Open3D (C++ API)  0.16.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
56 Material &operator=(const Material &other) = default;
57
59 Material(const std::string &material_name)
60 : material_name_(material_name) {}
61
65
68 bool IsValid() const { return !material_name_.empty(); }
69
71 const std::string &GetMaterialName() const { return material_name_; }
72
74 const TextureMaps &GetTextureMaps() const { return texture_maps_; }
75
80 const t::geometry::Image &GetTextureMap(const std::string &key) const {
81 return texture_maps_.at(key);
82 }
83
86 return scalar_properties_;
87 }
88
93 float GetScalarProperty(const std::string &key) const {
94 return scalar_properties_.at(key);
95 }
96
99 return vector_properties_;
100 }
101
106 Eigen::Vector4f GetVectorProperty(const std::string &key) const {
107 return vector_properties_.at(key);
108 }
109
115 void SetTextureMap(const std::string &key, const t::geometry::Image &image);
116
122 void SetScalarProperty(const std::string &key, float value) {
123 scalar_properties_[key] = value;
124 }
125
131 void SetVectorProperty(const std::string &key,
132 const Eigen::Vector4f &value) {
133 vector_properties_[key] = value;
134 }
135
137 // in or user specified shader. The name is NOT checked to ensure it is
138 // valid.
141 void SetMaterialName(const std::string &material_name) {
142 material_name_ = material_name;
143 }
144
148 bool HasTextureMap(const std::string &key) const {
149 return texture_maps_.count(key) > 0;
150 }
151
155 bool HasScalarProperty(const std::string &key) const {
156 return scalar_properties_.count(key) > 0;
157 }
158
162 bool HasVectorProperty(const std::string &key) const {
163 return vector_properties_.count(key) > 0;
164 }
165
172 return GetTextureMap("albedo");
173 }
175 return GetTextureMap("normal");
176 }
178 return GetTextureMap("ambient_occlusion");
179 }
181 return GetTextureMap("metallic");
182 }
184 return GetTextureMap("roughness");
185 }
187 return GetTextureMap("reflectance");
188 }
190 return GetTextureMap("clear_coat");
191 }
193 return GetTextureMap("clear_coat_roughness");
194 }
196 return GetTextureMap("anisotropy");
197 }
201 return GetTextureMap("ao_rough_metal");
202 }
203
204 bool HasAlbedoMap() const { return HasTextureMap("albedo"); }
205 bool HasNormalMap() const { return HasTextureMap("normal"); }
206 bool HasAOMap() const { return HasTextureMap("ambient_occlusion"); }
207 bool HasMetallicMap() const { return HasTextureMap("metallic"); }
208 bool HasRoughnessMap() const { return HasTextureMap("roughness"); }
209 bool HasReflectanceMap() const { return HasTextureMap("reflectance"); }
210 bool HasClearcoatMap() const { return HasTextureMap("clear_coat"); }
212 return HasTextureMap("clear_coat_roughness");
213 }
214 bool HasAnisotropyMap() const { return HasTextureMap("anisotropy"); }
216 return HasTextureMap("ao_rough_metal");
217 }
218
220 SetTextureMap("albedo", image);
221 }
223 SetTextureMap("normal", image);
224 }
226 SetTextureMap("ambient_occlusion", image);
227 }
229 SetTextureMap("metallic", image);
230 }
232 SetTextureMap("roughness", image);
233 }
235 SetTextureMap("reflectance", image);
236 }
238 SetTextureMap("clear_coat", image);
239 }
241 SetTextureMap("clear_coat_roughness", image);
242 }
244 SetTextureMap("anisotropy", image);
245 }
247 SetTextureMap("ao_rough_metal", image);
248 }
249
250 Eigen::Vector4f GetBaseColor() const {
251 return GetVectorProperty("base_color");
252 }
253 float GetBaseMetallic() const { return GetScalarProperty("metallic"); }
254 float GetBaseRoughness() const { return GetScalarProperty("roughness"); }
255 float GetBaseReflectance() const {
256 return GetScalarProperty("reflectance");
257 }
258 float GetBaseClearcoat() const { return GetScalarProperty("clear_coat"); }
260 return GetScalarProperty("clear_coat_roughness");
261 }
262 float GetAnisotropy() const { return GetScalarProperty("anisotropy"); }
263 float GetThickness() const { return GetScalarProperty("thickness"); }
264 float GetTransmission() const { return GetScalarProperty("transmission"); }
265 Eigen::Vector4f GetAbsorptionColor() const {
266 return GetVectorProperty("absorption_color");
267 }
268 float GetAbsorptionDistance() const {
269 return GetScalarProperty("absorption_distance");
270 }
271
272 bool HasBaseColor() const { return HasVectorProperty("color"); }
273 bool HasBaseMetallic() const { return HasScalarProperty("metallic"); }
274 bool HasBaseRoughness() const { return HasScalarProperty("roughness"); }
275 bool HasBaseReflectance() const { return HasScalarProperty("reflectance"); }
276 bool HasBaseClearcoat() const { return HasScalarProperty("clear_coat"); }
278 return HasScalarProperty("clear_coat_roughness");
279 }
280 bool HasAnisotropy() const { return HasScalarProperty("anisotropy"); }
281 bool HasThickness() const { return HasScalarProperty("thickness"); }
282 bool HasTransmission() const { return HasScalarProperty("transmission"); }
283 bool HasAbsorptionColor() const {
284 return HasVectorProperty("absorption_color");
285 }
287 return HasScalarProperty("absorption_distance");
288 }
289
290 void SetBaseColor(const Eigen::Vector4f &value) {
291 SetVectorProperty("base_color", value);
292 }
293 void SetBaseMetallic(float value) { SetScalarProperty("metallic", value); }
294 void SetBaseRoughness(float value) {
295 SetScalarProperty("roughness", value);
296 }
297 void SetBaseReflectance(float value) {
298 SetScalarProperty("reflectance", value);
299 }
300 void SetBaseClearcoat(float value) {
301 SetScalarProperty("clear_coat", value);
302 }
303 void SetBaseClearcoatRoughness(float value) {
304 SetScalarProperty("clear_coat_roughness", value);
305 }
306 void SetAnisotropy(float value) { SetScalarProperty("anisotropy", value); }
307 void SetThickness(float value) { SetScalarProperty("thickness", value); }
308 void SetTransmission(float value) {
309 SetScalarProperty("transmission", value);
310 }
311 void SetAbsorptionColor(const Eigen::Vector4f &value) {
312 SetVectorProperty("absorption_color", value);
313 }
314 void SetAbsorptionDistance(float value) {
315 SetScalarProperty("absorption_distance", value);
316 }
317
324 float GetPointSize() const { return GetScalarProperty("point_size"); }
325 float GetLineWidth() const { return GetScalarProperty("line_width"); }
326
327 bool HasPointSize() const { return HasScalarProperty("point_size"); }
328 bool HasLineWidth() const { return HasScalarProperty("line_width"); }
329
330 void SetPointSize(float value) { SetScalarProperty("point_size", value); }
331 void SetLineWidth(float value) { SetScalarProperty("line_width", value); }
332
334 void ToMaterialRecord(MaterialRecord &record) const;
335
336private:
337 std::string material_name_;
338 TextureMaps texture_maps_;
339 ScalarPropertyMap scalar_properties_;
340 VectorPropertyMap vector_properties_;
341};
342
343} // namespace rendering
344} // namespace visualization
345} // namespace open3d
std::shared_ptr< core::Tensor > image
Definition: FilamentRenderer.cpp:202
The Image class stores image with customizable rows, cols, channels, dtype and device.
Definition: Image.h:48
void SetBaseRoughness(float value)
Definition: Material.h:294
std::unordered_map< std::string, t::geometry::Image > TextureMaps
Definition: Material.h:41
bool HasScalarProperty(const std::string &key) const
Definition: Material.h:155
void SetBaseClearcoatRoughness(float value)
Definition: Material.h:303
void SetPointSize(float value)
Definition: Material.h:330
void SetAlbedoMap(const t::geometry::Image &image)
Definition: Material.h:219
void SetAbsorptionColor(const Eigen::Vector4f &value)
Definition: Material.h:311
bool HasReflectanceMap() const
Definition: Material.h:209
bool HasBaseMetallic() const
Definition: Material.h:273
bool HasAORoughnessMetalMap() const
Definition: Material.h:215
bool HasThickness() const
Definition: Material.h:281
bool HasRoughnessMap() const
Definition: Material.h:208
void SetMaterialName(const std::string &material_name)
Set material name. The material name should match the name of a built.
Definition: Material.h:141
bool HasBaseReflectance() const
Definition: Material.h:275
Eigen::Vector4f GetBaseColor() const
Definition: Material.h:250
const t::geometry::Image & GetNormalMap() const
Definition: Material.h:174
void SetAOMap(const t::geometry::Image &image)
Definition: Material.h:225
const t::geometry::Image & GetAlbedoMap() const
Definition: Material.h:171
void SetScalarProperty(const std::string &key, float value)
Definition: Material.h:122
void SetAnisotropy(float value)
Definition: Material.h:306
void SetDefaultProperties()
Definition: Material.cpp:35
bool HasAnisotropyMap() const
Definition: Material.h:214
bool HasAOMap() const
Definition: Material.h:206
const t::geometry::Image & GetAOMap() const
Definition: Material.h:177
bool HasLineWidth() const
Definition: Material.h:328
const t::geometry::Image & GetClearcoatMap() const
Definition: Material.h:189
const t::geometry::Image & GetAORoughnessMetalMap() const
Definition: Material.h:200
bool IsValid() const
Definition: Material.h:68
const t::geometry::Image & GetMetallicMap() const
Definition: Material.h:180
bool HasAnisotropy() const
Definition: Material.h:280
void SetAORoughnessMetalMap(const t::geometry::Image &image)
Definition: Material.h:246
bool HasBaseClearcoatRoughness() const
Definition: Material.h:277
void SetThickness(float value)
Definition: Material.h:307
void SetReflectanceMap(const t::geometry::Image &image)
Definition: Material.h:234
float GetThickness() const
Definition: Material.h:263
std::unordered_map< std::string, float > ScalarPropertyMap
Definition: Material.h:42
bool HasVectorProperty(const std::string &key) const
Definition: Material.h:162
const VectorPropertyMap & GetVectorProperties() const
Returns the map of vector properties.
Definition: Material.h:98
void SetBaseReflectance(float value)
Definition: Material.h:297
bool HasBaseClearcoat() const
Definition: Material.h:276
const t::geometry::Image & GetClearcoatRoughnessMap() const
Definition: Material.h:192
float GetBaseClearcoat() const
Definition: Material.h:258
float GetPointSize() const
Definition: Material.h:324
void SetTextureMap(const std::string &key, const t::geometry::Image &image)
Definition: Material.cpp:52
float GetBaseMetallic() const
Definition: Material.h:253
void SetAbsorptionDistance(float value)
Definition: Material.h:314
bool HasClearcoatRoughnessMap() const
Definition: Material.h:211
void SetAnisotropyMap(const t::geometry::Image &image)
Definition: Material.h:243
void SetVectorProperty(const std::string &key, const Eigen::Vector4f &value)
Definition: Material.h:131
void SetNormalMap(const t::geometry::Image &image)
Definition: Material.h:222
const std::string & GetMaterialName() const
Get the name of the material.
Definition: Material.h:71
const t::geometry::Image & GetRoughnessMap() const
Definition: Material.h:183
const t::geometry::Image & GetTextureMap(const std::string &key) const
Definition: Material.h:80
bool HasAlbedoMap() const
Definition: Material.h:204
bool HasMetallicMap() const
Definition: Material.h:207
Eigen::Vector4f GetVectorProperty(const std::string &key) const
Definition: Material.h:106
float GetBaseReflectance() const
Definition: Material.h:255
bool HasBaseColor() const
Definition: Material.h:272
void SetBaseClearcoat(float value)
Definition: Material.h:300
float GetScalarProperty(const std::string &key) const
Definition: Material.h:93
float GetBaseRoughness() const
Definition: Material.h:254
float GetAbsorptionDistance() const
Definition: Material.h:268
const TextureMaps & GetTextureMaps() const
Returns the texture map map.
Definition: Material.h:74
void SetTransmission(float value)
Definition: Material.h:308
Eigen::Vector4f GetAbsorptionColor() const
Definition: Material.h:265
const ScalarPropertyMap & GetScalarProperties() const
Returns the map of scalar properties.
Definition: Material.h:85
Material()=default
Create an empty, invalid material.
const t::geometry::Image & GetReflectanceMap() const
Definition: Material.h:186
bool HasBaseRoughness() const
Definition: Material.h:274
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:240
void SetBaseMetallic(float value)
Definition: Material.h:293
const t::geometry::Image & GetAnisotropyMap() const
Definition: Material.h:195
bool HasNormalMap() const
Definition: Material.h:205
bool HasPointSize() const
Definition: Material.h:327
float GetAnisotropy() const
Definition: Material.h:262
bool HasTextureMap(const std::string &key) const
Definition: Material.h:148
bool HasTransmission() const
Definition: Material.h:282
float GetBaseClearcoatRoughness() const
Definition: Material.h:259
float GetTransmission() const
Definition: Material.h:264
void SetClearcoatMap(const t::geometry::Image &image)
Definition: Material.h:237
void SetRoughnessMap(const t::geometry::Image &image)
Definition: Material.h:231
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:228
bool HasAbsorptionColor() const
Definition: Material.h:283
Material(const std::string &material_name)
Create an empty but valid material for the specified material name.
Definition: Material.h:59
bool HasClearcoatMap() const
Definition: Material.h:210
Material & operator=(const Material &other)=default
float GetLineWidth() const
Definition: Material.h:325
void SetLineWidth(float value)
Definition: Material.h:331
bool HasAbsorptionDistance() const
Definition: Material.h:286
void SetBaseColor(const Eigen::Vector4f &value)
Definition: Material.h:290
Definition: PinholeCameraIntrinsic.cpp:35