BaseMaterial3D

public bool AOEnabled { get; set; }

If true, ambient occlusion is enabled. Ambient occlusion darkens areas based on the BaseMaterial3D.AOTexture.

public float AOLightAffect { get; set; }

Amount that ambient occlusion affects lighting from lights. If 0, ambient occlusion only affects ambient light. If 1, ambient occlusion affects lights just as much as it affects ambient light. This can be used to impact the strength of the ambient occlusion effect, but typically looks unrealistic.

public bool AOOnUV2 { get; set; }

If true, use UV2 coordinates to look up from the BaseMaterial3D.AOTexture.

public Texture2D AOTexture { get; set; }

Texture that defines the amount of ambient occlusion for a given point on the object.

public BaseMaterial3D.TextureChannel AOTextureChannel { get; set; }

Specifies the channel of the BaseMaterial3D.AOTexture in which the ambient occlusion information is stored. This is useful when you store the information for multiple effects in a single texture. For example if you stored metallic in the red channel, roughness in the blue, and ambient occlusion in the green you could reduce the number of textures you use.

public Color AlbedoColor { get; set; }

Base color multiplied by the albedo texture when assigned. Alpha alone does not enable transparency: Transparency=Disabled remains opaque even at A=0. Final lit-material color also depends on lighting and Environment.

public Texture2D AlbedoTexture { get; set; }

Texture to multiply by BaseMaterial3D.AlbedoColor. Used for basic texturing of objects. If the texture appears unexpectedly too dark or too bright, check BaseMaterial3D.AlbedoTextureForceSrgb.

public bool AlbedoTextureForceSrgb { get; set; }

If true, forces a conversion of the BaseMaterial3D.AlbedoTexture from nonlinear sRGB encoding to linear encoding. See also BaseMaterial3D.VertexColorIsSrgb. This should only be enabled when needed (typically when using a ViewportTexture as BaseMaterial3D.AlbedoTexture). If BaseMaterial3D.AlbedoTextureForceSrgb is true when it shouldn't be, the texture will appear to be too dark. If BaseMaterial3D.AlbedoTextureForceSrgb is false when it shouldn't be, the texture will appear to be too bright.

public bool AlbedoTextureMsdf { get; set; }

Enables multichannel signed distance field rendering shader. Use BaseMaterial3D.MsdfPixelRange and BaseMaterial3D.MsdfOutlineSize to configure MSDF parameters.

public float AlphaAntialiasingEdge { get; set; }

Threshold at which antialiasing will be applied on the alpha channel.

public BaseMaterial3D.AlphaAntiAliasing AlphaAntialiasingMode { get; set; }

The type of alpha antialiasing to apply.

public float AlphaHashScale { get; set; }

The hashing scale for Alpha Hash. Recommended values between 0 and 2.

public float AlphaScissorThreshold { get; set; }

Cutout threshold for Transparency=AlphaScissor. At threshold 0.5, alpha 0.2 is discarded and 0.8 retained. This is a hard cutout, not smooth translucent blending.

public float Anisotropy { get; set; }

The strength of the anisotropy effect. This is multiplied by BaseMaterial3D.AnisotropyFlowmap's alpha channel if a texture is defined there and the texture contains an alpha channel.

public bool AnisotropyEnabled { get; set; }

If true, anisotropy is enabled. Anisotropy changes the shape of the specular blob and aligns it to tangent space. This is useful for brushed aluminum and hair reflections. Note: Mesh tangents are needed for anisotropy to work. If the mesh does not contain tangents, the anisotropy effect will appear broken. Note: Material anisotropy should not to be confused with anisotropic texture filtering, which can be enabled by setting BaseMaterial3D.TextureFilter to BaseMaterial3D.TextureFilterEnum.LinearWithMipmapsAnisotropic.

public Texture2D AnisotropyFlowmap { get; set; }

Texture that offsets the tangent map for anisotropy calculations and optionally controls the anisotropy effect (if an alpha channel is present). The flowmap texture is expected to be a derivative map, with the red channel representing distortion on the X axis and green channel representing distortion on the Y axis. Values below 0.5 will result in negative distortion, whereas values above 0.5 will result in positive distortion. If present, the texture's alpha channel will be used to multiply the strength of the BaseMaterial3D.Anisotropy effect. Fully opaque pixels will keep the anisotropy effect's original strength while fully transparent pixels will disable the anisotropy effect entirely. The flowmap texture's blue channel is ignored.

