Open3D (C++ API)  0.15.1
Material.h
Go to the documentation of this file.
1// ----------------------------------------------------------------------------
2// - Open3D: www.open3d.org -
3// ----------------------------------------------------------------------------
4// The MIT License (MIT)
5//
6// Copyright (c) 2018-2021 www.open3d.org
7//
8// Permission is hereby granted, free of charge, to any person obtaining a copy
9// of this software and associated documentation files (the "Software"), to deal
10// in the Software without restriction, including without limitation the rights
11// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12// copies of the Software, and to permit persons to whom the Software is
13// furnished to do so, subject to the following conditions:
14//
15// The above copyright notice and this permission notice shall be included in
16// all copies or substantial portions of the Software.
17//
18// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
21// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
23// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
24// IN THE SOFTWARE.
25// ----------------------------------------------------------------------------
26
27#pragma once
28
29#include <string>
30
32
33namespace open3d {
34namespace visualization {
35namespace rendering {
36
37struct MaterialRecord;
38
39class Material {
40public:
41 using TextureMaps = std::unordered_map<std::string, t::geometry::Image>;
42 using ScalarPropertyMap = std::unordered_map<std::string, float>;
43 using VectorPropertyMap = std::unordered_map<
44 std::string,
45 Eigen::Vector4f,
46 std::hash<std::string>,
47 std::equal_to<std::string>,
48 Eigen::aligned_allocator<
49 std::pair<const std::string, Eigen::Vector4f>>>;
50
52 Material() = default;
53
54 Material(const Material &mat) = default;
55
57 Material(const std::string &material_name)
58 : material_name_(material_name) {}
59
63
66 bool IsValid() const { return !material_name_.empty(); }
67
69 const std::string &GetMaterialName() const { return material_name_; }
70
72 const TextureMaps &GetTextureMaps() const { return texture_maps_; }
73
78 const t::geometry::Image &GetTextureMap(const std::string &key) const {
79 return texture_maps_.at(key);
80 }
81
84 return scalar_properties_;
85 }
86
91 float GetScalarProperty(const std::string &key) const {
92 return scalar_properties_.at(key);
93 }
94
97 return vector_properties_;
98 }
99
104 Eigen::Vector4f GetVectorProperty(const std::string &key) const {
105 return vector_properties_.at(key);
106 }
107
113 void SetTextureMap(const std::string &key, const t::geometry::Image &image);
114
120 void SetScalarProperty(const std::string &key, float value) {
121 scalar_properties_[key] = value;
122 }
123
129 void SetVectorProperty(const std::string &key,
130 const Eigen::Vector4f &value) {
131 vector_properties_[key] = value;
132 }
133
135 // in or user specified shader. The name is NOT checked to ensure it is
136 // valid.
139 void SetMaterialName(const std::string &material_name) {
140 material_name_ = material_name;
141 }
142
146 bool HasTextureMap(const std::string &key) const {
147 return texture_maps_.count(key) > 0;
148 }
149
153 bool HasScalarProperty(const std::string &key) const {
154 return scalar_properties_.count(key) > 0;
155 }
156
160 bool HasVectorProperty(const std::string &key) const {
161 return vector_properties_.count(key) > 0;
162 }
163
170 return GetTextureMap("albedo");
171 }
173 return GetTextureMap("normal");
174 }
176 return GetTextureMap("ambient_occlusion");
177 }
179 return GetTextureMap("metallic");
180 }
182 return GetTextureMap("roughness");
183 }
185 return GetTextureMap("reflectance");
186 }
188 return GetTextureMap("clear_coat");
189 }
191 return GetTextureMap("clear_coat_roughness");
192 }
194 return GetTextureMap("anisotropy");
195 }
199 return GetTextureMap("ao_rough_metal");
200 }
201
202 bool HasAlbedoMap() const { return HasTextureMap("albedo"); }
203 bool HasNormalMap() const { return HasTextureMap("normal"); }
204 bool HasAOMap() const { return HasTextureMap("ambient_occlusion"); }
205 bool HasMetallicMap() const { return HasTextureMap("metallic"); }
206 bool HasRoughnessMap() const { return HasTextureMap("roughness"); }
207 bool HasReflectanceMap() const { return HasTextureMap("reflectance"); }
208 bool HasClearcoatMap() const { return HasTextureMap("clear_coat"); }
210 return HasTextureMap("clear_coat_roughness");
211 }
212 bool HasAnisotropyMap() const { return HasTextureMap("anisotropy"); }
214 return HasTextureMap("ao_rough_metal");
215 }
216
218 SetTextureMap("albedo", image);
219 }
221 SetTextureMap("normal", image);
222 }
224 SetTextureMap("ambient_occlusion", image);
225 }
227 SetTextureMap("metallic", image);
228 }
230 SetTextureMap("roughness", image);
231 }
233 SetTextureMap("reflectance", image);
234 }
236 SetTextureMap("clear_coat", image);
237 }
239 SetTextureMap("clear_coat_roughness", image);
240 }
242 SetTextureMap("anisotropy", image);
243 }
245 SetTextureMap("ao_rough_metal", image);
246 }
247
248 Eigen::Vector4f GetBaseColor() const {
249 return GetVectorProperty("base_color");
250 }
251 float GetBaseMetallic() const { return GetScalarProperty("metallic"); }
252 float GetBaseRoughness() const { return GetScalarProperty("roughness"); }
253 float GetBaseReflectance() const {
254 return GetScalarProperty("reflectance");
255 }
256 float GetBaseClearcoat() const { return GetScalarProperty("clear_coat"); }
258 return GetScalarProperty("clear_coat_roughness");
259 }
260 float GetAnisotropy() const { return GetScalarProperty("anisotropy"); }
261 float GetThickness() const { return GetScalarProperty("thickness"); }
262 float GetTransmission() const { return GetScalarProperty("transmission"); }
263 Eigen::Vector4f GetAbsorptionColor() const {
264 return GetVectorProperty("absorption_color");
265 }
266 float GetAbsorptionDistance() const {
267 return GetScalarProperty("absorption_distance");
268 }
269
270 bool HasBaseColor() const { return HasVectorProperty("color"); }
271 bool HasBaseMetallic() const { return HasScalarProperty("metallic"); }
272 bool HasBaseRoughness() const { return HasScalarProperty("roughness"); }
273 bool HasBaseReflectance() const { return HasScalarProperty("reflectance"); }
274 bool HasBaseClearcoat() const { return HasScalarProperty("clear_coat"); }
276 return HasScalarProperty("clear_coat_roughness");
277 }
278 bool HasAnisotropy() const { return HasScalarProperty("anisotropy"); }
279 bool HasThickness() const { return HasScalarProperty("thickness"); }
280 bool HasTransmission() const { return HasScalarProperty("transmission"); }
281 bool HasAbsorptionColor() const {
282 return HasVectorProperty("absorption_color");
283 }
285 return HasScalarProperty("absorption_distance");
286 }
287
288 void SetBaseColor(const Eigen::Vector4f &value) {
289 SetVectorProperty("base_color", value);
290 }
291 void SetBaseMetallic(float value) { SetScalarProperty("metallic", value); }
292 void SetBaseRoughness(float value) {
293 SetScalarProperty("roughness", value);
294 }
295 void SetBaseReflectance(float value) {
296 SetScalarProperty("reflectance", value);
297 }
298 void SetBaseClearcoat(float value) {
299 SetScalarProperty("clear_coat", value);
300 }
301 void SetBaseClearcoatRoughness(float value) {
302 SetScalarProperty("clear_coat_roughness", value);
303 }
304 void SetAnisotropy(float value) { SetScalarProperty("anisotropy", value); }
305 void SetThickness(float value) { SetScalarProperty("thickness", value); }
306 void SetTransmission(float value) {
307 SetScalarProperty("transmission", value);
308 }
309 void SetAbsorptionColor(const Eigen::Vector4f &value) {
310 SetVectorProperty("absorption_color", value);
311 }
312 void SetAbsorptionDistance(float value) {
313 SetScalarProperty("absorption_distance", value);
314 }
315
322 float GetPointSize() const { return GetScalarProperty("point_size"); }
323 float GetLineWidth() const { return GetScalarProperty("line_width"); }
324
325 bool HasPointSize() const { return HasScalarProperty("point_size"); }
326 bool HasLineWidth() const { return HasScalarProperty("line_width"); }
327
328 void SetPointSize(float value) { SetScalarProperty("point_size", value); }
329 void SetLineWidth(float value) { SetScalarProperty("line_width", value); }
330
332 void ToMaterialRecord(MaterialRecord &record) const;
333
334private:
335 std::string material_name_;
336 TextureMaps texture_maps_;
337 ScalarPropertyMap scalar_properties_;
338 VectorPropertyMap vector_properties_;
339};
340
341} // namespace rendering
342} // namespace visualization
343} // namespace open3d
std::shared_ptr< core::Tensor > image
Definition: FilamentRenderer.cpp:228
The Image class stores image with customizable rows, cols, channels, dtype and device.
Definition: Image.h:48
void SetBaseRoughness(float value)
Definition: Material.h:292
std::unordered_map< std::string, t::geometry::Image > TextureMaps
Definition: Material.h:41
bool HasScalarProperty(const std::string &key) const
Definition: Material.h:153
void SetBaseClearcoatRoughness(float value)
Definition: Material.h:301
void SetPointSize(float value)
Definition: Material.h:328
void SetAlbedoMap(const t::geometry::Image &image)
Definition: Material.h:217
void SetAbsorptionColor(const Eigen::Vector4f &value)
Definition: Material.h:309
bool HasReflectanceMap() const
Definition: Material.h:207
bool HasBaseMetallic() const
Definition: Material.h:271
bool HasAORoughnessMetalMap() const
Definition: Material.h:213
bool HasThickness() const
Definition: Material.h:279
bool HasRoughnessMap() const
Definition: Material.h:206
void SetMaterialName(const std::string &material_name)
Set material name. The material name should match the name of a built.
Definition: Material.h:139
bool HasBaseReflectance() const
Definition: Material.h:273
Eigen::Vector4f GetBaseColor() const
Definition: Material.h:248
const t::geometry::Image & GetNormalMap() const
Definition: Material.h:172
void SetAOMap(const t::geometry::Image &image)
Definition: Material.h:223
const t::geometry::Image & GetAlbedoMap() const
Definition: Material.h:169
void SetScalarProperty(const std::string &key, float value)
Definition: Material.h:120
void SetAnisotropy(float value)
Definition: Material.h:304
void SetDefaultProperties()
Definition: Material.cpp:35
bool HasAnisotropyMap() const
Definition: Material.h:212
bool HasAOMap() const
Definition: Material.h:204
const t::geometry::Image & GetAOMap() const
Definition: Material.h:175
bool HasLineWidth() const
Definition: Material.h:326
const t::geometry::Image & GetClearcoatMap() const
Definition: Material.h:187
const t::geometry::Image & GetAORoughnessMetalMap() const
Definition: Material.h:198
bool IsValid() const
Definition: Material.h:66
const t::geometry::Image & GetMetallicMap() const
Definition: Material.h:178
bool HasAnisotropy() const
Definition: Material.h:278
void SetAORoughnessMetalMap(const t::geometry::Image &image)
Definition: Material.h:244
bool HasBaseClearcoatRoughness() const
Definition: Material.h:275
void SetThickness(float value)
Definition: Material.h:305
void SetReflectanceMap(const t::geometry::Image &image)
Definition: Material.h:232
float GetThickness() const
Definition: Material.h:261
std::unordered_map< std::string, float > ScalarPropertyMap
Definition: Material.h:42
bool HasVectorProperty(const std::string &key) const
Definition: Material.h:160
const VectorPropertyMap & GetVectorProperties() const
Returns the map of vector properties.
Definition: Material.h:96
void SetBaseReflectance(float value)
Definition: Material.h:295
bool HasBaseClearcoat() const
Definition: Material.h:274
const t::geometry::Image & GetClearcoatRoughnessMap() const
Definition: Material.h:190
float GetBaseClearcoat() const
Definition: Material.h:256
float GetPointSize() const
Definition: Material.h:322
void SetTextureMap(const std::string &key, const t::geometry::Image &image)
Definition: Material.cpp:52
float GetBaseMetallic() const
Definition: Material.h:251
void SetAbsorptionDistance(float value)
Definition: Material.h:312
bool HasClearcoatRoughnessMap() const
Definition: Material.h:209
void SetAnisotropyMap(const t::geometry::Image &image)
Definition: Material.h:241
void SetVectorProperty(const std::string &key, const Eigen::Vector4f &value)
Definition: Material.h:129
void SetNormalMap(const t::geometry::Image &image)
Definition: Material.h:220
const std::string & GetMaterialName() const
Get the name of the material.
Definition: Material.h:69
const t::geometry::Image & GetRoughnessMap() const
Definition: Material.h:181
const t::geometry::Image & GetTextureMap(const std::string &key) const
Definition: Material.h:78
bool HasAlbedoMap() const
Definition: Material.h:202
bool HasMetallicMap() const
Definition: Material.h:205
Eigen::Vector4f GetVectorProperty(const std::string &key) const
Definition: Material.h:104
float GetBaseReflectance() const
Definition: Material.h:253
bool HasBaseColor() const
Definition: Material.h:270
void SetBaseClearcoat(float value)
Definition: Material.h:298
float GetScalarProperty(const std::string &key) const
Definition: Material.h:91
float GetBaseRoughness() const
Definition: Material.h:252
float GetAbsorptionDistance() const
Definition: Material.h:266
const TextureMaps & GetTextureMaps() const
Returns the texture map map.
Definition: Material.h:72
void SetTransmission(float value)
Definition: Material.h:306
Eigen::Vector4f GetAbsorptionColor() const
Definition: Material.h:263
const ScalarPropertyMap & GetScalarProperties() const
Returns the map of scalar properties.
Definition: Material.h:83
Material()=default
Create an empty, invalid material.
const t::geometry::Image & GetReflectanceMap() const
Definition: Material.h:184
bool HasBaseRoughness() const
Definition: Material.h:272
std::unordered_map< std::string, Eigen::Vector4f, std::hash< std::string >, std::equal_to< std::string >, Eigen::aligned_allocator< std::pair< const std::string, Eigen::Vector4f > > > VectorPropertyMap
Definition: Material.h:49
void SetClearcoatRoughnessMap(const t::geometry::Image &image)
Definition: Material.h:238
void SetBaseMetallic(float value)
Definition: Material.h:291
const t::geometry::Image & GetAnisotropyMap() const
Definition: Material.h:193
bool HasNormalMap() const
Definition: Material.h:203
bool HasPointSize() const
Definition: Material.h:325
float GetAnisotropy() const
Definition: Material.h:260
bool HasTextureMap(const std::string &key) const
Definition: Material.h:146
bool HasTransmission() const
Definition: Material.h:280
float GetBaseClearcoatRoughness() const
Definition: Material.h:257
float GetTransmission() const
Definition: Material.h:262
void SetClearcoatMap(const t::geometry::Image &image)
Definition: Material.h:235
void SetRoughnessMap(const t::geometry::Image &image)
Definition: Material.h:229
void ToMaterialRecord(MaterialRecord &record) const
Fills a legacy MaterialRecord constructed from this Material.
Definition: Material.cpp:61
Material(const Material &mat)=default
void SetMetallicMap(const t::geometry::Image &image)
Definition: Material.h:226
bool HasAbsorptionColor() const
Definition: Material.h:281
Material(const std::string &material_name)
Create an empty but valid material for the specified material name.
Definition: Material.h:57
bool HasClearcoatMap() const
Definition: Material.h:208
float GetLineWidth() const
Definition: Material.h:323
void SetLineWidth(float value)
Definition: Material.h:329
bool HasAbsorptionDistance() const
Definition: Material.h:284
void SetBaseColor(const Eigen::Vector4f &value)
Definition: Material.h:288
Definition: PinholeCameraIntrinsic.cpp:35