12 #ifndef __RE_Material_h__
13 #define __RE_Material_h__
56 if(myDirtyFlag || myDepNode.isDirty())
58 if(myTimeDep && !SYSisEqual(time, myTime))
66 myTime = timedep ?
t : 0.0;
74 if (!myRefCount.add(-1))
85 { myMatNetName = mat_path; }
87 {
return myMatNetName; }
90 void dirtyMatNet(
bool dirty =
true) { myMatNetDirty = dirty; }
95 void setOverrides(
const UT_Options *overrides);
97 bool hasOverrides()
const {
return myOverrides.getNumOptions()>0; }
101 { myVertexOverrides = ovr; }
103 {
return myVertexOverrides; }
113 void setMaterialType(RE_MaterialType
type);
120 void assignShaderRef(
int shader_program_id,
132 void clearDiffuseMap();
134 void reserveDiffuseLayers(
int nlayers);
168 bool mat_changed =
true);
172 bool mat_change =
true);
174 bool mat_change =
true);
176 bool mat_change =
true);
178 bool mat_change =
true);
180 bool mat_change =
true);
182 bool mat_change =
true);
184 bool mat_change =
true);
186 bool mat_change =
true);
188 bool mat_change =
true);
190 bool mat_change =
true);
192 bool mat_change =
true);
194 bool mat_change =
true);
212 static bool fetchRegOrUDIM(
const UT_StringRef &tex_name,
215 bool allow_preload =
false,
216 const char *uvtile_marker =
nullptr);
220 void clearTextureLayer(
int layer);
225 bool hasBumpMap()
const {
return myBumpMap.myTex.isValid(); }
229 bool hasEnvMap()
const {
return myEnvMap.myTex.isValid(); }
231 {
return myEmissionMap.myTex.isValid(); }
233 {
return myRoughMap.myTex.isValid(); }
235 {
return myOcclusionMap.myTex.isValid(); }
237 {
return myMetallicMap.myTex.isValid(); }
239 {
return myCoatRoughMap.myTex.isValid(); }
241 {
return myCoatIntMap.myTex.isValid(); }
243 {
return myReflectAmountMap.myTex.isValid(); }
246 {
return myHairDiffMap.myTex.isValid(); }
248 {
return myHairSpecMap.myTex.isValid(); }
250 {
return myHairDiffRamp.myTex.isValid(); }
252 {
return myHairSpecRamp.myTex.isValid(); }
254 {
return myHairAlphaRamp.myTex.isValid(); }
258 bool isTransparent(
bool check_diffuse_alpha)
const;
273 void setNumMatXTextures(
int num);
278 void finishTextureSetup(
RE_Render *
r,
bool preload);
279 bool checkForCacheUpdate(
int cache_serial,
fpreal t);
296 void limitTextureSize(
bool limit,
int w,
int h);
302 void setTextureScale(
float sc);
305 void setTextureMemLimitMB(
int mem);
308 void mipMapTextures(
bool yes);
311 void setAnisotropySamples(
int samp);
318 void doLighting(
bool yes );
319 bool isLit()
const {
return myDoLighting; }
322 const char *
name =
nullptr,
327 {
return myOwnShader[sht]; }
330 void setShaderSource(
const char *vert_src,
331 const char *geom_src,
332 const char *frag_src,
338 bool hasShaderSource(
const char *vert_src,
339 const char *geom_src,
340 const char *frag_src,
344 void setShaderProgram(
const char *program_file);
345 bool hasShaderProgram(
const char *program_file)
const;
348 {
return myShaderProgramFile.isstring() ||
349 myVertexSource[ptype].isstring() ||
350 myGeometrySource[ptype].isstring() ||
351 myFragmentSource[ptype].isstring(); }
357 float amb(
unsigned idx )
const {
return myAmb[idx]; }
359 float diff(
unsigned idx )
const {
return myDiff[idx]; }
361 float spec(
unsigned idx )
const {
return mySpec[idx]; }
363 float emit(
unsigned idx )
const {
return myEmit[idx]; }
367 float alpha()
const {
return myAlpha; }
376 void setAlpha(
float alpha_perp,
float alpha_para = -1.0 );
385 void setAlphaMode(AlphaMode
mode);
387 {
return myAlphaMode; }
389 void setAlphaCutoff(
fpreal alpha_val);
392 return (myAlphaMode != IGNORE_ALPHA) ? myAlphaCutoff : 0.0;
401 { myShaderAlphaFlag =
enabled; }
405 void setRoughness(
float r );
408 void setShininess(
float sh );
410 void setDiffuseRoughness(
fpreal r);
412 void setAmb(
float r,
float g,
float b );
413 void setDiff(
float r,
float g,
float b );
414 void setSpec(
float r,
float g,
float b );
415 void setEmit(
float r,
float g,
float b );
416 void setMetallic(
float metal);
429 void setSpecularTint(
fpreal t);
432 enum { PHONG=0, BLINN=1, GGX=2, SPEC_ANGLE=3 };
433 void setSpecularModel(
int spec_model);
435 void setCoatSpecularModel(
int spec_model);
437 void setCoatIntensity(
fpreal i);
439 void setCoatRoughness(
fpreal r);
442 void setIOR(
float ior);
445 void setReflection(
float r,
bool explicit_r);
446 fpreal getReflection()
const;
448 void usePackedColor(
bool enable);
449 void useGeometryColor(
bool enable);
459 return myNeedsTangentSpace ||
460 (myNormalMap.myMap &&
461 myNormalMapType == NMLMAP_TANGENT);
467 void setOpacityMapParms(
bool invert,
int component);
468 void setNormalParms(re_NormalMapType
type,
bool bias,
470 bool flip_x,
bool flip_y,
bool flip_z);
478 DISPLACE_VECTOR_OBJECT };
479 void setDisplaceParms(
float scale,
float offset,
float quality,
480 re_Displace vector_space,
bool y_up);
483 void setRoughParms(
bool invert_map,
int component);
484 void setOcclusionParms(
int component);
485 void setMetallicParms(
int component);
486 void setCoatRoughnessParms(
int component);
487 void setCoatIntensityParms(
int component);
488 void setReflectionAmountParms(
int component,
bool affect_ior);
489 void setEmissionParms(
bool use_matcap);
491 bool hasDisplacement()
const;
493 void setUVTransform(RE_TexMapType maptype,
496 void clearUVTransform(RE_TexMapType maptype,
502 void setHairDiffuse(
float intensity,
508 void setHairSpecular(
float intensity,
515 void setHairAlpha(
float alpha,
516 bool use_alpha_ramp);
519 void setHairRandomize(
bool random_hue,
UT_Vector2F hue_range,
522 bool random_spec_int,
528 void setUVTransform(
int layer,
532 void getUVTransform(
int layer,
540 void setUVTriplanar(
int layer,
545 bool isUVTriplanar(
int layer)
const;
546 fpreal getUVTriplanarSharp(
int layer)
const;
547 fpreal getUVTriplanarScale(
int layer)
const;
550 bool getUVLayerUseTint(
int layer)
const;
552 fpreal getUVLayerRough(
int layer)
const;
560 static void clearEnvMapOverride();
573 bool loadTextureMaps(
RE_Render *
r,
bool preload_only =
false);
583 RE_TexMapType maptype,
586 void removeTextureMap(RE_TexMapType maptype,
591 RE_TexMapType maptype,
594 void clearTextureMap(RE_TexMapType maptype,
601 {
return myMaterialType==FILM_SURFACE ?myNumDiffuseLayers :1; }
603 bool updateShaderForMaterial(
609 bool allow_partial =
false);
615 int64 getMemoryUsage(
bool inclusive)
const;
618 void writeMaterialParmsToBlockGL4(
RE_Render *
r,
626 void removeTexturesFromResident(
RE_Render *
r);
630 void updateMaterialBlock(
int layer);
633 {
return myMaterialBlock; }
635 {
return myHairMaterialBlock; }
637 {
return myGameMaterialBlock; }
640 void loadShaderAttribNames();
642 class re_MaterialTextureMap
645 re_MaterialTextureMap()
646 : myMap(nullptr), myMapIndex(-1),
647 myArrayMapIndex(-1), myTexCoords(0), myComponent(0),
648 myExplicitMap(false), myOwnMap(false) {}
649 ~re_MaterialTextureMap()
666 re_MaterialTextureMap *fetchMapInfo(RE_TexMapType
t,
670 bool preload_only =
false,
673 RE_TexMapType map_target,
674 re_MaterialTextureMap &map,
676 bool promote_1chan_to_rgb =
false);
678 bool bindTextureMap(
RE_Render *
r, re_MaterialTextureMap &map,
679 const char *udim_stride_name,
681 const char *component_name =
nullptr);
682 void bindUVTransform(RE_TexMapType
type,
684 void bindComponentAndUDIM(re_MaterialTextureMap &map,
685 const char *udim_area_name,
686 const char *component_name =
nullptr);
687 void bindTextureMaps(
RE_Render *
r,
int layer);
691 void updateHairMaterialForShader(
RE_Render *
r,
695 void updateGameMaterialForShader(
RE_Render *
r,
704 re_MaterialTextureMap &map,
707 const char *texture_name);
711 const re_MaterialTextureMap &map)
const;
722 float myDiffRoughness;
724 RE_MaterialType myMaterialType;
725 AlphaMode myAlphaMode;
733 re_MaterialTextureMap mySpecMap;
734 re_MaterialTextureMap myOpacityMap;
735 re_MaterialTextureMap myBumpMap;
736 re_MaterialTextureMap myRoughMap;
737 re_MaterialTextureMap myEmissionMap;
738 re_MaterialTextureMap myNormalMap;
739 re_MaterialTextureMap myDisplaceMap;
740 re_MaterialTextureMap myOcclusionMap;
741 re_MaterialTextureMap myMetallicMap;
742 re_MaterialTextureMap myCoatRoughMap;
743 re_MaterialTextureMap myCoatIntMap;
744 re_MaterialTextureMap myReflectAmountMap;
745 re_MaterialTextureMap myGameBlendMap;
746 re_MaterialTextureMap myEnvMap;
747 re_MaterialTextureMap myHairDiffMap;
748 re_MaterialTextureMap myHairSpecMap;
749 re_MaterialTextureMap myHairDiffRamp;
750 re_MaterialTextureMap myHairSpecRamp;
751 re_MaterialTextureMap myHairAlphaRamp;
768 unsigned myDoLighting:1,
770 myLimitTextureSize:1,
773 myTrivialTextureAlpha:1,
776 myTextureLoadPending:1,
777 myCustomShaderDirty:1,
783 myNeedsTangentSpace:1;
784 int myTextureAnisotropy;
785 int myNumDiffuseLayers;
788 int myMaxTextureW, myMaxTextureH;
789 float myTextureScale;
790 int myTextureMemLimitMB;
792 bool myShaderAlphaFlag;
794 bool myUsePackedColor;
802 bool myExplicitReflection;
815 re_NormalMapType myNormalMapType;
823 float myDisplaceScale;
824 float myDisplaceOffset;
825 float myDisplaceQuality;
826 re_Displace myDisplaceSpace;
830 bool myOpacityMapInvert;
834 bool myEmissionMatCap;
845 int myMaterialOverride;
846 bool myMatBlockDirty;
847 bool myMatBlockHasEnvMapTexture;
848 bool myMatBlockHasReflectMapTexture;
849 bool myMatBlockHasDiffuseTexture;
852 int myTextureCacheSerial;
855 class re_HairCompParms
858 re_HairCompParms() : intensity(0.5), shift(0.0),
angle(1.0),
859 root_col(1,1,1), tip_col(1,1,1),
860 use_ramp(false), use_map(false) {}
869 struct re_HairRandomParms
871 re_HairRandomParms() : randomize(false) {}
876 bool myHairMaterialEnabled;
877 re_HairCompParms myHairDiffuse;
878 re_HairCompParms myHairSpecular;
880 bool myHairUseAlphaRamp;
881 re_HairRandomParms myHairRandomDiffHue;
882 re_HairRandomParms myHairRandomDiffSat;
883 re_HairRandomParms myHairRandomDiffInt;
884 re_HairRandomParms myHairRandomSpecInt;
886 int myHairMatBlockIndex;
887 int myHairRandomTextureIndex;
888 int myHairDiffBaseMapIndex;
896 int myMatBlockDiffuseIndex;
897 int myMatBlockDiffuseArrayIndex;
899 int myMatBlockEnvMapIndex;
900 int myMatBlockReflectMapIndex;
902 int myHairMaterialOverride;
905 void *myLastHairShader;
906 int myLastHairShaderSerial;
908 int myHairDiffArrayIndex;
910 int myHairSpecArrayIndex;
911 int myHairDiffRampIndex;
912 int myHairSpecRampIndex;
913 int myHairAlphaRampIndex;
914 int myMatBlockHairIndex;
918 int myGameMaterialOverride;
922 re_GameLayer() : triplanar(false),
scale(1,1),
trans(0,0),
rot(0),
924 tpblend(1,1,1), tpoff(0,0,0), use_tint(false),
925 tint(1.0, 1.0, 1.0, 1.0), rough(1.0) {}
941 int myLastGameShaderSerial;
942 int myGameBlendIndex;
943 int myGameMatBlockIndex;
945 int myPrevSeamlessCubeMap;
960 re_UVTransform() :
transform(1.0), identity(true) {}
997 if(cache_serial != myTextureCacheSerial)
999 myTextureCacheSerial = cache_serial;
1000 myNeedsTexUpdate =
true;
1003 if(myTimeDep && !SYSisEqual(t, myTime))
1005 myNeedsTexUpdate =
true;
1025 return myShader[sht];
1026 if(myShaderRef[sht] != 0)
1035 return myShaderRef[sht];
1047 {
return myDefault; }
1051 {
return myFactory; }
1057 if(material_id == -1)
1058 return myDefault ? myDefault : myFactory;
1061 return entry->second;
1069 { (*this)[ material->getUniqueId() ] = material; }
1074 { myDefault = material;
if(add_list && material)
add(material); }
1079 { myFactory = material;
if(add_list && material)
add(material); }
void setDiffuse(UT_Color col)
bool mipMapTextures() const
void setTextured(bool has_tex)
GLboolean GLboolean GLboolean b
bool hasOverrides() const
bool hasHairDiffuseMap() const
void setNeedsUVs(bool uvs)
float getDisplaceLOD() const
bool hasOpacityMap() const
GLenum GLenum GLenum GLenum GLenum scale
const UT_StringHolder & getNodePath() const
void dirty(bool dirty=true)
GLenum GLuint GLint GLint layer
bool isTimeDependent() const
void setMatNetName(const UT_StringRef &mat_path)
GA_API const UT_StringHolder uv
GT_API const UT_StringHolder time
GLsizei const GLchar *const * path
const RE_UniformBlockHandle & hairBlock() const
GA_API const UT_StringHolder rot
bool isMatCapTextured() const
void setEmit(float r, float g, float b)
int getSpecularModel() const
constexpr SYS_FORCE_INLINE T & z() noexcept
bool areTexturesPending()
void setShaderAlpha(bool enabled)
bool hasShaderAlpha() const
const RE_MaterialPtr & getDefaultMaterial() const
bool hasTessellation() const
void setSpecular(UT_Color col)
bool hasCoatIntensityMap() const
const UT_Options & getOverrides() const
void setSpec(float r, float g, float b)
GLenum GLenum GLsizei const GLuint GLboolean enabled
bool hasRoughnessMap() const
GLuint const GLchar * name
fpreal getCurrentTime() const
int getTextureMemLimitMB() const
const UT_StringMap< UT_StringHolder > & vertexOverrides() const
void setAmb(float r, float g, float b)
int getAnisotropySamples() const
bool isShaderOwned(RE_ShaderTarget sht=RE_SHADER_TARGET_TRIANGLE) const
static RE_Shader * lookupProgram(int id)
std::unique_ptr< T, Deleter > UT_UniquePtr
A smart pointer for unique ownership of dynamically allocated objects.
GLubyte GLubyte GLubyte GLubyte w
bool needsTangentSpace() const
bool isMatNetDirty() const
GLuint GLenum GLenum transform
vint4 blend(const vint4 &a, const vint4 &b, const vbool4 &mask)
RE_MaterialType getMaterialType() const
bool hasHairSpecularRamp() const
float amb(unsigned idx) const
DEP_MicroNode & dependencies()
void setFactoryMaterial(const RE_MaterialPtr &material, bool add_list=true)
const RE_UniformBlockHandle & materialBlock() const
void intrusive_ptr_release(T *x)
bool hasDisplaceMap() const
int getCoatSpecuarModel() const
const RE_UniformBlockHandle & gameMatBlock() const
GA_API const UT_StringHolder trans
bool hasHairDiffuseRamp() const
bool hasReflectionAmountMap() const
void setMatXNodeVersion(int64 version)
bool hasNormalMap() const
void setReflectionMap(RE_Texture *map)
bool usePackedColor() const
bool limitTextureSize() const
void setTimeDependent(bool timedep, fpreal t=0.0)
RE_Shader * getShader(RE_ShaderTarget sht=RE_SHADER_TARGET_TRIANGLE) const
bool customShaderDirty() const
bool hasMetallicMap() const
bool hasDisplacement() const
const UT_StringRef & getMatNetName() const
void setEmission(UT_Color col)
fpreal getCoatIntensity() const
bool hasOcclusionMap() const
void markDefaultShader(bool def)
bool hasSpecularMap() const
bool allowShaders() const
void enableHairParameters(bool e)
float diff(unsigned idx) const
GT_API const UT_StringHolder version
void setDefaultMaterial(const RE_MaterialPtr &material, bool add_list=true)
UT_Vector3T< fpreal32 > UT_Vector3F
GLint GLint GLsizei GLint GLenum format
float emit(unsigned idx) const
float coatRoughness() const
GLfloat GLfloat GLfloat GLfloat h
A map of string to various well defined value types.
AlphaMode getAlphaMode() const
float diffuseRoughness() const
bool hasCoatRoughnessMap() const
float spec(unsigned idx) const
float coatIntensity() const
void intrusive_ptr_add_ref(T *x)
void setDiff(float r, float g, float b)
void clearReflectionMap()
const RE_MaterialPtr & getFactoryMaterial() const
bool useGeometryColor() const
bool checkForCacheUpdate(int cache_serial, fpreal t)
void setVertexOverrides(const UT_StringMap< UT_StringHolder > &ovr)
UT_Vector3F metallicEdgeTint() const
bool hasHairAlphaRamp() const
void setDisplaceLOD(float lod)
bool hasEmissionMap() const
void preloadMapsOnly(bool preload)
RE_TextureCompress getTextureFormat() const
void setAmbient(UT_Color col)
void dirtyMatNet(bool dirty=true)
void setNeedsTangentSpace(bool b)
const UT_StringHolder & getMaterialName() const
MX_RENDER_API ShaderPtr createShader(const string &shaderName, GenContext &context, ElementPtr elem)
Create a shader for a given element.
fpreal getAlphaCutoff() const
Simple class for a mutli-integer cache tag.
void add(const RE_MaterialPtr &material)
int64 getMatXNodeVersion() const
ImageBuf OIIO_API add(Image_or_Const A, Image_or_Const B, ROI roi={}, int nthreads=0)
void getMaxTextureSize(int &w, int &h)
bool hasExplicitReflection() const
constexpr SYS_FORCE_INLINE T & y() noexcept
GLfloat GLfloat GLfloat alpha
bool isDirty(fpreal time) const
fpreal getCoatRoughness() const
Base::const_iterator const_iterator
int getNumDiffuseLayers() const
bool hasHairSpecularMap() const
void setTransparent(bool alpha)
float getTextureScale() const
RE_MaterialTextureBinding
bool needsTextureUpdate() const
bool isDefaultShader() const
fpreal getSpecularTint() const
void allowShaders(bool yes)
FMT_CONSTEXPR auto find(Ptr first, Ptr last, T value, Ptr &out) -> bool
int getShaderRefID(RE_ShaderTarget ptype=RE_SHADER_TARGET_TRIANGLE) const
bool hasCustomShader(RE_ShaderTarget ptype=RE_SHADER_TARGET_TRIANGLE) const
constexpr SYS_FORCE_INLINE T & x() noexcept