public Color Backlight { get; set; }

The color used by the backlight effect. Represents the light passing through an object.

public bool BacklightEnabled { get; set; }

If true, the backlight effect is enabled. See also BaseMaterial3D.SubsurfScatterTransmittanceEnabled.

public Texture2D BacklightTexture { get; set; }

Texture used to control the backlight effect per-pixel. Added to BaseMaterial3D.Backlight.

public bool BentNormalEnabled { get; set; }

If true, the bent normal map is enabled. This allows for more accurate indirect lighting and specular occlusion.

public Texture2D BentNormalTexture { get; set; }

Texture that specifies the average direction of incoming ambient light at a given pixel. The BaseMaterial3D.BentNormalTexture only uses the red and green channels; the blue and alpha channels are ignored. The normal read from BaseMaterial3D.BentNormalTexture is oriented around the surface normal provided by the Mesh. Note: A bent normal map is different from a regular normal map. When baking a bent normal map make sure to use a cosine distribution for the bent normal map to work correctly. Note: The mesh must have both normals and tangents defined in its vertex data. Otherwise, the shading produced by the bent normal map will not look correct. If creating geometry with SurfaceTool, you can use SurfaceTool.GenerateNormals and SurfaceTool.GenerateTangents to automatically generate normals and tangents respectively. Note: Reckfell expects the bent normal map to use X+, Y+, and Z+ coordinates. See this page for a comparison of normal map coordinates expected by popular engines.

public bool BillboardKeepScale { get; set; }

If true, the shader will keep the scale set for the mesh. Otherwise, the scale is lost when billboarding. Only applies when BaseMaterial3D.BillboardMode is not BaseMaterial3D.BillboardModeEnum.Disabled.

public BaseMaterial3D.BillboardModeEnum BillboardMode { get; set; }

Controls how the object faces the camera.

Billboard orientation can be unsuitable for VR when the camera rolls: its left-right axis need not remain horizontal. Check the intended stereo and head-rotation behavior for the application.

public BaseMaterial3D.BlendModeEnum BlendMode { get; set; }

The material's blend mode. Note: Values other than Mix force the object into the transparent pipeline.

public float Clearcoat { get; set; }

Sets the strength of the clearcoat effect. Setting to 0 looks the same as disabling the clearcoat effect.

public bool ClearcoatEnabled { get; set; }

If true, clearcoat rendering is enabled. Adds a secondary transparent pass to the lighting calculation resulting in an added specular blob. This makes materials appear as if they have a clear layer on them that can be either glossy or rough. Note: Clearcoat rendering is not visible if the material's BaseMaterial3D.ShadingMode is BaseMaterial3D.ShadingModeEnum.Unshaded.

public float ClearcoatRoughness { get; set; }

Sets the roughness of the clearcoat pass. A higher value results in a rougher clearcoat while a lower value results in a smoother clearcoat.

public Texture2D ClearcoatTexture { get; set; }

Texture that defines the strength of the clearcoat effect and the glossiness of the clearcoat. Strength is specified in the red channel while glossiness is specified in the green channel.

public BaseMaterial3D.CullModeEnum CullMode { get; set; }

Determines which side of the triangle to cull depending on whether the triangle faces towards or away from the camera.

public BaseMaterial3D.DepthDrawModeEnum DepthDrawMode { get; set; }

Determines when depth rendering takes place. See also BaseMaterial3D.Transparency.

public BaseMaterial3D.DepthTestEnum DepthTest { get; set; }

Determines which comparison operator is used when testing depth. Note: Changing BaseMaterial3D.DepthTest to a non-default value only has a visible effect when used on a transparent material, or a material that has BaseMaterial3D.DepthDrawMode set to BaseMaterial3D.DepthDrawModeEnum.Disabled.

public Texture2D DetailAlbedo { get; set; }

Texture that specifies the color of the detail overlay. BaseMaterial3D.DetailAlbedo's alpha channel is used as a mask, even when the material is opaque. To use a dedicated texture as a mask, see BaseMaterial3D.DetailMask. Note: BaseMaterial3D.DetailAlbedo is not modulated by BaseMaterial3D.AlbedoColor.

