GeometryInstance3D

public GeometryInstance3D.ShadowCastingSetting CastShadow { get; set; }

Controls geometry shadow casting, not ordinary visibility or shadow reception. Off removes the object shadow; the light also needs ShadowEnabled. The example verifies DirectionalLight3D in Compatibility.

public Aabb CustomAabb { get; set; }

Custom local bounds for culling the rendering instance. A nonzero Aabb replaces computed bounds; default(Aabb) removes the override. ExtraCullMargin is then applied before transforming the result to world space. Does not change vertices, Mesh.GetAabb(), VisualInstance3D.GetAabb() or collision. An excessively large box weakens culling and is not a general switch disabling visibility tests.

public float ExtraCullMargin { get; set; }

Additional geometry-culling bounds margin. Useful when a vertex shader moves vertices outside the original AABB. Does not modify CPU vertices, the original Mesh.GetAabb or CollisionShape3D. Choose it for the maximum possible displacement; the example uses 2.

public GeometryInstance3D.LightmapScale GILightmapScale { get; set; }

The texel density to use for lightmapping in LightmapGI.

public float GILightmapTexelScale { get; set; }

The texel density to use for lightmapping in LightmapGI. Greater scale values provide higher resolution in the lightmap, which can result in sharper shadows for lights that have both direct and indirect light baked. However, greater scale values will also increase the space taken by the mesh in the lightmap texture, which increases the memory, storage, and bake time requirements. When using a single mesh at different scales, consider adjusting this value to keep the lightmap texel density consistent across meshes. For example, doubling GeometryInstance3D.GILightmapTexelScale doubles the lightmap texture resolution for this object on each axis, so it will quadruple the texel count.

public GeometryInstance3D.GIModeEnum GIMode { get; set; }

The global illumination mode to use for the whole geometry. To avoid inconsistent results, use a mode that matches the purpose of the mesh during gameplay (static/dynamic). Note: Lights' bake mode will also affect the global illumination rendering. See Light3D.LightBakeMode.

public bool IgnoreOcclusionCulling { get; set; }

Bypasses occlusion culling for this geometry. The test restores the hidden sphere to the render list behind a wall; it does not make it visible through the opaque wall or disable every other culling mechanism.

public float LodBias { get; set; }

Instance mesh-LOD selection multiplier. Increasing 1 to 8 preserves more distant primitives in the test. Does not create missing LOD data, modify physics or specify a fixed switching distance.

public Material MaterialOverlay { get; set; }

Additional material rendered over the base in another pass. Does not replace MaterialOverride and is not returned by GetActiveMaterial. A transparent Alpha overlay is verified; configure transparency, depth and extra-pass cost separately.

public Material MaterialOverride { get; set; }

Base material overriding all instance surfaces, ahead of surface overrides and Mesh materials. Assigning an existing resource does not make it unique. null restores surface-material selection.

public float Transparency { get; set; }

The transparency applied to the whole geometry (as a multiplier of the materials' existing transparency). 0.0 is fully opaque, while 1.0 is fully transparent. Values greater than 0.0 (exclusive) will force the geometry's materials to go through the transparent pipeline, which is slower to render and can exhibit rendering issues due to incorrect transparency sorting. However, unlike using a transparent material, setting GeometryInstance3D.Transparency to a value greater than 0.0 (exclusive) will not disable shadow rendering. In spatial shaders, 1.0 - transparency is set as the default value of the ALPHA built-in. Note: GeometryInstance3D.Transparency is clamped between 0.0 and 1.0, so this property cannot be used to make transparent materials more opaque than they originally are. Note: Only supported when using the Forward+ rendering method. When using the Mobile or Compatibility rendering method, GeometryInstance3D.Transparency is ignored and is considered as always being 0.0.

public float VisibilityRangeBegin { get; set; }

Lower visibility-distance bound, measured from the camera to the transformed AABB center. Zero disables this bound. Range culling does not stop _Process, physics or unload resources. With zero margins both adjacent models can be visible at an exact shared threshold.

public float VisibilityRangeBeginMargin { get; set; }

Margin around the lower bound. With fading disabled it supplies state-dependent switching hysteresis, not automatic transparency. Coordinate it with the neighboring model’s upper range.

public float VisibilityRangeEnd { get; set; }

Upper visibility-distance bound; zero disables it. Measured to the transformed AABB center, not necessarily the entity origin. Selects visible geometry; does not stream resources or automatically simplify triangles.

public float VisibilityRangeEndMargin { get; set; }

Margin around the upper bound. With fading disabled it contributes to hysteresis; fade modes use it as a transition band. The value alone does not enable transparency or stop entity processing.

public GeometryInstance3D.VisibilityRangeFadeModeEnum VisibilityRangeFadeMode { get; set; }

Range-transition mode. Disabled switches visibility without transparent fading. Source configuration requires Forward+ for transparent Self/Dependencies fading; do not rely on it in Compatibility or Mobile. The native example verifies only Disabled with zero margins.

public Aabb GetCustomAabb();

Returns the stored CustomAabb value, not final server-side culling bounds. Calling RenderingServer.InstanceSetCustomAabb directly does not update this wrapper value.

public float GetExtraCullMargin();

Returns the stored extra local-bounds margin. A direct RenderingServer.InstanceSetExtraVisibilityMargin call changes server state but does not update this wrapper value.

public Variant GetInstanceShaderParameter(StringName name);

Reads the effective instance-uniform value for this geometry. After a Nil reset, the verified example returns the shader default White. This differs from ShaderMaterial.GetShaderParameter, which returns Nil without a stored override.

public Material GetMaterialOverlay();

Additional material for another draw pass. It neither replaces base MaterialOverride nor appears as GetActiveMaterial. Its queue, blending and depth still apply: an opaque overlay is not guaranteed on top. The check verifies a transparent alpha overlay blending with the base.

public Material GetMaterialOverride();

Base material for the entire instance, ahead of surface overrides and Mesh materials. Assignment does not clone the resource. null restores per-surface selection; MaterialOverlay remains a separate pass.

public void SetCustomAabb(Aabb aabb);

Stores CustomAabb and forwards it to the RenderingServer instance. The box uses local coordinates. For wind or other GPU deformation, cover every vertex position: the engine does not infer this displacement from shader code.

public void SetExtraCullMargin(float margin);

Grows local rendering bounds on every side before the instance transform is applied. Useful for vertex-shader displacement; reducing scale also reduces the world-space margin. Does not change source vertices, GetAabb() or collision. A negative value is rejected with an engine error and leaves the prior setting unchanged.

public void SetInstanceShaderParameter(StringName name, Variant value);

Sets an instance uniform on this geometry while other meshes retain a shared ShaderMaterial. The parameter must be declared as instance uniform. Nil removes the override and restores that parameter’s shader default.

public void SetMaterialOverlay(Material material);

Additional material for another draw pass. It neither replaces base MaterialOverride nor appears as GetActiveMaterial. Its queue, blending and depth still apply: an opaque overlay is not guaranteed on top. The check verifies a transparent alpha overlay blending with the base.

public void SetMaterialOverride(Material material);

Base material for the entire instance, ahead of surface overrides and Mesh materials. Assignment does not clone the resource. null restores per-surface selection; MaterialOverlay remains a separate pass.