public BaseMaterial3D.BlendModeEnum DetailBlendMode { get; set; }

Specifies how the BaseMaterial3D.DetailAlbedo should blend with the current ALBEDO.

public bool DetailEnabled { get; set; }

If true, enables the detail overlay. Detail is a second texture that gets mixed over the surface of the object based on BaseMaterial3D.DetailMask and BaseMaterial3D.DetailAlbedo's alpha channel. This can be used to add variation to objects, or to blend between two different albedo/normal textures.

public Texture2D DetailMask { get; set; }

Texture used to specify how the detail textures get blended with the base textures. BaseMaterial3D.DetailMask can be used together with BaseMaterial3D.DetailAlbedo's alpha channel (if any).

public Texture2D DetailNormal { get; set; }

Texture that specifies the per-pixel normal of the detail overlay. The BaseMaterial3D.DetailNormal texture only uses the red and green channels; the blue and alpha channels are ignored. The normal read from BaseMaterial3D.DetailNormal is oriented around the surface normal provided by the Mesh. Note: Reckfell expects the normal map to use X+, Y+, and Z+ coordinates. See this page for a comparison of normal map coordinates expected by popular engines.

public BaseMaterial3D.DetailUV DetailUVLayer { get; set; }

Specifies whether to use UV or UV2 for the detail layer.

public BaseMaterial3D.DiffuseModeEnum DiffuseMode { get; set; }

The algorithm used for diffuse light scattering.

public bool DisableAmbientLight { get; set; }

If true, the object receives no ambient light.

public bool DisableFog { get; set; }

If true, the object will not be affected by fog (neither volumetric nor depth fog). This is useful for unshaded or transparent materials (e.g. particles), which without this setting will be affected even if fully transparent.

public bool DisableReceiveShadows { get; set; }

If true, the object receives no shadow that would otherwise be cast onto it.

public bool DisableSpecularOcclusion { get; set; }

If true, disables approximate indirect-specular occlusion for this material. Defaults to false, following rendering/reflections/specular_occlusion/enabled. If the global setting is already off, this property does not re-enable occlusion. In current Forward+ and Mobile, the branch without a bent-normal map uses ambient luminance: zero ambient can suppress even a valid reflection. Useful for isolated reflection checks without ambient; does not disable direct shadows or diffuse AO, or create lighting.

public float DistanceFadeMaxDistance { get; set; }

Distance at which the object appears fully opaque. Note: If BaseMaterial3D.DistanceFadeMaxDistance is less than BaseMaterial3D.DistanceFadeMinDistance, the behavior will be reversed. The object will start to fade away at BaseMaterial3D.DistanceFadeMaxDistance and will fully disappear once it reaches BaseMaterial3D.DistanceFadeMinDistance.

public float DistanceFadeMinDistance { get; set; }

Distance at which the object starts to become visible. If the object is less than this distance away, it will be invisible. Note: If BaseMaterial3D.DistanceFadeMinDistance is greater than BaseMaterial3D.DistanceFadeMaxDistance, the behavior will be reversed. The object will start to fade away at BaseMaterial3D.DistanceFadeMaxDistance and will fully disappear once it reaches BaseMaterial3D.DistanceFadeMinDistance.

public BaseMaterial3D.DistanceFadeModeEnum DistanceFadeMode { get; set; }

Specifies which type of fade to use. Can be any of the BaseMaterial3D.DistanceFadeModeEnums.

public Color Emission { get; set; }

The emitted light's color. See BaseMaterial3D.EmissionEnabled.

public bool EmissionEnabled { get; set; }

Enables Emission contribution to material brightness. Not a separate Light3D; nearby objects do not automatically receive direct illumination. Glow adds a halo through Environment processing, while indirect illumination requires a separate solution.

public float EmissionEnergyMultiplier { get; set; }

Emission multiplier when EmissionEnabled. The example uses 8 for a bright glow source; this is an artistic test setting, not universal exposure or lighting energy for nearby objects.

public float EmissionIntensity { get; set; }

Luminance of emitted light, measured in nits (candela per square meter). Only available when ProjectSettings.rendering/lights_and_shadows/use_physical_light_units is enabled. The default is roughly equivalent to an indoor lightbulb.

public bool EmissionOnUV2 { get; set; }

Use UV2 to read from the BaseMaterial3D.EmissionTexture.

public BaseMaterial3D.EmissionOperatorEnum EmissionOperator { get; set; }

Sets how BaseMaterial3D.Emission interacts with BaseMaterial3D.EmissionTexture. Can either add or multiply.

public Texture2D EmissionTexture { get; set; }

Texture that specifies how much surface emits light at a given point.

public bool FixedSize { get; set; }

If true, the object is rendered at the same size regardless of distance. The object's size on screen is the same as if the camera was 1.0 units away from the object's origin, regardless of the actual distance from the camera. The Camera3D's field of view (or Camera3D.Size when in orthogonal/frustum mode) still affects the size the object is drawn at.

public float FovOverride { get; set; }

Overrides the Camera3D's field of view angle (in degrees). Note: This behaves as if the field of view is set on a Camera3D with Camera3D.KeepAspect set to Camera3D.KeepAspectEnum.Height. Additionally, it may not look correct on a non-perspective camera where the field of view setting is ignored.

public bool Grow { get; set; }

If true, enables the vertex grow setting. This can be used to create mesh-based outlines using a second material pass and its BaseMaterial3D.CullMode set to BaseMaterial3D.CullModeEnum.Front. See also BaseMaterial3D.GrowAmount. Note: Vertex growth cannot create new vertices, which means that visible gaps may occur in sharp corners. This can be alleviated by designing the mesh to use smooth normals exclusively using face weighted normals in the 3D authoring software. In this case, grow will be able to join every outline together, just like in the original mesh.

public float GrowAmount { get; set; }

Grows object vertices in the direction of their normals. Only effective if BaseMaterial3D.Grow is true.

public bool HeightmapDeepParallax { get; set; }

If true, uses parallax occlusion mapping to represent depth in the material instead of simple offset mapping (see BaseMaterial3D.HeightmapEnabled). This results in a more convincing depth effect, but is much more expensive on the GPU. Only enable this on materials where it makes a significant visual difference.

public bool HeightmapEnabled { get; set; }

If true, height mapping is enabled (also called "parallax mapping" or "depth mapping"). See also BaseMaterial3D.NormalEnabled. Height mapping is a demanding feature on the GPU, so it should only be used on materials where it makes a significant visual difference. Note: Height mapping is not supported if triplanar mapping is used on the same material. The value of BaseMaterial3D.HeightmapEnabled will be ignored if BaseMaterial3D.Uv1Triplanar is enabled.

public bool HeightmapFlipBinormal { get; set; }

If true, flips the mesh's binormal vectors when interpreting the height map. If the heightmap effect looks strange when the camera moves (even with a reasonable BaseMaterial3D.HeightmapScale), try setting this to true.

public bool HeightmapFlipTangent { get; set; }

If true, flips the mesh's tangent vectors when interpreting the height map. If the heightmap effect looks strange when the camera moves (even with a reasonable BaseMaterial3D.HeightmapScale), try setting this to true.

public bool HeightmapFlipTexture { get; set; }

If true, interprets the height map texture as a depth map, with brighter values appearing to be "lower" in altitude compared to darker values. This can be enabled for compatibility with some materials authored for Reckfell.x. This is not necessary if the Invert import option was used to invert the depth map in Reckfell.x, in which case BaseMaterial3D.HeightmapFlipTexture should remain false.

public int HeightmapMaxLayers { get; set; }

The number of layers to use for parallax occlusion mapping when the camera is up close to the material. Higher values result in a more convincing depth effect, especially in materials that have steep height changes. Higher values have a significant cost on the GPU, so it should only be increased on materials where it makes a significant visual difference. Note: Only effective if BaseMaterial3D.HeightmapDeepParallax is true.

public int HeightmapMinLayers { get; set; }

The number of layers to use for parallax occlusion mapping when the camera is far away from the material. Higher values result in a more convincing depth effect, especially in materials that have steep height changes. Higher values have a significant cost on the GPU, so it should only be increased on materials where it makes a significant visual difference. Note: Only effective if BaseMaterial3D.HeightmapDeepParallax is true.

public float HeightmapScale { get; set; }

The heightmap scale to use for the parallax effect (see BaseMaterial3D.HeightmapEnabled). The default value is tuned so that the highest point (value = 255) appears to be 5 cm higher than the lowest point (value = 0). Higher values result in a deeper appearance, but may result in artifacts appearing when looking at the material from oblique angles, especially when the camera moves. Negative values can be used to invert the parallax effect, but this is different from inverting the texture using BaseMaterial3D.HeightmapFlipTexture as the material will also appear to be "closer" to the camera. In most cases, BaseMaterial3D.HeightmapScale should be kept to a positive value. Note: If the height map effect looks strange regardless of this value, try adjusting BaseMaterial3D.HeightmapFlipBinormal and BaseMaterial3D.HeightmapFlipTangent. See also BaseMaterial3D.HeightmapTexture for recommendations on authoring heightmap textures, as the way the heightmap texture is authored affects how BaseMaterial3D.HeightmapScale behaves.

public Texture2D HeightmapTexture { get; set; }

The texture to use as a height map. See also BaseMaterial3D.HeightmapEnabled. For best results, the texture should be normalized (with BaseMaterial3D.HeightmapScale reduced to compensate). In GIMP(https://gimp.org), this can be done using Colors > Auto > Equalize. If the texture only uses a small part of its available range, the parallax effect may look strange, especially when the camera moves. Note: To reduce memory usage and improve loading times, you may be able to use a lower-resolution heightmap texture as most heightmaps are only comprised of low-frequency data.

public float Metallic { get; set; }

Surface metallic response, typically 0 for a dielectric and 1 for a metal. Does not supply environment reflections. A metal without suitable light/reflection sources can appear dark; arbitrary albedo amplification is not a substitute.

public float MetallicSpecular { get; set; }

Adjusts the strength of specular reflections. Specular reflections are composed of scene reflections and the specular lobe which is the bright spot that is reflected from light sources. When set to 0.0, no specular reflections will be visible. This differs from the BaseMaterial3D.SpecularModeEnum.Disabled BaseMaterial3D.SpecularModeEnum as BaseMaterial3D.SpecularModeEnum.Disabled only applies to the specular lobe from the light source. Note: Unlike BaseMaterial3D.Metallic, this is not energy-conserving, so it should be left at 0.5 in most cases. See also BaseMaterial3D.Roughness.

public Texture2D MetallicTexture { get; set; }

Texture used to specify metallic for an object. This is multiplied by BaseMaterial3D.Metallic.

public BaseMaterial3D.TextureChannel MetallicTextureChannel { get; set; }

Specifies the channel of the BaseMaterial3D.MetallicTexture in which the metallic information is stored. This is useful when you store the information for multiple effects in a single texture. For example if you stored metallic in the red channel, roughness in the blue, and ambient occlusion in the green you could reduce the number of textures you use.

public float MsdfOutlineSize { get; set; }

The width of the shape outline.

public float MsdfPixelRange { get; set; }

The width of the range around the shape between the minimum and maximum representable signed distance.

public bool NoDepthTest { get; set; }

If true, depth testing is disabled and the object will be drawn in render order.

public bool NormalEnabled { get; set; }

If true, normal mapping is enabled. This has a slight performance cost, especially on mobile GPUs.

public float NormalScale { get; set; }

The strength of the normal map's effect.

public Texture2D NormalTexture { get; set; }

Surface normal texture; enable NormalEnabled. Changes shading normals, not the silhouette or physics shape. Check import, channel conventions and mesh tangents separately; normal-map import is outside the runnable example.

public Texture2D OrmTexture { get; set; }

The Occlusion/Roughness/Metallic texture to use. This is a more efficient replacement of BaseMaterial3D.AOTexture, BaseMaterial3D.RoughnessTexture and BaseMaterial3D.MetallicTexture in OrmMaterial3D. Ambient occlusion is stored in the red channel. Roughness map is stored in the green channel. Metallic map is stored in the blue channel. The alpha channel is ignored.

public bool ParticlesAnimEnabled { get; set; }

If true, enables particles_anim_* properties. The ParticleProcessMaterial.AnimSpeedMin or CpuParticles3D.AnimSpeedMin should also be set to a value bigger than zero for the animation to play. Note: For compatibility reasons, this property is ignored and always enabled when BaseMaterial3D.BillboardMode is set to BaseMaterial3D.BillboardModeEnum.Particles.

public int ParticlesAnimHFrames { get; set; }

The number of horizontal frames in the particle sprite sheet. Only enabled when BaseMaterial3D.ParticlesAnimEnabled is true or BaseMaterial3D.BillboardMode is set to BaseMaterial3D.BillboardModeEnum.Particles.

public bool ParticlesAnimLoop { get; set; }

If true, particle animations are looped. Only enabled when BaseMaterial3D.ParticlesAnimEnabled is true or BaseMaterial3D.BillboardMode is set to BaseMaterial3D.BillboardModeEnum.Particles.

public int ParticlesAnimVFrames { get; set; }

The number of vertical frames in the particle sprite sheet. Only enabled when BaseMaterial3D.ParticlesAnimEnabled is true or BaseMaterial3D.BillboardMode is set to BaseMaterial3D.BillboardModeEnum.Particles.

public float PointSize { get; set; }

The point size in pixels. See BaseMaterial3D.UsePointSize.

public float ProximityFadeDistance { get; set; }

Distance over which the fade effect takes place. The larger the distance the longer it takes for an object to fade.

public bool ProximityFadeEnabled { get; set; }

If true, the proximity fade effect is enabled. The proximity fade effect fades out each pixel based on its distance to another object.

public bool RefractionEnabled { get; set; }

If true, the refraction effect is enabled. Distorts transparency based on light from behind the object. Note: Refraction is implemented using the screen texture. Only opaque materials will appear in the refraction, since transparent materials do not appear in the screen texture.

public float RefractionScale { get; set; }

The strength of the refraction effect.

public Texture2D RefractionTexture { get; set; }

Texture that controls the strength of the refraction per-pixel. Multiplied by BaseMaterial3D.RefractionScale.

public BaseMaterial3D.TextureChannel RefractionTextureChannel { get; set; }

Specifies the channel of the BaseMaterial3D.RefractionTexture in which the refraction information is stored. This is useful when you store the information for multiple effects in a single texture. For example if you stored refraction in the red channel, roughness in the blue, and ambient occlusion in the green you could reduce the number of textures you use.

public float Rim { get; set; }

Sets the strength of the rim lighting effect.

public bool RimEnabled { get; set; }

If true, rim effect is enabled. Rim lighting increases the brightness at glancing angles on an object. Note: Rim lighting is not visible if the material's BaseMaterial3D.ShadingMode is BaseMaterial3D.ShadingModeEnum.Unshaded.

public Texture2D RimTexture { get; set; }

Texture used to set the strength of the rim lighting effect per-pixel. Multiplied by BaseMaterial3D.Rim.

public float RimTint { get; set; }

The amount of to blend light and albedo color when rendering rim effect. If 0 the light color is used, while 1 means albedo color is used. An intermediate value generally works best.

public float Roughness { get; set; }

Surface roughness, usually 0..1: lower values give tighter highlights/sharper reflections, higher values a broader response. Does not change polygon count or mesh geometry.

public Texture2D RoughnessTexture { get; set; }

Texture used to control the roughness per-pixel. Multiplied by BaseMaterial3D.Roughness.

public BaseMaterial3D.TextureChannel RoughnessTextureChannel { get; set; }

Specifies the channel of the BaseMaterial3D.RoughnessTexture in which the roughness information is stored. This is useful when you store the information for multiple effects in a single texture. For example if you stored metallic in the red channel, roughness in the blue, and ambient occlusion in the green you could reduce the number of textures you use.

public BaseMaterial3D.ShadingModeEnum ShadingMode { get; set; }

Material lighting mode. Unshaded removes ordinary light-source response; PerPixel supplies a standard lit surface. Unshaded does not automatically disable every environment effect or transparency rule.

public bool ShadowToOpacity { get; set; }

If true, enables the "shadow to opacity" render mode where lighting modifies the alpha so shadowed areas are opaque and non-shadowed areas are transparent. Useful for overlaying shadows onto a camera feed in AR.

public BaseMaterial3D.SpecularModeEnum SpecularMode { get; set; }

The method for rendering the specular blob. Note: BaseMaterial3D.SpecularMode only applies to the specular blob. It does not affect specular reflections from the sky, screen-space reflections, VoxelGI, SDFGI or ReflectionProbes. To disable reflections from these sources as well, set BaseMaterial3D.MetallicSpecular to 0.0 instead.

public Color StencilColor { get; set; }

The primary color of the stencil effect.

public BaseMaterial3D.StencilCompareEnum StencilCompare { get; set; }

The comparison operator to use for stencil masking operations.

public int StencilFlags { get; set; }

The flags dictating how the stencil operation behaves.

public BaseMaterial3D.StencilModeEnum StencilMode { get; set; }

The stencil effect mode.

public float StencilOutlineThickness { get; set; }

The outline thickness for BaseMaterial3D.StencilModeEnum.Outline.

public int StencilReference { get; set; }

The stencil reference value (0-255). Typically a power of 2.

public bool SubsurfScatterEnabled { get; set; }

If true, subsurface scattering is enabled. Emulates light that penetrates an object's surface, is scattered, and then emerges. Subsurface scattering quality is controlled by ProjectSettings.rendering/environment/subsurface_scattering/subsurface_scattering_quality. Note: Subsurface scattering is not supported on viewports that have a transparent background (where Viewport.TransparentBg is true).

public bool SubsurfScatterSkinMode { get; set; }

If true, subsurface scattering will use a special mode optimized for the color and density of human skin, such as boosting the intensity of the red channel in subsurface scattering.

public float SubsurfScatterStrength { get; set; }

The strength of the subsurface scattering effect. The depth of the effect is also controlled by ProjectSettings.rendering/environment/subsurface_scattering/subsurface_scattering_scale, which is set globally.

public Texture2D SubsurfScatterTexture { get; set; }

Texture used to control the subsurface scattering strength. Stored in the red texture channel. Multiplied by BaseMaterial3D.SubsurfScatterStrength.

public float SubsurfScatterTransmittanceBoost { get; set; }

The intensity of the subsurface scattering transmittance effect.

public Color SubsurfScatterTransmittanceColor { get; set; }

The color to multiply the subsurface scattering transmittance effect with. Ignored if BaseMaterial3D.SubsurfScatterSkinMode is true.

public float SubsurfScatterTransmittanceDepth { get; set; }

The depth of the subsurface scattering transmittance effect.

public bool SubsurfScatterTransmittanceEnabled { get; set; }

If true, enables subsurface scattering transmittance. Only effective if BaseMaterial3D.SubsurfScatterEnabled is true. See also BaseMaterial3D.BacklightEnabled.

public Texture2D SubsurfScatterTransmittanceTexture { get; set; }

The texture to use for multiplying the intensity of the subsurface scattering transmittance intensity. See also BaseMaterial3D.SubsurfScatterTexture. Ignored if BaseMaterial3D.SubsurfScatterSkinMode is true.

public BaseMaterial3D.TextureFilterEnum TextureFilter { get; set; }

Filter flags for the texture. Note: BaseMaterial3D.HeightmapTexture is always sampled with linear filtering, even if nearest-neighbor filtering is selected here. This is to ensure the heightmap effect looks as intended. If you need sharper height transitions between pixels, resize the heightmap texture in an image editor with nearest-neighbor filtering.

public bool TextureRepeat { get; set; }

If true, the texture repeats when exceeding the texture's size. See BaseMaterial3D.Flags.UseTextureRepeat.

public BaseMaterial3D.TransparencyEnum Transparency { get; set; }

Selects alpha handling. Disabled keeps the surface opaque, Alpha blends with the background, and AlphaScissor discards fragments below the threshold. Alpha can change sorting and cost; it is not an automatic physical-glass model.

public Vector3 UV2Offset { get; set; }

How much to offset the UV2 coordinates. This amount will be added to UV2 in the vertex function. This can be used to offset a texture. The Z component is used when BaseMaterial3D.UV2Triplanar is enabled, but it is not used anywhere else.

public Vector3 UV2Scale { get; set; }

How much to scale the UV2 coordinates. This is multiplied by UV2 in the vertex function. The Z component is used when BaseMaterial3D.UV2Triplanar is enabled, but it is not used anywhere else.

public bool UV2Triplanar { get; set; }

If true, instead of using UV2 textures will use a triplanar texture lookup to determine how to apply textures. Triplanar uses the orientation of the object's surface to blend between texture coordinates. It reads from the source texture 3 times, once for each axis and then blends between the results based on how closely the pixel aligns with each axis. This is often used for natural features to get a realistic blend of materials. Because triplanar texturing requires many more texture reads per-pixel it is much slower than normal UV texturing. Additionally, because it is blending the texture between the three axes, it is unsuitable when you are trying to achieve crisp texturing.

public float UV2TriplanarSharpness { get; set; }

A lower number blends the texture more softly while a higher number blends the texture more sharply. Note: BaseMaterial3D.UV2TriplanarSharpness is clamped between 0.0 and 150.0 (inclusive) as values outside that range can look broken depending on the mesh.

public bool UV2WorldTriplanar { get; set; }

If true, triplanar mapping for UV2 is calculated in world space rather than object local space. See also BaseMaterial3D.UV2Triplanar.

public bool UseFovOverride { get; set; }

If true use BaseMaterial3D.FovOverride to override the Camera3D's field of view angle.

public bool UseParticleTrails { get; set; }

Enables trail-pose deformation support in the surface material. Also requires emitter TrailEnabled and a compatible mesh/skin. Does not replace ProcessMaterial; inspect the effective MaterialOverride.

public bool UsePointSize { get; set; }

If true, render point size can be changed. Note: This is only effective for objects whose geometry is point-based rather than triangle-based. See also BaseMaterial3D.PointSize.

public bool UseZClipScale { get; set; }

If true use BaseMaterial3D.ZClipScale to scale the object being rendered towards the camera to avoid clipping into things like walls.

public Vector3 Uv1Offset { get; set; }

How much to offset the UV coordinates. This amount will be added to UV in the vertex function. This can be used to offset a texture. The Z component is used when BaseMaterial3D.Uv1Triplanar is enabled, but it is not used anywhere else.

public Vector3 Uv1Scale { get; set; }

How much to scale the UV coordinates. This is multiplied by UV in the vertex function. The Z component is used when BaseMaterial3D.Uv1Triplanar is enabled, but it is not used anywhere else.

public bool Uv1Triplanar { get; set; }

If true, instead of using UV textures will use a triplanar texture lookup to determine how to apply textures. Triplanar uses the orientation of the object's surface to blend between texture coordinates. It reads from the source texture 3 times, once for each axis and then blends between the results based on how closely the pixel aligns with each axis. This is often used for natural features to get a realistic blend of materials. Because triplanar texturing requires many more texture reads per-pixel it is much slower than normal UV texturing. Additionally, because it is blending the texture between the three axes, it is unsuitable when you are trying to achieve crisp texturing.

public float Uv1TriplanarSharpness { get; set; }

A lower number blends the texture more softly while a higher number blends the texture more sharply. Note: BaseMaterial3D.Uv1TriplanarSharpness is clamped between 0.0 and 150.0 (inclusive) as values outside that range can look broken depending on the mesh.

public bool Uv1WorldTriplanar { get; set; }

If true, triplanar mapping for UV is calculated in world space rather than object local space. See also BaseMaterial3D.Uv1Triplanar.

public bool VertexColorIsSrgb { get; set; }

If true, vertex colors are considered to be stored in nonlinear sRGB encoding and are converted to linear encoding during rendering. If false, vertex colors are considered to be stored in linear encoding and are rendered as-is. See also BaseMaterial3D.AlbedoTextureForceSrgb. Note: Only effective when using the Forward+ and Mobile rendering methods, not Compatibility.

public bool VertexColorUseAsAlbedo { get; set; }

If true, the vertex color is used as albedo color.

public float ZClipScale { get; set; }

Scales the object being rendered towards the camera to avoid clipping into things like walls. This is intended to be used for objects that are fixed with respect to the camera like player arms, tools, etc. Lighting and shadows will continue to work correctly when this setting is adjusted, but screen-space effects like SSAO and SSR may break with lower scales. Therefore, try to keep this setting as close to 1.0 as possible.

public bool GetFeature(BaseMaterial3D.Feature feature);

Returns true if the specified feature is enabled.

public bool GetFlag(BaseMaterial3D.Flags flag);

Returns true if the specified flag is enabled.

public Texture2D GetTexture(BaseMaterial3D.TextureParam param);

Returns the Texture2D associated with the specified texture param.