1 /** 2 Default 3D rendering material. 3 4 Copyright: 5 Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur. 6 Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md) 7 Copyright (c) 2017-2018 Godot-D contributors 8 9 License: $(LINK2 https://opensource.org/licenses/MIT, MIT License) 10 11 12 */ 13 module godot.spatialmaterial; 14 import std.meta : AliasSeq, staticIndexOf; 15 import std.traits : Unqual; 16 import godot.d.traits; 17 import godot.core; 18 import godot.c; 19 import godot.d.bind; 20 import godot.d.reference; 21 import godot.globalenums; 22 import godot.object; 23 import godot.classdb; 24 import godot.material; 25 import godot.resource; 26 import godot.reference; 27 import godot.texture; 28 /** 29 Default 3D rendering material. 30 31 This provides a default material with a wide variety of rendering features and properties without the need to write shader code. See the tutorial below for details. 32 */ 33 @GodotBaseClass struct SpatialMaterial 34 { 35 package(godot) enum string _GODOT_internal_name = "SpatialMaterial"; 36 public: 37 @nogc nothrow: 38 union { /** */ godot_object _godot_object; /** */ Material _GODOT_base; } 39 alias _GODOT_base this; 40 alias BaseClasses = AliasSeq!(typeof(_GODOT_base), typeof(_GODOT_base).BaseClasses); 41 package(godot) __gshared bool _classBindingInitialized = false; 42 package(godot) static struct GDNativeClassBinding 43 { 44 __gshared: 45 @GodotName("get_albedo") GodotMethod!(Color) getAlbedo; 46 @GodotName("get_alpha_scissor_threshold") GodotMethod!(double) getAlphaScissorThreshold; 47 @GodotName("get_anisotropy") GodotMethod!(double) getAnisotropy; 48 @GodotName("get_ao_light_affect") GodotMethod!(double) getAoLightAffect; 49 @GodotName("get_ao_texture_channel") GodotMethod!(SpatialMaterial.TextureChannel) getAoTextureChannel; 50 @GodotName("get_billboard_mode") GodotMethod!(SpatialMaterial.BillboardMode) getBillboardMode; 51 @GodotName("get_blend_mode") GodotMethod!(SpatialMaterial.BlendMode) getBlendMode; 52 @GodotName("get_clearcoat") GodotMethod!(double) getClearcoat; 53 @GodotName("get_clearcoat_gloss") GodotMethod!(double) getClearcoatGloss; 54 @GodotName("get_cull_mode") GodotMethod!(SpatialMaterial.CullMode) getCullMode; 55 @GodotName("get_depth_deep_parallax_flip_binormal") GodotMethod!(bool) getDepthDeepParallaxFlipBinormal; 56 @GodotName("get_depth_deep_parallax_flip_tangent") GodotMethod!(bool) getDepthDeepParallaxFlipTangent; 57 @GodotName("get_depth_deep_parallax_max_layers") GodotMethod!(long) getDepthDeepParallaxMaxLayers; 58 @GodotName("get_depth_deep_parallax_min_layers") GodotMethod!(long) getDepthDeepParallaxMinLayers; 59 @GodotName("get_depth_draw_mode") GodotMethod!(SpatialMaterial.DepthDrawMode) getDepthDrawMode; 60 @GodotName("get_depth_scale") GodotMethod!(double) getDepthScale; 61 @GodotName("get_detail_blend_mode") GodotMethod!(SpatialMaterial.BlendMode) getDetailBlendMode; 62 @GodotName("get_detail_uv") GodotMethod!(SpatialMaterial.DetailUV) getDetailUv; 63 @GodotName("get_diffuse_mode") GodotMethod!(SpatialMaterial.DiffuseMode) getDiffuseMode; 64 @GodotName("get_distance_fade") GodotMethod!(SpatialMaterial.DistanceFadeMode) getDistanceFade; 65 @GodotName("get_distance_fade_max_distance") GodotMethod!(double) getDistanceFadeMaxDistance; 66 @GodotName("get_distance_fade_min_distance") GodotMethod!(double) getDistanceFadeMinDistance; 67 @GodotName("get_emission") GodotMethod!(Color) getEmission; 68 @GodotName("get_emission_energy") GodotMethod!(double) getEmissionEnergy; 69 @GodotName("get_emission_operator") GodotMethod!(SpatialMaterial.EmissionOperator) getEmissionOperator; 70 @GodotName("get_feature") GodotMethod!(bool, long) getFeature; 71 @GodotName("get_flag") GodotMethod!(bool, long) getFlag; 72 @GodotName("get_grow") GodotMethod!(double) getGrow; 73 @GodotName("get_line_width") GodotMethod!(double) getLineWidth; 74 @GodotName("get_metallic") GodotMethod!(double) getMetallic; 75 @GodotName("get_metallic_texture_channel") GodotMethod!(SpatialMaterial.TextureChannel) getMetallicTextureChannel; 76 @GodotName("get_normal_scale") GodotMethod!(double) getNormalScale; 77 @GodotName("get_particles_anim_h_frames") GodotMethod!(long) getParticlesAnimHFrames; 78 @GodotName("get_particles_anim_loop") GodotMethod!(bool) getParticlesAnimLoop; 79 @GodotName("get_particles_anim_v_frames") GodotMethod!(long) getParticlesAnimVFrames; 80 @GodotName("get_point_size") GodotMethod!(double) getPointSize; 81 @GodotName("get_proximity_fade_distance") GodotMethod!(double) getProximityFadeDistance; 82 @GodotName("get_refraction") GodotMethod!(double) getRefraction; 83 @GodotName("get_refraction_texture_channel") GodotMethod!(SpatialMaterial.TextureChannel) getRefractionTextureChannel; 84 @GodotName("get_rim") GodotMethod!(double) getRim; 85 @GodotName("get_rim_tint") GodotMethod!(double) getRimTint; 86 @GodotName("get_roughness") GodotMethod!(double) getRoughness; 87 @GodotName("get_roughness_texture_channel") GodotMethod!(SpatialMaterial.TextureChannel) getRoughnessTextureChannel; 88 @GodotName("get_specular") GodotMethod!(double) getSpecular; 89 @GodotName("get_specular_mode") GodotMethod!(SpatialMaterial.SpecularMode) getSpecularMode; 90 @GodotName("get_subsurface_scattering_strength") GodotMethod!(double) getSubsurfaceScatteringStrength; 91 @GodotName("get_texture") GodotMethod!(Texture, long) getTexture; 92 @GodotName("get_transmission") GodotMethod!(Color) getTransmission; 93 @GodotName("get_uv1_offset") GodotMethod!(Vector3) getUv1Offset; 94 @GodotName("get_uv1_scale") GodotMethod!(Vector3) getUv1Scale; 95 @GodotName("get_uv1_triplanar_blend_sharpness") GodotMethod!(double) getUv1TriplanarBlendSharpness; 96 @GodotName("get_uv2_offset") GodotMethod!(Vector3) getUv2Offset; 97 @GodotName("get_uv2_scale") GodotMethod!(Vector3) getUv2Scale; 98 @GodotName("get_uv2_triplanar_blend_sharpness") GodotMethod!(double) getUv2TriplanarBlendSharpness; 99 @GodotName("is_depth_deep_parallax_enabled") GodotMethod!(bool) isDepthDeepParallaxEnabled; 100 @GodotName("is_grow_enabled") GodotMethod!(bool) isGrowEnabled; 101 @GodotName("is_proximity_fade_enabled") GodotMethod!(bool) isProximityFadeEnabled; 102 @GodotName("set_albedo") GodotMethod!(void, Color) setAlbedo; 103 @GodotName("set_alpha_scissor_threshold") GodotMethod!(void, double) setAlphaScissorThreshold; 104 @GodotName("set_anisotropy") GodotMethod!(void, double) setAnisotropy; 105 @GodotName("set_ao_light_affect") GodotMethod!(void, double) setAoLightAffect; 106 @GodotName("set_ao_texture_channel") GodotMethod!(void, long) setAoTextureChannel; 107 @GodotName("set_billboard_mode") GodotMethod!(void, long) setBillboardMode; 108 @GodotName("set_blend_mode") GodotMethod!(void, long) setBlendMode; 109 @GodotName("set_clearcoat") GodotMethod!(void, double) setClearcoat; 110 @GodotName("set_clearcoat_gloss") GodotMethod!(void, double) setClearcoatGloss; 111 @GodotName("set_cull_mode") GodotMethod!(void, long) setCullMode; 112 @GodotName("set_depth_deep_parallax") GodotMethod!(void, bool) setDepthDeepParallax; 113 @GodotName("set_depth_deep_parallax_flip_binormal") GodotMethod!(void, bool) setDepthDeepParallaxFlipBinormal; 114 @GodotName("set_depth_deep_parallax_flip_tangent") GodotMethod!(void, bool) setDepthDeepParallaxFlipTangent; 115 @GodotName("set_depth_deep_parallax_max_layers") GodotMethod!(void, long) setDepthDeepParallaxMaxLayers; 116 @GodotName("set_depth_deep_parallax_min_layers") GodotMethod!(void, long) setDepthDeepParallaxMinLayers; 117 @GodotName("set_depth_draw_mode") GodotMethod!(void, long) setDepthDrawMode; 118 @GodotName("set_depth_scale") GodotMethod!(void, double) setDepthScale; 119 @GodotName("set_detail_blend_mode") GodotMethod!(void, long) setDetailBlendMode; 120 @GodotName("set_detail_uv") GodotMethod!(void, long) setDetailUv; 121 @GodotName("set_diffuse_mode") GodotMethod!(void, long) setDiffuseMode; 122 @GodotName("set_distance_fade") GodotMethod!(void, long) setDistanceFade; 123 @GodotName("set_distance_fade_max_distance") GodotMethod!(void, double) setDistanceFadeMaxDistance; 124 @GodotName("set_distance_fade_min_distance") GodotMethod!(void, double) setDistanceFadeMinDistance; 125 @GodotName("set_emission") GodotMethod!(void, Color) setEmission; 126 @GodotName("set_emission_energy") GodotMethod!(void, double) setEmissionEnergy; 127 @GodotName("set_emission_operator") GodotMethod!(void, long) setEmissionOperator; 128 @GodotName("set_feature") GodotMethod!(void, long, bool) setFeature; 129 @GodotName("set_flag") GodotMethod!(void, long, bool) setFlag; 130 @GodotName("set_grow") GodotMethod!(void, double) setGrow; 131 @GodotName("set_grow_enabled") GodotMethod!(void, bool) setGrowEnabled; 132 @GodotName("set_line_width") GodotMethod!(void, double) setLineWidth; 133 @GodotName("set_metallic") GodotMethod!(void, double) setMetallic; 134 @GodotName("set_metallic_texture_channel") GodotMethod!(void, long) setMetallicTextureChannel; 135 @GodotName("set_normal_scale") GodotMethod!(void, double) setNormalScale; 136 @GodotName("set_particles_anim_h_frames") GodotMethod!(void, long) setParticlesAnimHFrames; 137 @GodotName("set_particles_anim_loop") GodotMethod!(void, bool) setParticlesAnimLoop; 138 @GodotName("set_particles_anim_v_frames") GodotMethod!(void, long) setParticlesAnimVFrames; 139 @GodotName("set_point_size") GodotMethod!(void, double) setPointSize; 140 @GodotName("set_proximity_fade") GodotMethod!(void, bool) setProximityFade; 141 @GodotName("set_proximity_fade_distance") GodotMethod!(void, double) setProximityFadeDistance; 142 @GodotName("set_refraction") GodotMethod!(void, double) setRefraction; 143 @GodotName("set_refraction_texture_channel") GodotMethod!(void, long) setRefractionTextureChannel; 144 @GodotName("set_rim") GodotMethod!(void, double) setRim; 145 @GodotName("set_rim_tint") GodotMethod!(void, double) setRimTint; 146 @GodotName("set_roughness") GodotMethod!(void, double) setRoughness; 147 @GodotName("set_roughness_texture_channel") GodotMethod!(void, long) setRoughnessTextureChannel; 148 @GodotName("set_specular") GodotMethod!(void, double) setSpecular; 149 @GodotName("set_specular_mode") GodotMethod!(void, long) setSpecularMode; 150 @GodotName("set_subsurface_scattering_strength") GodotMethod!(void, double) setSubsurfaceScatteringStrength; 151 @GodotName("set_texture") GodotMethod!(void, long, Texture) setTexture; 152 @GodotName("set_transmission") GodotMethod!(void, Color) setTransmission; 153 @GodotName("set_uv1_offset") GodotMethod!(void, Vector3) setUv1Offset; 154 @GodotName("set_uv1_scale") GodotMethod!(void, Vector3) setUv1Scale; 155 @GodotName("set_uv1_triplanar_blend_sharpness") GodotMethod!(void, double) setUv1TriplanarBlendSharpness; 156 @GodotName("set_uv2_offset") GodotMethod!(void, Vector3) setUv2Offset; 157 @GodotName("set_uv2_scale") GodotMethod!(void, Vector3) setUv2Scale; 158 @GodotName("set_uv2_triplanar_blend_sharpness") GodotMethod!(void, double) setUv2TriplanarBlendSharpness; 159 } 160 /// 161 pragma(inline, true) bool opEquals(in SpatialMaterial other) const 162 { return _godot_object.ptr is other._godot_object.ptr; } 163 /// 164 pragma(inline, true) typeof(null) opAssign(typeof(null) n) 165 { _godot_object.ptr = n; return null; } 166 /// 167 pragma(inline, true) bool opEquals(typeof(null) n) const 168 { return _godot_object.ptr is n; } 169 /// 170 size_t toHash() const @trusted { return cast(size_t)_godot_object.ptr; } 171 mixin baseCasts; 172 /// Construct a new instance of SpatialMaterial. 173 /// Note: use `memnew!SpatialMaterial` instead. 174 static SpatialMaterial _new() 175 { 176 static godot_class_constructor constructor; 177 if(constructor is null) constructor = _godot_api.godot_get_class_constructor("SpatialMaterial"); 178 if(constructor is null) return typeof(this).init; 179 return cast(SpatialMaterial)(constructor()); 180 } 181 @disable new(size_t s); 182 /// 183 enum EmissionOperator : int 184 { 185 /** 186 Adds the emission color to the color from the emission texture. 187 */ 188 emissionOpAdd = 0, 189 /** 190 Multiplies the emission color by the color from the emission texture. 191 */ 192 emissionOpMultiply = 1, 193 } 194 /// 195 enum DiffuseMode : int 196 { 197 /** 198 Default diffuse scattering algorithm. 199 */ 200 diffuseBurley = 0, 201 /** 202 Diffuse scattering ignores roughness. 203 */ 204 diffuseLambert = 1, 205 /** 206 Extends Lambert to cover more than 90 degrees when roughness increases. 207 */ 208 diffuseLambertWrap = 2, 209 /** 210 Attempts to use roughness to emulate microsurfacing. 211 */ 212 diffuseOrenNayar = 3, 213 /** 214 Uses a hard cut for lighting, with smoothing affected by roughness. 215 */ 216 diffuseToon = 4, 217 } 218 /// 219 enum SpecularMode : int 220 { 221 /** 222 Default specular blob. 223 */ 224 specularSchlickGgx = 0, 225 /** 226 Older specular algorithm, included for compatibility. 227 */ 228 specularBlinn = 1, 229 /** 230 Older specular algorithm, included for compatibility. 231 */ 232 specularPhong = 2, 233 /** 234 Toon blob which changes size based on roughness. 235 */ 236 specularToon = 3, 237 /** 238 No specular blob. 239 */ 240 specularDisabled = 4, 241 } 242 /// 243 enum Feature : int 244 { 245 /** 246 Constant for setting $(D flagsTransparent). 247 */ 248 featureTransparent = 0, 249 /** 250 Constant for setting $(D emissionEnabled). 251 */ 252 featureEmission = 1, 253 /** 254 Constant for setting $(D normalEnabled). 255 */ 256 featureNormalMapping = 2, 257 /** 258 Constant for setting $(D rimEnabled). 259 */ 260 featureRim = 3, 261 /** 262 Constant for setting $(D clearcoatEnabled). 263 */ 264 featureClearcoat = 4, 265 /** 266 Constant for setting $(D anisotropyEnabled). 267 */ 268 featureAnisotropy = 5, 269 /** 270 Constant for setting $(D aoEnabled). 271 */ 272 featureAmbientOcclusion = 6, 273 /** 274 Constant for setting $(D depthEnabled). 275 */ 276 featureDepthMapping = 7, 277 /** 278 Constant for setting $(D subsurfScatterEnabled). 279 */ 280 featureSubsuraceScattering = 8, 281 /** 282 Constant for setting $(D transmissionEnabled). 283 */ 284 featureTransmission = 9, 285 /** 286 Constant for setting $(D refractionEnabled). 287 */ 288 featureRefraction = 10, 289 /** 290 Constant for setting $(D detailEnabled). 291 */ 292 featureDetail = 11, 293 /** 294 Represents the size of the $(D feature) enum. 295 */ 296 featureMax = 12, 297 } 298 /// 299 enum Flags : int 300 { 301 /** 302 No lighting is used on the object. Color comes directly from `ALBEDO`. 303 */ 304 flagUnshaded = 0, 305 /** 306 Lighting is calculated per-vertex rather than per-pixel. This can be used to increase the speed of the shader at the cost of quality. 307 */ 308 flagUseVertexLighting = 1, 309 /** 310 Disables the depth test, so this object is drawn on top of all others. However, objects drawn after it in the draw order may cover it. 311 */ 312 flagDisableDepthTest = 2, 313 /** 314 Set `ALBEDO` to the per-vertex color specified in the mesh. 315 */ 316 flagAlbedoFromVertexColor = 3, 317 /** 318 Vertex color is in sRGB space and needs to be converted to linear. Only applies in the GLES3 renderer. 319 */ 320 flagSrgbVertexColor = 4, 321 /** 322 Uses point size to alter the size of primitive points. Also changes the albedo texture lookup to use `POINT_COORD` instead of `UV`. 323 */ 324 flagUsePointSize = 5, 325 /** 326 Object is scaled by depth so that it always appears the same size on screen. 327 */ 328 flagFixedSize = 6, 329 /** 330 Shader will keep the scale set for the mesh. Otherwise the scale is lost when billboarding. Only applies when $(D paramsBillboardMode) is $(D constant BILLBOARD_ENABLED). 331 */ 332 flagBillboardKeepScale = 7, 333 /** 334 Use triplanar texture lookup for all texture lookups that would normally use `UV`. 335 */ 336 flagUv1UseTriplanar = 8, 337 /** 338 Use triplanar texture lookup for all texture lookups that would normally use `UV2`. 339 */ 340 flagUv2UseTriplanar = 9, 341 /** 342 Use world coordinates in the triplanar texture lookup instead of local coordinates. 343 */ 344 flagTriplanarUseWorld = 10, 345 /** 346 Use `UV2` coordinates to look up from the $(D aoTexture). 347 */ 348 flagAoOnUv2 = 11, 349 /** 350 Use `UV2` coordinates to look up from the $(D emissionTexture). 351 */ 352 flagEmissionOnUv2 = 12, 353 /** 354 Use alpha scissor. Set by $(D paramsUseAlphaScissor). 355 */ 356 flagUseAlphaScissor = 13, 357 /** 358 Forces the shader to convert albedo from sRGB space to linear space. 359 */ 360 flagAlbedoTextureForceSrgb = 14, 361 /** 362 Disables receiving shadows from other objects. 363 */ 364 flagDontReceiveShadows = 15, 365 /** 366 Ensures that normals appear correct, even with non-uniform scaling. 367 */ 368 flagEnsureCorrectNormals = 16, 369 /** 370 Disables receiving ambient light. 371 */ 372 flagDisableAmbientLight = 17, 373 /** 374 Enables the shadow to opacity feature. 375 */ 376 flagUseShadowToOpacity = 18, 377 /** 378 Represents the size of the $(D flags) enum. 379 */ 380 flagMax = 19, 381 } 382 /// 383 enum CullMode : int 384 { 385 /** 386 Default cull mode. The back of the object is culled when not visible. 387 */ 388 cullBack = 0, 389 /** 390 The front of the object is culled when not visible. 391 */ 392 cullFront = 1, 393 /** 394 No culling is performed. 395 */ 396 cullDisabled = 2, 397 } 398 /// 399 enum DetailUV : int 400 { 401 /** 402 Use `UV` with the detail texture. 403 */ 404 detailUv1 = 0, 405 /** 406 Use `UV2` with the detail texture. 407 */ 408 detailUv2 = 1, 409 } 410 /// 411 enum DistanceFadeMode : int 412 { 413 /** 414 Do not use distance fade. 415 */ 416 distanceFadeDisabled = 0, 417 /** 418 Smoothly fades the object out based on each pixel's distance from the camera using the alpha channel. 419 */ 420 distanceFadePixelAlpha = 1, 421 /** 422 Smoothly fades the object out based on each pixel's distance from the camera using a dither approach. Dithering discards pixels based on a set pattern to smoothly fade without enabling transparency. On certain hardware this can be faster than $(D constant DISTANCE_FADE_PIXEL_ALPHA). 423 */ 424 distanceFadePixelDither = 2, 425 /** 426 Smoothly fades the object out based on the object's distance from the camera using a dither approach. Dithering discards pixels based on a set pattern to smoothly fade without enabling transparency. On certain hardware this can be faster than $(D constant DISTANCE_FADE_PIXEL_ALPHA). 427 */ 428 distanceFadeObjectDither = 3, 429 } 430 /// 431 enum BillboardMode : int 432 { 433 /** 434 Billboard mode is disabled. 435 */ 436 billboardDisabled = 0, 437 /** 438 The object's Z axis will always face the camera. 439 */ 440 billboardEnabled = 1, 441 /** 442 The object's X axis will always face the camera. 443 */ 444 billboardFixedY = 2, 445 /** 446 Used for particle systems when assigned to $(D Particles) and $(D CPUParticles) nodes. Enables `particles_anim_*` properties. 447 The $(D ParticlesMaterial.animSpeed) or $(D CPUParticles.animSpeed) should also be set to a positive value for the animation to play. 448 */ 449 billboardParticles = 3, 450 } 451 /// 452 enum DepthDrawMode : int 453 { 454 /** 455 Default depth draw mode. Depth is drawn only for opaque objects. 456 */ 457 depthDrawOpaqueOnly = 0, 458 /** 459 Depth draw is calculated for both opaque and transparent objects. 460 */ 461 depthDrawAlways = 1, 462 /** 463 No depth draw. 464 */ 465 depthDrawDisabled = 2, 466 /** 467 For transparent objects, an opaque pass is made first with the opaque parts, then transparency is drawn. 468 */ 469 depthDrawAlphaOpaquePrepass = 3, 470 } 471 /// 472 enum TextureChannel : int 473 { 474 /** 475 Used to read from the red channel of a texture. 476 */ 477 textureChannelRed = 0, 478 /** 479 Used to read from the green channel of a texture. 480 */ 481 textureChannelGreen = 1, 482 /** 483 Used to read from the blue channel of a texture. 484 */ 485 textureChannelBlue = 2, 486 /** 487 Used to read from the alpha channel of a texture. 488 */ 489 textureChannelAlpha = 3, 490 /** 491 Currently unused. 492 */ 493 textureChannelGrayscale = 4, 494 } 495 /// 496 enum BlendMode : int 497 { 498 /** 499 Default blend mode. The color of the object is blended over the background based on the object's alpha value. 500 */ 501 blendModeMix = 0, 502 /** 503 The color of the object is added to the background. 504 */ 505 blendModeAdd = 1, 506 /** 507 The color of the object is subtracted from the background. 508 */ 509 blendModeSub = 2, 510 /** 511 The color of the object is multiplied by the background. 512 */ 513 blendModeMul = 3, 514 } 515 /// 516 enum TextureParam : int 517 { 518 /** 519 Texture specifying per-pixel color. 520 */ 521 textureAlbedo = 0, 522 /** 523 Texture specifying per-pixel metallic value. 524 */ 525 textureMetallic = 1, 526 /** 527 Texture specifying per-pixel roughness value. 528 */ 529 textureRoughness = 2, 530 /** 531 Texture specifying per-pixel emission color. 532 */ 533 textureEmission = 3, 534 /** 535 Texture specifying per-pixel normal vector. 536 */ 537 textureNormal = 4, 538 /** 539 Texture specifying per-pixel rim value. 540 */ 541 textureRim = 5, 542 /** 543 Texture specifying per-pixel clearcoat value. 544 */ 545 textureClearcoat = 6, 546 /** 547 Texture specifying per-pixel flowmap direction for use with $(D anisotropy). 548 */ 549 textureFlowmap = 7, 550 /** 551 Texture specifying per-pixel ambient occlusion value. 552 */ 553 textureAmbientOcclusion = 8, 554 /** 555 Texture specifying per-pixel depth. 556 */ 557 textureDepth = 9, 558 /** 559 Texture specifying per-pixel subsurface scattering. 560 */ 561 textureSubsurfaceScattering = 10, 562 /** 563 Texture specifying per-pixel transmission color. 564 */ 565 textureTransmission = 11, 566 /** 567 Texture specifying per-pixel refraction strength. 568 */ 569 textureRefraction = 12, 570 /** 571 Texture specifying per-pixel detail mask blending value. 572 */ 573 textureDetailMask = 13, 574 /** 575 Texture specifying per-pixel detail color. 576 */ 577 textureDetailAlbedo = 14, 578 /** 579 Texture specifying per-pixel detail normal. 580 */ 581 textureDetailNormal = 15, 582 /** 583 Represents the size of the $(D textureparam) enum. 584 */ 585 textureMax = 16, 586 } 587 /// 588 enum Constants : int 589 { 590 emissionOpAdd = 0, 591 cullBack = 0, 592 depthDrawOpaqueOnly = 0, 593 diffuseBurley = 0, 594 distanceFadeDisabled = 0, 595 blendModeMix = 0, 596 featureTransparent = 0, 597 billboardDisabled = 0, 598 flagUnshaded = 0, 599 textureAlbedo = 0, 600 textureChannelRed = 0, 601 specularSchlickGgx = 0, 602 detailUv1 = 0, 603 diffuseLambert = 1, 604 cullFront = 1, 605 specularBlinn = 1, 606 blendModeAdd = 1, 607 textureMetallic = 1, 608 depthDrawAlways = 1, 609 textureChannelGreen = 1, 610 featureEmission = 1, 611 emissionOpMultiply = 1, 612 flagUseVertexLighting = 1, 613 distanceFadePixelAlpha = 1, 614 billboardEnabled = 1, 615 detailUv2 = 1, 616 flagDisableDepthTest = 2, 617 blendModeSub = 2, 618 textureRoughness = 2, 619 featureNormalMapping = 2, 620 textureChannelBlue = 2, 621 cullDisabled = 2, 622 depthDrawDisabled = 2, 623 diffuseLambertWrap = 2, 624 specularPhong = 2, 625 billboardFixedY = 2, 626 distanceFadePixelDither = 2, 627 distanceFadeObjectDither = 3, 628 textureEmission = 3, 629 billboardParticles = 3, 630 specularToon = 3, 631 diffuseOrenNayar = 3, 632 flagAlbedoFromVertexColor = 3, 633 featureRim = 3, 634 textureChannelAlpha = 3, 635 blendModeMul = 3, 636 depthDrawAlphaOpaquePrepass = 3, 637 diffuseToon = 4, 638 featureClearcoat = 4, 639 textureChannelGrayscale = 4, 640 specularDisabled = 4, 641 flagSrgbVertexColor = 4, 642 textureNormal = 4, 643 flagUsePointSize = 5, 644 featureAnisotropy = 5, 645 textureRim = 5, 646 featureAmbientOcclusion = 6, 647 textureClearcoat = 6, 648 flagFixedSize = 6, 649 flagBillboardKeepScale = 7, 650 textureFlowmap = 7, 651 featureDepthMapping = 7, 652 flagUv1UseTriplanar = 8, 653 featureSubsuraceScattering = 8, 654 textureAmbientOcclusion = 8, 655 textureDepth = 9, 656 flagUv2UseTriplanar = 9, 657 featureTransmission = 9, 658 flagTriplanarUseWorld = 10, 659 featureRefraction = 10, 660 textureSubsurfaceScattering = 10, 661 featureDetail = 11, 662 textureTransmission = 11, 663 flagAoOnUv2 = 11, 664 featureMax = 12, 665 flagEmissionOnUv2 = 12, 666 textureRefraction = 12, 667 flagUseAlphaScissor = 13, 668 textureDetailMask = 13, 669 textureDetailAlbedo = 14, 670 flagAlbedoTextureForceSrgb = 14, 671 textureDetailNormal = 15, 672 flagDontReceiveShadows = 15, 673 textureMax = 16, 674 flagEnsureCorrectNormals = 16, 675 flagDisableAmbientLight = 17, 676 flagUseShadowToOpacity = 18, 677 flagMax = 19, 678 } 679 /** 680 681 */ 682 Color getAlbedo() const 683 { 684 checkClassBinding!(typeof(this))(); 685 return ptrcall!(Color)(GDNativeClassBinding.getAlbedo, _godot_object); 686 } 687 /** 688 689 */ 690 double getAlphaScissorThreshold() const 691 { 692 checkClassBinding!(typeof(this))(); 693 return ptrcall!(double)(GDNativeClassBinding.getAlphaScissorThreshold, _godot_object); 694 } 695 /** 696 697 */ 698 double getAnisotropy() const 699 { 700 checkClassBinding!(typeof(this))(); 701 return ptrcall!(double)(GDNativeClassBinding.getAnisotropy, _godot_object); 702 } 703 /** 704 705 */ 706 double getAoLightAffect() const 707 { 708 checkClassBinding!(typeof(this))(); 709 return ptrcall!(double)(GDNativeClassBinding.getAoLightAffect, _godot_object); 710 } 711 /** 712 713 */ 714 SpatialMaterial.TextureChannel getAoTextureChannel() const 715 { 716 checkClassBinding!(typeof(this))(); 717 return ptrcall!(SpatialMaterial.TextureChannel)(GDNativeClassBinding.getAoTextureChannel, _godot_object); 718 } 719 /** 720 721 */ 722 SpatialMaterial.BillboardMode getBillboardMode() const 723 { 724 checkClassBinding!(typeof(this))(); 725 return ptrcall!(SpatialMaterial.BillboardMode)(GDNativeClassBinding.getBillboardMode, _godot_object); 726 } 727 /** 728 729 */ 730 SpatialMaterial.BlendMode getBlendMode() const 731 { 732 checkClassBinding!(typeof(this))(); 733 return ptrcall!(SpatialMaterial.BlendMode)(GDNativeClassBinding.getBlendMode, _godot_object); 734 } 735 /** 736 737 */ 738 double getClearcoat() const 739 { 740 checkClassBinding!(typeof(this))(); 741 return ptrcall!(double)(GDNativeClassBinding.getClearcoat, _godot_object); 742 } 743 /** 744 745 */ 746 double getClearcoatGloss() const 747 { 748 checkClassBinding!(typeof(this))(); 749 return ptrcall!(double)(GDNativeClassBinding.getClearcoatGloss, _godot_object); 750 } 751 /** 752 753 */ 754 SpatialMaterial.CullMode getCullMode() const 755 { 756 checkClassBinding!(typeof(this))(); 757 return ptrcall!(SpatialMaterial.CullMode)(GDNativeClassBinding.getCullMode, _godot_object); 758 } 759 /** 760 761 */ 762 bool getDepthDeepParallaxFlipBinormal() const 763 { 764 checkClassBinding!(typeof(this))(); 765 return ptrcall!(bool)(GDNativeClassBinding.getDepthDeepParallaxFlipBinormal, _godot_object); 766 } 767 /** 768 769 */ 770 bool getDepthDeepParallaxFlipTangent() const 771 { 772 checkClassBinding!(typeof(this))(); 773 return ptrcall!(bool)(GDNativeClassBinding.getDepthDeepParallaxFlipTangent, _godot_object); 774 } 775 /** 776 777 */ 778 long getDepthDeepParallaxMaxLayers() const 779 { 780 checkClassBinding!(typeof(this))(); 781 return ptrcall!(long)(GDNativeClassBinding.getDepthDeepParallaxMaxLayers, _godot_object); 782 } 783 /** 784 785 */ 786 long getDepthDeepParallaxMinLayers() const 787 { 788 checkClassBinding!(typeof(this))(); 789 return ptrcall!(long)(GDNativeClassBinding.getDepthDeepParallaxMinLayers, _godot_object); 790 } 791 /** 792 793 */ 794 SpatialMaterial.DepthDrawMode getDepthDrawMode() const 795 { 796 checkClassBinding!(typeof(this))(); 797 return ptrcall!(SpatialMaterial.DepthDrawMode)(GDNativeClassBinding.getDepthDrawMode, _godot_object); 798 } 799 /** 800 801 */ 802 double getDepthScale() const 803 { 804 checkClassBinding!(typeof(this))(); 805 return ptrcall!(double)(GDNativeClassBinding.getDepthScale, _godot_object); 806 } 807 /** 808 809 */ 810 SpatialMaterial.BlendMode getDetailBlendMode() const 811 { 812 checkClassBinding!(typeof(this))(); 813 return ptrcall!(SpatialMaterial.BlendMode)(GDNativeClassBinding.getDetailBlendMode, _godot_object); 814 } 815 /** 816 817 */ 818 SpatialMaterial.DetailUV getDetailUv() const 819 { 820 checkClassBinding!(typeof(this))(); 821 return ptrcall!(SpatialMaterial.DetailUV)(GDNativeClassBinding.getDetailUv, _godot_object); 822 } 823 /** 824 825 */ 826 SpatialMaterial.DiffuseMode getDiffuseMode() const 827 { 828 checkClassBinding!(typeof(this))(); 829 return ptrcall!(SpatialMaterial.DiffuseMode)(GDNativeClassBinding.getDiffuseMode, _godot_object); 830 } 831 /** 832 833 */ 834 SpatialMaterial.DistanceFadeMode getDistanceFade() const 835 { 836 checkClassBinding!(typeof(this))(); 837 return ptrcall!(SpatialMaterial.DistanceFadeMode)(GDNativeClassBinding.getDistanceFade, _godot_object); 838 } 839 /** 840 841 */ 842 double getDistanceFadeMaxDistance() const 843 { 844 checkClassBinding!(typeof(this))(); 845 return ptrcall!(double)(GDNativeClassBinding.getDistanceFadeMaxDistance, _godot_object); 846 } 847 /** 848 849 */ 850 double getDistanceFadeMinDistance() const 851 { 852 checkClassBinding!(typeof(this))(); 853 return ptrcall!(double)(GDNativeClassBinding.getDistanceFadeMinDistance, _godot_object); 854 } 855 /** 856 857 */ 858 Color getEmission() const 859 { 860 checkClassBinding!(typeof(this))(); 861 return ptrcall!(Color)(GDNativeClassBinding.getEmission, _godot_object); 862 } 863 /** 864 865 */ 866 double getEmissionEnergy() const 867 { 868 checkClassBinding!(typeof(this))(); 869 return ptrcall!(double)(GDNativeClassBinding.getEmissionEnergy, _godot_object); 870 } 871 /** 872 873 */ 874 SpatialMaterial.EmissionOperator getEmissionOperator() const 875 { 876 checkClassBinding!(typeof(this))(); 877 return ptrcall!(SpatialMaterial.EmissionOperator)(GDNativeClassBinding.getEmissionOperator, _godot_object); 878 } 879 /** 880 Returns `true`, if the specified $(D feature) is enabled. 881 */ 882 bool getFeature(in long feature) const 883 { 884 checkClassBinding!(typeof(this))(); 885 return ptrcall!(bool)(GDNativeClassBinding.getFeature, _godot_object, feature); 886 } 887 /** 888 Returns `true`, if the specified flag is enabled. See $(D flags) enumerator for options. 889 */ 890 bool getFlag(in long flag) const 891 { 892 checkClassBinding!(typeof(this))(); 893 return ptrcall!(bool)(GDNativeClassBinding.getFlag, _godot_object, flag); 894 } 895 /** 896 897 */ 898 double getGrow() const 899 { 900 checkClassBinding!(typeof(this))(); 901 return ptrcall!(double)(GDNativeClassBinding.getGrow, _godot_object); 902 } 903 /** 904 905 */ 906 double getLineWidth() const 907 { 908 checkClassBinding!(typeof(this))(); 909 return ptrcall!(double)(GDNativeClassBinding.getLineWidth, _godot_object); 910 } 911 /** 912 913 */ 914 double getMetallic() const 915 { 916 checkClassBinding!(typeof(this))(); 917 return ptrcall!(double)(GDNativeClassBinding.getMetallic, _godot_object); 918 } 919 /** 920 921 */ 922 SpatialMaterial.TextureChannel getMetallicTextureChannel() const 923 { 924 checkClassBinding!(typeof(this))(); 925 return ptrcall!(SpatialMaterial.TextureChannel)(GDNativeClassBinding.getMetallicTextureChannel, _godot_object); 926 } 927 /** 928 929 */ 930 double getNormalScale() const 931 { 932 checkClassBinding!(typeof(this))(); 933 return ptrcall!(double)(GDNativeClassBinding.getNormalScale, _godot_object); 934 } 935 /** 936 937 */ 938 long getParticlesAnimHFrames() const 939 { 940 checkClassBinding!(typeof(this))(); 941 return ptrcall!(long)(GDNativeClassBinding.getParticlesAnimHFrames, _godot_object); 942 } 943 /** 944 945 */ 946 bool getParticlesAnimLoop() const 947 { 948 checkClassBinding!(typeof(this))(); 949 return ptrcall!(bool)(GDNativeClassBinding.getParticlesAnimLoop, _godot_object); 950 } 951 /** 952 953 */ 954 long getParticlesAnimVFrames() const 955 { 956 checkClassBinding!(typeof(this))(); 957 return ptrcall!(long)(GDNativeClassBinding.getParticlesAnimVFrames, _godot_object); 958 } 959 /** 960 961 */ 962 double getPointSize() const 963 { 964 checkClassBinding!(typeof(this))(); 965 return ptrcall!(double)(GDNativeClassBinding.getPointSize, _godot_object); 966 } 967 /** 968 969 */ 970 double getProximityFadeDistance() const 971 { 972 checkClassBinding!(typeof(this))(); 973 return ptrcall!(double)(GDNativeClassBinding.getProximityFadeDistance, _godot_object); 974 } 975 /** 976 977 */ 978 double getRefraction() const 979 { 980 checkClassBinding!(typeof(this))(); 981 return ptrcall!(double)(GDNativeClassBinding.getRefraction, _godot_object); 982 } 983 /** 984 985 */ 986 SpatialMaterial.TextureChannel getRefractionTextureChannel() const 987 { 988 checkClassBinding!(typeof(this))(); 989 return ptrcall!(SpatialMaterial.TextureChannel)(GDNativeClassBinding.getRefractionTextureChannel, _godot_object); 990 } 991 /** 992 993 */ 994 double getRim() const 995 { 996 checkClassBinding!(typeof(this))(); 997 return ptrcall!(double)(GDNativeClassBinding.getRim, _godot_object); 998 } 999 /** 1000 1001 */ 1002 double getRimTint() const 1003 { 1004 checkClassBinding!(typeof(this))(); 1005 return ptrcall!(double)(GDNativeClassBinding.getRimTint, _godot_object); 1006 } 1007 /** 1008 1009 */ 1010 double getRoughness() const 1011 { 1012 checkClassBinding!(typeof(this))(); 1013 return ptrcall!(double)(GDNativeClassBinding.getRoughness, _godot_object); 1014 } 1015 /** 1016 1017 */ 1018 SpatialMaterial.TextureChannel getRoughnessTextureChannel() const 1019 { 1020 checkClassBinding!(typeof(this))(); 1021 return ptrcall!(SpatialMaterial.TextureChannel)(GDNativeClassBinding.getRoughnessTextureChannel, _godot_object); 1022 } 1023 /** 1024 1025 */ 1026 double getSpecular() const 1027 { 1028 checkClassBinding!(typeof(this))(); 1029 return ptrcall!(double)(GDNativeClassBinding.getSpecular, _godot_object); 1030 } 1031 /** 1032 1033 */ 1034 SpatialMaterial.SpecularMode getSpecularMode() const 1035 { 1036 checkClassBinding!(typeof(this))(); 1037 return ptrcall!(SpatialMaterial.SpecularMode)(GDNativeClassBinding.getSpecularMode, _godot_object); 1038 } 1039 /** 1040 1041 */ 1042 double getSubsurfaceScatteringStrength() const 1043 { 1044 checkClassBinding!(typeof(this))(); 1045 return ptrcall!(double)(GDNativeClassBinding.getSubsurfaceScatteringStrength, _godot_object); 1046 } 1047 /** 1048 Returns the $(D Texture) associated with the specified $(D textureparam). 1049 */ 1050 Ref!Texture getTexture(in long param) const 1051 { 1052 checkClassBinding!(typeof(this))(); 1053 return ptrcall!(Texture)(GDNativeClassBinding.getTexture, _godot_object, param); 1054 } 1055 /** 1056 1057 */ 1058 Color getTransmission() const 1059 { 1060 checkClassBinding!(typeof(this))(); 1061 return ptrcall!(Color)(GDNativeClassBinding.getTransmission, _godot_object); 1062 } 1063 /** 1064 1065 */ 1066 Vector3 getUv1Offset() const 1067 { 1068 checkClassBinding!(typeof(this))(); 1069 return ptrcall!(Vector3)(GDNativeClassBinding.getUv1Offset, _godot_object); 1070 } 1071 /** 1072 1073 */ 1074 Vector3 getUv1Scale() const 1075 { 1076 checkClassBinding!(typeof(this))(); 1077 return ptrcall!(Vector3)(GDNativeClassBinding.getUv1Scale, _godot_object); 1078 } 1079 /** 1080 1081 */ 1082 double getUv1TriplanarBlendSharpness() const 1083 { 1084 checkClassBinding!(typeof(this))(); 1085 return ptrcall!(double)(GDNativeClassBinding.getUv1TriplanarBlendSharpness, _godot_object); 1086 } 1087 /** 1088 1089 */ 1090 Vector3 getUv2Offset() const 1091 { 1092 checkClassBinding!(typeof(this))(); 1093 return ptrcall!(Vector3)(GDNativeClassBinding.getUv2Offset, _godot_object); 1094 } 1095 /** 1096 1097 */ 1098 Vector3 getUv2Scale() const 1099 { 1100 checkClassBinding!(typeof(this))(); 1101 return ptrcall!(Vector3)(GDNativeClassBinding.getUv2Scale, _godot_object); 1102 } 1103 /** 1104 1105 */ 1106 double getUv2TriplanarBlendSharpness() const 1107 { 1108 checkClassBinding!(typeof(this))(); 1109 return ptrcall!(double)(GDNativeClassBinding.getUv2TriplanarBlendSharpness, _godot_object); 1110 } 1111 /** 1112 1113 */ 1114 bool isDepthDeepParallaxEnabled() const 1115 { 1116 checkClassBinding!(typeof(this))(); 1117 return ptrcall!(bool)(GDNativeClassBinding.isDepthDeepParallaxEnabled, _godot_object); 1118 } 1119 /** 1120 1121 */ 1122 bool isGrowEnabled() const 1123 { 1124 checkClassBinding!(typeof(this))(); 1125 return ptrcall!(bool)(GDNativeClassBinding.isGrowEnabled, _godot_object); 1126 } 1127 /** 1128 1129 */ 1130 bool isProximityFadeEnabled() const 1131 { 1132 checkClassBinding!(typeof(this))(); 1133 return ptrcall!(bool)(GDNativeClassBinding.isProximityFadeEnabled, _godot_object); 1134 } 1135 /** 1136 1137 */ 1138 void setAlbedo(in Color albedo) 1139 { 1140 checkClassBinding!(typeof(this))(); 1141 ptrcall!(void)(GDNativeClassBinding.setAlbedo, _godot_object, albedo); 1142 } 1143 /** 1144 1145 */ 1146 void setAlphaScissorThreshold(in double threshold) 1147 { 1148 checkClassBinding!(typeof(this))(); 1149 ptrcall!(void)(GDNativeClassBinding.setAlphaScissorThreshold, _godot_object, threshold); 1150 } 1151 /** 1152 1153 */ 1154 void setAnisotropy(in double anisotropy) 1155 { 1156 checkClassBinding!(typeof(this))(); 1157 ptrcall!(void)(GDNativeClassBinding.setAnisotropy, _godot_object, anisotropy); 1158 } 1159 /** 1160 1161 */ 1162 void setAoLightAffect(in double amount) 1163 { 1164 checkClassBinding!(typeof(this))(); 1165 ptrcall!(void)(GDNativeClassBinding.setAoLightAffect, _godot_object, amount); 1166 } 1167 /** 1168 1169 */ 1170 void setAoTextureChannel(in long channel) 1171 { 1172 checkClassBinding!(typeof(this))(); 1173 ptrcall!(void)(GDNativeClassBinding.setAoTextureChannel, _godot_object, channel); 1174 } 1175 /** 1176 1177 */ 1178 void setBillboardMode(in long mode) 1179 { 1180 checkClassBinding!(typeof(this))(); 1181 ptrcall!(void)(GDNativeClassBinding.setBillboardMode, _godot_object, mode); 1182 } 1183 /** 1184 1185 */ 1186 void setBlendMode(in long blend_mode) 1187 { 1188 checkClassBinding!(typeof(this))(); 1189 ptrcall!(void)(GDNativeClassBinding.setBlendMode, _godot_object, blend_mode); 1190 } 1191 /** 1192 1193 */ 1194 void setClearcoat(in double clearcoat) 1195 { 1196 checkClassBinding!(typeof(this))(); 1197 ptrcall!(void)(GDNativeClassBinding.setClearcoat, _godot_object, clearcoat); 1198 } 1199 /** 1200 1201 */ 1202 void setClearcoatGloss(in double clearcoat_gloss) 1203 { 1204 checkClassBinding!(typeof(this))(); 1205 ptrcall!(void)(GDNativeClassBinding.setClearcoatGloss, _godot_object, clearcoat_gloss); 1206 } 1207 /** 1208 1209 */ 1210 void setCullMode(in long cull_mode) 1211 { 1212 checkClassBinding!(typeof(this))(); 1213 ptrcall!(void)(GDNativeClassBinding.setCullMode, _godot_object, cull_mode); 1214 } 1215 /** 1216 1217 */ 1218 void setDepthDeepParallax(in bool enable) 1219 { 1220 checkClassBinding!(typeof(this))(); 1221 ptrcall!(void)(GDNativeClassBinding.setDepthDeepParallax, _godot_object, enable); 1222 } 1223 /** 1224 1225 */ 1226 void setDepthDeepParallaxFlipBinormal(in bool flip) 1227 { 1228 checkClassBinding!(typeof(this))(); 1229 ptrcall!(void)(GDNativeClassBinding.setDepthDeepParallaxFlipBinormal, _godot_object, flip); 1230 } 1231 /** 1232 1233 */ 1234 void setDepthDeepParallaxFlipTangent(in bool flip) 1235 { 1236 checkClassBinding!(typeof(this))(); 1237 ptrcall!(void)(GDNativeClassBinding.setDepthDeepParallaxFlipTangent, _godot_object, flip); 1238 } 1239 /** 1240 1241 */ 1242 void setDepthDeepParallaxMaxLayers(in long layer) 1243 { 1244 checkClassBinding!(typeof(this))(); 1245 ptrcall!(void)(GDNativeClassBinding.setDepthDeepParallaxMaxLayers, _godot_object, layer); 1246 } 1247 /** 1248 1249 */ 1250 void setDepthDeepParallaxMinLayers(in long layer) 1251 { 1252 checkClassBinding!(typeof(this))(); 1253 ptrcall!(void)(GDNativeClassBinding.setDepthDeepParallaxMinLayers, _godot_object, layer); 1254 } 1255 /** 1256 1257 */ 1258 void setDepthDrawMode(in long depth_draw_mode) 1259 { 1260 checkClassBinding!(typeof(this))(); 1261 ptrcall!(void)(GDNativeClassBinding.setDepthDrawMode, _godot_object, depth_draw_mode); 1262 } 1263 /** 1264 1265 */ 1266 void setDepthScale(in double depth_scale) 1267 { 1268 checkClassBinding!(typeof(this))(); 1269 ptrcall!(void)(GDNativeClassBinding.setDepthScale, _godot_object, depth_scale); 1270 } 1271 /** 1272 1273 */ 1274 void setDetailBlendMode(in long detail_blend_mode) 1275 { 1276 checkClassBinding!(typeof(this))(); 1277 ptrcall!(void)(GDNativeClassBinding.setDetailBlendMode, _godot_object, detail_blend_mode); 1278 } 1279 /** 1280 1281 */ 1282 void setDetailUv(in long detail_uv) 1283 { 1284 checkClassBinding!(typeof(this))(); 1285 ptrcall!(void)(GDNativeClassBinding.setDetailUv, _godot_object, detail_uv); 1286 } 1287 /** 1288 1289 */ 1290 void setDiffuseMode(in long diffuse_mode) 1291 { 1292 checkClassBinding!(typeof(this))(); 1293 ptrcall!(void)(GDNativeClassBinding.setDiffuseMode, _godot_object, diffuse_mode); 1294 } 1295 /** 1296 1297 */ 1298 void setDistanceFade(in long mode) 1299 { 1300 checkClassBinding!(typeof(this))(); 1301 ptrcall!(void)(GDNativeClassBinding.setDistanceFade, _godot_object, mode); 1302 } 1303 /** 1304 1305 */ 1306 void setDistanceFadeMaxDistance(in double distance) 1307 { 1308 checkClassBinding!(typeof(this))(); 1309 ptrcall!(void)(GDNativeClassBinding.setDistanceFadeMaxDistance, _godot_object, distance); 1310 } 1311 /** 1312 1313 */ 1314 void setDistanceFadeMinDistance(in double distance) 1315 { 1316 checkClassBinding!(typeof(this))(); 1317 ptrcall!(void)(GDNativeClassBinding.setDistanceFadeMinDistance, _godot_object, distance); 1318 } 1319 /** 1320 1321 */ 1322 void setEmission(in Color emission) 1323 { 1324 checkClassBinding!(typeof(this))(); 1325 ptrcall!(void)(GDNativeClassBinding.setEmission, _godot_object, emission); 1326 } 1327 /** 1328 1329 */ 1330 void setEmissionEnergy(in double emission_energy) 1331 { 1332 checkClassBinding!(typeof(this))(); 1333 ptrcall!(void)(GDNativeClassBinding.setEmissionEnergy, _godot_object, emission_energy); 1334 } 1335 /** 1336 1337 */ 1338 void setEmissionOperator(in long operator) 1339 { 1340 checkClassBinding!(typeof(this))(); 1341 ptrcall!(void)(GDNativeClassBinding.setEmissionOperator, _godot_object, operator); 1342 } 1343 /** 1344 If `true`, enables the specified $(D feature). Many features that are available in $(D SpatialMaterial)s need to be enabled before use. This way the cost for using the feature is only incurred when specified. Features can also be enabled by setting the corresponding member to `true`. 1345 */ 1346 void setFeature(in long feature, in bool enable) 1347 { 1348 checkClassBinding!(typeof(this))(); 1349 ptrcall!(void)(GDNativeClassBinding.setFeature, _godot_object, feature, enable); 1350 } 1351 /** 1352 If `true`, enables the specified flag. Flags are optional behaviour that can be turned on and off. Only one flag can be enabled at a time with this function, the flag enumerators cannot be bit-masked together to enable or disable multiple flags at once. Flags can also be enabled by setting the corresponding member to `true`. See $(D flags) enumerator for options. 1353 */ 1354 void setFlag(in long flag, in bool enable) 1355 { 1356 checkClassBinding!(typeof(this))(); 1357 ptrcall!(void)(GDNativeClassBinding.setFlag, _godot_object, flag, enable); 1358 } 1359 /** 1360 1361 */ 1362 void setGrow(in double amount) 1363 { 1364 checkClassBinding!(typeof(this))(); 1365 ptrcall!(void)(GDNativeClassBinding.setGrow, _godot_object, amount); 1366 } 1367 /** 1368 1369 */ 1370 void setGrowEnabled(in bool enable) 1371 { 1372 checkClassBinding!(typeof(this))(); 1373 ptrcall!(void)(GDNativeClassBinding.setGrowEnabled, _godot_object, enable); 1374 } 1375 /** 1376 1377 */ 1378 void setLineWidth(in double line_width) 1379 { 1380 checkClassBinding!(typeof(this))(); 1381 ptrcall!(void)(GDNativeClassBinding.setLineWidth, _godot_object, line_width); 1382 } 1383 /** 1384 1385 */ 1386 void setMetallic(in double metallic) 1387 { 1388 checkClassBinding!(typeof(this))(); 1389 ptrcall!(void)(GDNativeClassBinding.setMetallic, _godot_object, metallic); 1390 } 1391 /** 1392 1393 */ 1394 void setMetallicTextureChannel(in long channel) 1395 { 1396 checkClassBinding!(typeof(this))(); 1397 ptrcall!(void)(GDNativeClassBinding.setMetallicTextureChannel, _godot_object, channel); 1398 } 1399 /** 1400 1401 */ 1402 void setNormalScale(in double normal_scale) 1403 { 1404 checkClassBinding!(typeof(this))(); 1405 ptrcall!(void)(GDNativeClassBinding.setNormalScale, _godot_object, normal_scale); 1406 } 1407 /** 1408 1409 */ 1410 void setParticlesAnimHFrames(in long frames) 1411 { 1412 checkClassBinding!(typeof(this))(); 1413 ptrcall!(void)(GDNativeClassBinding.setParticlesAnimHFrames, _godot_object, frames); 1414 } 1415 /** 1416 1417 */ 1418 void setParticlesAnimLoop(in bool loop) 1419 { 1420 checkClassBinding!(typeof(this))(); 1421 ptrcall!(void)(GDNativeClassBinding.setParticlesAnimLoop, _godot_object, loop); 1422 } 1423 /** 1424 1425 */ 1426 void setParticlesAnimVFrames(in long frames) 1427 { 1428 checkClassBinding!(typeof(this))(); 1429 ptrcall!(void)(GDNativeClassBinding.setParticlesAnimVFrames, _godot_object, frames); 1430 } 1431 /** 1432 1433 */ 1434 void setPointSize(in double point_size) 1435 { 1436 checkClassBinding!(typeof(this))(); 1437 ptrcall!(void)(GDNativeClassBinding.setPointSize, _godot_object, point_size); 1438 } 1439 /** 1440 1441 */ 1442 void setProximityFade(in bool enabled) 1443 { 1444 checkClassBinding!(typeof(this))(); 1445 ptrcall!(void)(GDNativeClassBinding.setProximityFade, _godot_object, enabled); 1446 } 1447 /** 1448 1449 */ 1450 void setProximityFadeDistance(in double distance) 1451 { 1452 checkClassBinding!(typeof(this))(); 1453 ptrcall!(void)(GDNativeClassBinding.setProximityFadeDistance, _godot_object, distance); 1454 } 1455 /** 1456 1457 */ 1458 void setRefraction(in double refraction) 1459 { 1460 checkClassBinding!(typeof(this))(); 1461 ptrcall!(void)(GDNativeClassBinding.setRefraction, _godot_object, refraction); 1462 } 1463 /** 1464 1465 */ 1466 void setRefractionTextureChannel(in long channel) 1467 { 1468 checkClassBinding!(typeof(this))(); 1469 ptrcall!(void)(GDNativeClassBinding.setRefractionTextureChannel, _godot_object, channel); 1470 } 1471 /** 1472 1473 */ 1474 void setRim(in double rim) 1475 { 1476 checkClassBinding!(typeof(this))(); 1477 ptrcall!(void)(GDNativeClassBinding.setRim, _godot_object, rim); 1478 } 1479 /** 1480 1481 */ 1482 void setRimTint(in double rim_tint) 1483 { 1484 checkClassBinding!(typeof(this))(); 1485 ptrcall!(void)(GDNativeClassBinding.setRimTint, _godot_object, rim_tint); 1486 } 1487 /** 1488 1489 */ 1490 void setRoughness(in double roughness) 1491 { 1492 checkClassBinding!(typeof(this))(); 1493 ptrcall!(void)(GDNativeClassBinding.setRoughness, _godot_object, roughness); 1494 } 1495 /** 1496 1497 */ 1498 void setRoughnessTextureChannel(in long channel) 1499 { 1500 checkClassBinding!(typeof(this))(); 1501 ptrcall!(void)(GDNativeClassBinding.setRoughnessTextureChannel, _godot_object, channel); 1502 } 1503 /** 1504 1505 */ 1506 void setSpecular(in double specular) 1507 { 1508 checkClassBinding!(typeof(this))(); 1509 ptrcall!(void)(GDNativeClassBinding.setSpecular, _godot_object, specular); 1510 } 1511 /** 1512 1513 */ 1514 void setSpecularMode(in long specular_mode) 1515 { 1516 checkClassBinding!(typeof(this))(); 1517 ptrcall!(void)(GDNativeClassBinding.setSpecularMode, _godot_object, specular_mode); 1518 } 1519 /** 1520 1521 */ 1522 void setSubsurfaceScatteringStrength(in double strength) 1523 { 1524 checkClassBinding!(typeof(this))(); 1525 ptrcall!(void)(GDNativeClassBinding.setSubsurfaceScatteringStrength, _godot_object, strength); 1526 } 1527 /** 1528 Sets the $(D Texture) to be used by the specified $(D textureparam). This function is called when setting members ending in `*_texture`. 1529 */ 1530 void setTexture(in long param, Texture texture) 1531 { 1532 checkClassBinding!(typeof(this))(); 1533 ptrcall!(void)(GDNativeClassBinding.setTexture, _godot_object, param, texture); 1534 } 1535 /** 1536 1537 */ 1538 void setTransmission(in Color transmission) 1539 { 1540 checkClassBinding!(typeof(this))(); 1541 ptrcall!(void)(GDNativeClassBinding.setTransmission, _godot_object, transmission); 1542 } 1543 /** 1544 1545 */ 1546 void setUv1Offset(in Vector3 offset) 1547 { 1548 checkClassBinding!(typeof(this))(); 1549 ptrcall!(void)(GDNativeClassBinding.setUv1Offset, _godot_object, offset); 1550 } 1551 /** 1552 1553 */ 1554 void setUv1Scale(in Vector3 scale) 1555 { 1556 checkClassBinding!(typeof(this))(); 1557 ptrcall!(void)(GDNativeClassBinding.setUv1Scale, _godot_object, scale); 1558 } 1559 /** 1560 1561 */ 1562 void setUv1TriplanarBlendSharpness(in double sharpness) 1563 { 1564 checkClassBinding!(typeof(this))(); 1565 ptrcall!(void)(GDNativeClassBinding.setUv1TriplanarBlendSharpness, _godot_object, sharpness); 1566 } 1567 /** 1568 1569 */ 1570 void setUv2Offset(in Vector3 offset) 1571 { 1572 checkClassBinding!(typeof(this))(); 1573 ptrcall!(void)(GDNativeClassBinding.setUv2Offset, _godot_object, offset); 1574 } 1575 /** 1576 1577 */ 1578 void setUv2Scale(in Vector3 scale) 1579 { 1580 checkClassBinding!(typeof(this))(); 1581 ptrcall!(void)(GDNativeClassBinding.setUv2Scale, _godot_object, scale); 1582 } 1583 /** 1584 1585 */ 1586 void setUv2TriplanarBlendSharpness(in double sharpness) 1587 { 1588 checkClassBinding!(typeof(this))(); 1589 ptrcall!(void)(GDNativeClassBinding.setUv2TriplanarBlendSharpness, _godot_object, sharpness); 1590 } 1591 /** 1592 The material's base color. 1593 */ 1594 @property Color albedoColor() 1595 { 1596 return getAlbedo(); 1597 } 1598 /// ditto 1599 @property void albedoColor(Color v) 1600 { 1601 setAlbedo(v); 1602 } 1603 /** 1604 Texture to multiply by $(D albedoColor). Used for basic texturing of objects. 1605 */ 1606 @property Texture albedoTexture() 1607 { 1608 return getTexture(0); 1609 } 1610 /// ditto 1611 @property void albedoTexture(Texture v) 1612 { 1613 setTexture(0, v); 1614 } 1615 /** 1616 The strength of the anisotropy effect. 1617 */ 1618 @property double anisotropy() 1619 { 1620 return getAnisotropy(); 1621 } 1622 /// ditto 1623 @property void anisotropy(double v) 1624 { 1625 setAnisotropy(v); 1626 } 1627 /** 1628 If `true`, anisotropy is enabled. Changes the shape of the specular blob and aligns it to tangent space. Mesh tangents are needed for this to work. If the mesh does not contain tangents the anisotropy effect will appear broken. 1629 */ 1630 @property bool anisotropyEnabled() 1631 { 1632 return getFeature(5); 1633 } 1634 /// ditto 1635 @property void anisotropyEnabled(bool v) 1636 { 1637 setFeature(5, v); 1638 } 1639 /** 1640 Texture that offsets the tangent map for anisotropy calculations. 1641 */ 1642 @property Texture anisotropyFlowmap() 1643 { 1644 return getTexture(7); 1645 } 1646 /// ditto 1647 @property void anisotropyFlowmap(Texture v) 1648 { 1649 setTexture(7, v); 1650 } 1651 /** 1652 If `true`, ambient occlusion is enabled. Ambient occlusion darkens areas based on the $(D aoTexture). 1653 */ 1654 @property bool aoEnabled() 1655 { 1656 return getFeature(6); 1657 } 1658 /// ditto 1659 @property void aoEnabled(bool v) 1660 { 1661 setFeature(6, v); 1662 } 1663 /** 1664 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. 1665 */ 1666 @property double aoLightAffect() 1667 { 1668 return getAoLightAffect(); 1669 } 1670 /// ditto 1671 @property void aoLightAffect(double v) 1672 { 1673 setAoLightAffect(v); 1674 } 1675 /** 1676 If `true`, use `UV2` coordinates to look up from the $(D aoTexture). 1677 */ 1678 @property bool aoOnUv2() 1679 { 1680 return getFlag(11); 1681 } 1682 /// ditto 1683 @property void aoOnUv2(bool v) 1684 { 1685 setFlag(11, v); 1686 } 1687 /** 1688 Texture that defines the amount of ambient occlusion for a given point on the object. 1689 */ 1690 @property Texture aoTexture() 1691 { 1692 return getTexture(8); 1693 } 1694 /// ditto 1695 @property void aoTexture(Texture v) 1696 { 1697 setTexture(8, v); 1698 } 1699 /** 1700 Specifies the channel of the $(D 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. 1701 */ 1702 @property SpatialMaterial.TextureChannel aoTextureChannel() 1703 { 1704 return getAoTextureChannel(); 1705 } 1706 /// ditto 1707 @property void aoTextureChannel(long v) 1708 { 1709 setAoTextureChannel(v); 1710 } 1711 /** 1712 Sets the strength of the clearcoat effect. Setting to `0` looks the same as disabling the clearcoat effect. 1713 */ 1714 @property double clearcoat() 1715 { 1716 return getClearcoat(); 1717 } 1718 /// ditto 1719 @property void clearcoat(double v) 1720 { 1721 setClearcoat(v); 1722 } 1723 /** 1724 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. 1725 $(B Note:) Clearcoat rendering is not visible if the material has $(D flagsUnshaded) set to `true`. 1726 */ 1727 @property bool clearcoatEnabled() 1728 { 1729 return getFeature(4); 1730 } 1731 /// ditto 1732 @property void clearcoatEnabled(bool v) 1733 { 1734 setFeature(4, v); 1735 } 1736 /** 1737 Sets the roughness of the clearcoat pass. A higher value results in a smoother clearcoat while a lower value results in a rougher clearcoat. 1738 */ 1739 @property double clearcoatGloss() 1740 { 1741 return getClearcoatGloss(); 1742 } 1743 /// ditto 1744 @property void clearcoatGloss(double v) 1745 { 1746 setClearcoatGloss(v); 1747 } 1748 /** 1749 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. 1750 */ 1751 @property Texture clearcoatTexture() 1752 { 1753 return getTexture(6); 1754 } 1755 /// ditto 1756 @property void clearcoatTexture(Texture v) 1757 { 1758 setTexture(6, v); 1759 } 1760 /** 1761 If `true`, the shader will read depth texture at multiple points along the view ray to determine occlusion and parrallax. This can be very performance demanding, but results in more realistic looking depth mapping. 1762 */ 1763 @property bool depthDeepParallax() 1764 { 1765 return isDepthDeepParallaxEnabled(); 1766 } 1767 /// ditto 1768 @property void depthDeepParallax(bool v) 1769 { 1770 setDepthDeepParallax(v); 1771 } 1772 /** 1773 If `true`, depth mapping is enabled (also called "parallax mapping" or "height mapping"). See also $(D normalEnabled). 1774 $(B Note:) Depth mapping is not supported if triplanar mapping is used on the same material. The value of $(D depthEnabled) will be ignored if $(D uv1Triplanar) is enabled. 1775 */ 1776 @property bool depthEnabled() 1777 { 1778 return getFeature(7); 1779 } 1780 /// ditto 1781 @property void depthEnabled(bool v) 1782 { 1783 setFeature(7, v); 1784 } 1785 /** 1786 If `true`, direction of the binormal is flipped before using in the depth effect. This may be necessary if you have encoded your binormals in a way that is conflicting with the depth effect. 1787 */ 1788 @property bool depthFlipBinormal() 1789 { 1790 return getDepthDeepParallaxFlipBinormal(); 1791 } 1792 /// ditto 1793 @property void depthFlipBinormal(bool v) 1794 { 1795 setDepthDeepParallaxFlipBinormal(v); 1796 } 1797 /** 1798 If `true`, direction of the tangent is flipped before using in the depth effect. This may be necessary if you have encoded your tangents in a way that is conflicting with the depth effect. 1799 */ 1800 @property bool depthFlipTangent() 1801 { 1802 return getDepthDeepParallaxFlipTangent(); 1803 } 1804 /// ditto 1805 @property void depthFlipTangent(bool v) 1806 { 1807 setDepthDeepParallaxFlipTangent(v); 1808 } 1809 /** 1810 Number of layers to use when using $(D depthDeepParallax) and the view direction is perpendicular to the surface of the object. A higher number will be more performance demanding while a lower number may not look as crisp. 1811 */ 1812 @property long depthMaxLayers() 1813 { 1814 return getDepthDeepParallaxMaxLayers(); 1815 } 1816 /// ditto 1817 @property void depthMaxLayers(long v) 1818 { 1819 setDepthDeepParallaxMaxLayers(v); 1820 } 1821 /** 1822 Number of layers to use when using $(D depthDeepParallax) and the view direction is parallel to the surface of the object. A higher number will be more performance demanding while a lower number may not look as crisp. 1823 */ 1824 @property long depthMinLayers() 1825 { 1826 return getDepthDeepParallaxMinLayers(); 1827 } 1828 /// ditto 1829 @property void depthMinLayers(long v) 1830 { 1831 setDepthDeepParallaxMinLayers(v); 1832 } 1833 /** 1834 Scales the depth offset effect. A higher number will create a larger depth. 1835 */ 1836 @property double depthScale() 1837 { 1838 return getDepthScale(); 1839 } 1840 /// ditto 1841 @property void depthScale(double v) 1842 { 1843 setDepthScale(v); 1844 } 1845 /** 1846 Texture used to determine depth at a given pixel. Depth is always stored in the red channel. 1847 */ 1848 @property Texture depthTexture() 1849 { 1850 return getTexture(9); 1851 } 1852 /// ditto 1853 @property void depthTexture(Texture v) 1854 { 1855 setTexture(9, v); 1856 } 1857 /** 1858 Texture that specifies the color of the detail overlay. 1859 */ 1860 @property Texture detailAlbedo() 1861 { 1862 return getTexture(14); 1863 } 1864 /// ditto 1865 @property void detailAlbedo(Texture v) 1866 { 1867 setTexture(14, v); 1868 } 1869 /** 1870 Specifies how the $(D detailAlbedo) should blend with the current `ALBEDO`. See $(D blendmode) for options. 1871 */ 1872 @property SpatialMaterial.BlendMode detailBlendMode() 1873 { 1874 return getDetailBlendMode(); 1875 } 1876 /// ditto 1877 @property void detailBlendMode(long v) 1878 { 1879 setDetailBlendMode(v); 1880 } 1881 /** 1882 If `true`, enables the detail overlay. Detail is a second texture that gets mixed over the surface of the object based on $(D detailMask). This can be used to add variation to objects, or to blend between two different albedo/normal textures. 1883 */ 1884 @property bool detailEnabled() 1885 { 1886 return getFeature(11); 1887 } 1888 /// ditto 1889 @property void detailEnabled(bool v) 1890 { 1891 setFeature(11, v); 1892 } 1893 /** 1894 Texture used to specify how the detail textures get blended with the base textures. 1895 */ 1896 @property Texture detailMask() 1897 { 1898 return getTexture(13); 1899 } 1900 /// ditto 1901 @property void detailMask(Texture v) 1902 { 1903 setTexture(13, v); 1904 } 1905 /** 1906 Texture that specifies the per-pixel normal of the detail overlay. 1907 $(B Note:) Godot expects the normal map to use X+, Y-, and Z+ coordinates. See $(D url=http://wiki.polycount.com/wiki/Normal_Map_Technical_Details#Common_Swizzle_Coordinates)this page$(D /url) for a comparison of normal map coordinates expected by popular engines. 1908 */ 1909 @property Texture detailNormal() 1910 { 1911 return getTexture(15); 1912 } 1913 /// ditto 1914 @property void detailNormal(Texture v) 1915 { 1916 setTexture(15, v); 1917 } 1918 /** 1919 Specifies whether to use `UV` or `UV2` for the detail layer. See $(D detailuv) for options. 1920 */ 1921 @property SpatialMaterial.DetailUV detailUvLayer() 1922 { 1923 return getDetailUv(); 1924 } 1925 /// ditto 1926 @property void detailUvLayer(long v) 1927 { 1928 setDetailUv(v); 1929 } 1930 /** 1931 Distance at which the object appears fully opaque. 1932 $(B Note:) If `distance_fade_max_distance` is less than `distance_fade_min_distance`, the behavior will be reversed. The object will start to fade away at `distance_fade_max_distance` and will fully disappear once it reaches `distance_fade_min_distance`. 1933 */ 1934 @property double distanceFadeMaxDistance() 1935 { 1936 return getDistanceFadeMaxDistance(); 1937 } 1938 /// ditto 1939 @property void distanceFadeMaxDistance(double v) 1940 { 1941 setDistanceFadeMaxDistance(v); 1942 } 1943 /** 1944 Distance at which the object starts to become visible. If the object is less than this distance away, it will be invisible. 1945 $(B Note:) If `distance_fade_min_distance` is greater than `distance_fade_max_distance`, the behavior will be reversed. The object will start to fade away at `distance_fade_max_distance` and will fully disappear once it reaches `distance_fade_min_distance`. 1946 */ 1947 @property double distanceFadeMinDistance() 1948 { 1949 return getDistanceFadeMinDistance(); 1950 } 1951 /// ditto 1952 @property void distanceFadeMinDistance(double v) 1953 { 1954 setDistanceFadeMinDistance(v); 1955 } 1956 /** 1957 Specifies which type of fade to use. Can be any of the $(D distancefademode)s. 1958 */ 1959 @property SpatialMaterial.DistanceFadeMode distanceFadeMode() 1960 { 1961 return getDistanceFade(); 1962 } 1963 /// ditto 1964 @property void distanceFadeMode(long v) 1965 { 1966 setDistanceFade(v); 1967 } 1968 /** 1969 The emitted light's color. See $(D emissionEnabled). 1970 */ 1971 @property Color emission() 1972 { 1973 return getEmission(); 1974 } 1975 /// ditto 1976 @property void emission(Color v) 1977 { 1978 setEmission(v); 1979 } 1980 /** 1981 If `true`, the body emits light. Emitting light makes the object appear brighter. The object can also cast light on other objects if a $(D GIProbe) or $(D BakedLightmap) is used and this object is used in baked lighting. 1982 */ 1983 @property bool emissionEnabled() 1984 { 1985 return getFeature(1); 1986 } 1987 /// ditto 1988 @property void emissionEnabled(bool v) 1989 { 1990 setFeature(1, v); 1991 } 1992 /** 1993 The emitted light's strength. See $(D emissionEnabled). 1994 */ 1995 @property double emissionEnergy() 1996 { 1997 return getEmissionEnergy(); 1998 } 1999 /// ditto 2000 @property void emissionEnergy(double v) 2001 { 2002 setEmissionEnergy(v); 2003 } 2004 /** 2005 Use `UV2` to read from the $(D emissionTexture). 2006 */ 2007 @property bool emissionOnUv2() 2008 { 2009 return getFlag(12); 2010 } 2011 /// ditto 2012 @property void emissionOnUv2(bool v) 2013 { 2014 setFlag(12, v); 2015 } 2016 /** 2017 Sets how $(D emission) interacts with $(D emissionTexture). Can either add or multiply. See $(D emissionoperator) for options. 2018 */ 2019 @property SpatialMaterial.EmissionOperator emissionOperator() 2020 { 2021 return getEmissionOperator(); 2022 } 2023 /// ditto 2024 @property void emissionOperator(long v) 2025 { 2026 setEmissionOperator(v); 2027 } 2028 /** 2029 Texture that specifies how much surface emits light at a given point. 2030 */ 2031 @property Texture emissionTexture() 2032 { 2033 return getTexture(3); 2034 } 2035 /// ditto 2036 @property void emissionTexture(Texture v) 2037 { 2038 setTexture(3, v); 2039 } 2040 /** 2041 Forces a conversion of the $(D albedoTexture) from sRGB space to linear space. 2042 */ 2043 @property bool flagsAlbedoTexForceSrgb() 2044 { 2045 return getFlag(14); 2046 } 2047 /// ditto 2048 @property void flagsAlbedoTexForceSrgb(bool v) 2049 { 2050 setFlag(14, v); 2051 } 2052 /** 2053 If `true`, the object receives no ambient light. 2054 */ 2055 @property bool flagsDisableAmbientLight() 2056 { 2057 return getFlag(17); 2058 } 2059 /// ditto 2060 @property void flagsDisableAmbientLight(bool v) 2061 { 2062 setFlag(17, v); 2063 } 2064 /** 2065 If `true`, the object receives no shadow that would otherwise be cast onto it. 2066 */ 2067 @property bool flagsDoNotReceiveShadows() 2068 { 2069 return getFlag(15); 2070 } 2071 /// ditto 2072 @property void flagsDoNotReceiveShadows(bool v) 2073 { 2074 setFlag(15, v); 2075 } 2076 /** 2077 If `true`, the shader will compute extra operations to make sure the normal stays correct when using a non-uniform scale. Only enable if using non-uniform scaling. 2078 */ 2079 @property bool flagsEnsureCorrectNormals() 2080 { 2081 return getFlag(16); 2082 } 2083 /// ditto 2084 @property void flagsEnsureCorrectNormals(bool v) 2085 { 2086 setFlag(16, v); 2087 } 2088 /** 2089 If `true`, the object is rendered at the same size regardless of distance. 2090 */ 2091 @property bool flagsFixedSize() 2092 { 2093 return getFlag(6); 2094 } 2095 /// ditto 2096 @property void flagsFixedSize(bool v) 2097 { 2098 setFlag(6, v); 2099 } 2100 /** 2101 If `true`, depth testing is disabled and the object will be drawn in render order. 2102 */ 2103 @property bool flagsNoDepthTest() 2104 { 2105 return getFlag(2); 2106 } 2107 /// ditto 2108 @property void flagsNoDepthTest(bool v) 2109 { 2110 setFlag(2, v); 2111 } 2112 /** 2113 If `true`, transparency is enabled on the body. See also $(D paramsBlendMode). 2114 */ 2115 @property bool flagsTransparent() 2116 { 2117 return getFeature(0); 2118 } 2119 /// ditto 2120 @property void flagsTransparent(bool v) 2121 { 2122 setFeature(0, v); 2123 } 2124 /** 2125 If `true`, the object is unaffected by lighting. 2126 */ 2127 @property bool flagsUnshaded() 2128 { 2129 return getFlag(0); 2130 } 2131 /// ditto 2132 @property void flagsUnshaded(bool v) 2133 { 2134 setFlag(0, v); 2135 } 2136 /** 2137 If `true`, render point size can be changed. 2138 $(B Note:) this is only effective for objects whose geometry is point-based rather than triangle-based. See also $(D paramsPointSize). 2139 */ 2140 @property bool flagsUsePointSize() 2141 { 2142 return getFlag(5); 2143 } 2144 /// ditto 2145 @property void flagsUsePointSize(bool v) 2146 { 2147 setFlag(5, v); 2148 } 2149 /** 2150 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. 2151 */ 2152 @property bool flagsUseShadowToOpacity() 2153 { 2154 return getFlag(18); 2155 } 2156 /// ditto 2157 @property void flagsUseShadowToOpacity(bool v) 2158 { 2159 setFlag(18, v); 2160 } 2161 /** 2162 If `true`, lighting is calculated per vertex rather than per pixel. This may increase performance on low-end devices. 2163 */ 2164 @property bool flagsVertexLighting() 2165 { 2166 return getFlag(1); 2167 } 2168 /// ditto 2169 @property void flagsVertexLighting(bool v) 2170 { 2171 setFlag(1, v); 2172 } 2173 /** 2174 If `true`, triplanar mapping is calculated in world space rather than object local space. See also $(D uv1Triplanar). 2175 */ 2176 @property bool flagsWorldTriplanar() 2177 { 2178 return getFlag(10); 2179 } 2180 /// ditto 2181 @property void flagsWorldTriplanar(bool v) 2182 { 2183 setFlag(10, v); 2184 } 2185 /** 2186 A high value makes the material appear more like a metal. Non-metals use their albedo as the diffuse color and add diffuse to the specular reflection. With non-metals, the reflection appears on top of the albedo color. Metals use their albedo as a multiplier to the specular reflection and set the diffuse color to black resulting in a tinted reflection. Materials work better when fully metal or fully non-metal, values between `0` and `1` should only be used for blending between metal and non-metal sections. To alter the amount of reflection use $(D roughness). 2187 */ 2188 @property double metallic() 2189 { 2190 return getMetallic(); 2191 } 2192 /// ditto 2193 @property void metallic(double v) 2194 { 2195 setMetallic(v); 2196 } 2197 /** 2198 Sets the size of the specular lobe. The specular lobe is the bright spot that is reflected from light sources. 2199 $(B Note:) unlike $(D metallic), this is not energy-conserving, so it should be left at `0.5` in most cases. See also $(D roughness). 2200 */ 2201 @property double metallicSpecular() 2202 { 2203 return getSpecular(); 2204 } 2205 /// ditto 2206 @property void metallicSpecular(double v) 2207 { 2208 setSpecular(v); 2209 } 2210 /** 2211 Texture used to specify metallic for an object. This is multiplied by $(D metallic). 2212 */ 2213 @property Texture metallicTexture() 2214 { 2215 return getTexture(1); 2216 } 2217 /// ditto 2218 @property void metallicTexture(Texture v) 2219 { 2220 setTexture(1, v); 2221 } 2222 /** 2223 Specifies the channel of the $(D 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. 2224 */ 2225 @property SpatialMaterial.TextureChannel metallicTextureChannel() 2226 { 2227 return getMetallicTextureChannel(); 2228 } 2229 /// ditto 2230 @property void metallicTextureChannel(long v) 2231 { 2232 setMetallicTextureChannel(v); 2233 } 2234 /** 2235 If `true`, normal mapping is enabled. 2236 */ 2237 @property bool normalEnabled() 2238 { 2239 return getFeature(2); 2240 } 2241 /// ditto 2242 @property void normalEnabled(bool v) 2243 { 2244 setFeature(2, v); 2245 } 2246 /** 2247 The strength of the normal map's effect. 2248 */ 2249 @property double normalScale() 2250 { 2251 return getNormalScale(); 2252 } 2253 /// ditto 2254 @property void normalScale(double v) 2255 { 2256 setNormalScale(v); 2257 } 2258 /** 2259 Texture used to specify the normal at a given pixel. The `normal_texture` only uses the red and green channels. The normal read from `normal_texture` is oriented around the surface normal provided by the $(D Mesh). 2260 $(B Note:) Godot expects the normal map to use X+, Y-, and Z+ coordinates. See $(D url=http://wiki.polycount.com/wiki/Normal_Map_Technical_Details#Common_Swizzle_Coordinates)this page$(D /url) for a comparison of normal map coordinates expected by popular engines. 2261 */ 2262 @property Texture normalTexture() 2263 { 2264 return getTexture(4); 2265 } 2266 /// ditto 2267 @property void normalTexture(Texture v) 2268 { 2269 setTexture(4, v); 2270 } 2271 /** 2272 Threshold at which the alpha scissor will discard values. 2273 */ 2274 @property double paramsAlphaScissorThreshold() 2275 { 2276 return getAlphaScissorThreshold(); 2277 } 2278 /// ditto 2279 @property void paramsAlphaScissorThreshold(double v) 2280 { 2281 setAlphaScissorThreshold(v); 2282 } 2283 /** 2284 If `true`, the shader will keep the scale set for the mesh. Otherwise the scale is lost when billboarding. Only applies when $(D paramsBillboardMode) is $(D constant BILLBOARD_ENABLED). 2285 */ 2286 @property bool paramsBillboardKeepScale() 2287 { 2288 return getFlag(7); 2289 } 2290 /// ditto 2291 @property void paramsBillboardKeepScale(bool v) 2292 { 2293 setFlag(7, v); 2294 } 2295 /** 2296 Controls how the object faces the camera. See $(D billboardmode). 2297 $(B Note:) Billboard mode is not suitable for VR because the left-right vector of the camera is not horizontal when the screen is attached to your head instead of on the table. See $(D url=https://github.com/godotengine/godot/issues/41567)GitHub issue #41567$(D /url) for details. 2298 */ 2299 @property SpatialMaterial.BillboardMode paramsBillboardMode() 2300 { 2301 return getBillboardMode(); 2302 } 2303 /// ditto 2304 @property void paramsBillboardMode(long v) 2305 { 2306 setBillboardMode(v); 2307 } 2308 /** 2309 The material's blend mode. 2310 $(B Note:) Values other than `Mix` force the object into the transparent pipeline. See $(D blendmode). 2311 */ 2312 @property SpatialMaterial.BlendMode paramsBlendMode() 2313 { 2314 return getBlendMode(); 2315 } 2316 /// ditto 2317 @property void paramsBlendMode(long v) 2318 { 2319 setBlendMode(v); 2320 } 2321 /** 2322 Which side of the object is not drawn when backfaces are rendered. See $(D cullmode). 2323 */ 2324 @property SpatialMaterial.CullMode paramsCullMode() 2325 { 2326 return getCullMode(); 2327 } 2328 /// ditto 2329 @property void paramsCullMode(long v) 2330 { 2331 setCullMode(v); 2332 } 2333 /** 2334 Determines when depth rendering takes place. See $(D depthdrawmode). See also $(D flagsTransparent). 2335 */ 2336 @property SpatialMaterial.DepthDrawMode paramsDepthDrawMode() 2337 { 2338 return getDepthDrawMode(); 2339 } 2340 /// ditto 2341 @property void paramsDepthDrawMode(long v) 2342 { 2343 setDepthDrawMode(v); 2344 } 2345 /** 2346 The algorithm used for diffuse light scattering. See $(D diffusemode). 2347 */ 2348 @property SpatialMaterial.DiffuseMode paramsDiffuseMode() 2349 { 2350 return getDiffuseMode(); 2351 } 2352 /// ditto 2353 @property void paramsDiffuseMode(long v) 2354 { 2355 setDiffuseMode(v); 2356 } 2357 /** 2358 If `true`, enables the vertex grow setting. See $(D paramsGrowAmount). 2359 */ 2360 @property bool paramsGrow() 2361 { 2362 return isGrowEnabled(); 2363 } 2364 /// ditto 2365 @property void paramsGrow(bool v) 2366 { 2367 setGrowEnabled(v); 2368 } 2369 /** 2370 Grows object vertices in the direction of their normals. 2371 */ 2372 @property double paramsGrowAmount() 2373 { 2374 return getGrow(); 2375 } 2376 /// ditto 2377 @property void paramsGrowAmount(double v) 2378 { 2379 setGrow(v); 2380 } 2381 /** 2382 Currently unimplemented in Godot. 2383 */ 2384 @property double paramsLineWidth() 2385 { 2386 return getLineWidth(); 2387 } 2388 /// ditto 2389 @property void paramsLineWidth(double v) 2390 { 2391 setLineWidth(v); 2392 } 2393 /** 2394 The point size in pixels. See $(D flagsUsePointSize). 2395 */ 2396 @property double paramsPointSize() 2397 { 2398 return getPointSize(); 2399 } 2400 /// ditto 2401 @property void paramsPointSize(double v) 2402 { 2403 setPointSize(v); 2404 } 2405 /** 2406 The method for rendering the specular blob. See $(D specularmode). 2407 */ 2408 @property SpatialMaterial.SpecularMode paramsSpecularMode() 2409 { 2410 return getSpecularMode(); 2411 } 2412 /// ditto 2413 @property void paramsSpecularMode(long v) 2414 { 2415 setSpecularMode(v); 2416 } 2417 /** 2418 If `true`, the shader will discard all pixels that have an alpha value less than $(D paramsAlphaScissorThreshold). 2419 */ 2420 @property bool paramsUseAlphaScissor() 2421 { 2422 return getFlag(13); 2423 } 2424 /// ditto 2425 @property void paramsUseAlphaScissor(bool v) 2426 { 2427 setFlag(13, v); 2428 } 2429 /** 2430 The number of horizontal frames in the particle sprite sheet. Only enabled when using $(D constant BILLBOARD_PARTICLES). See $(D paramsBillboardMode). 2431 */ 2432 @property long particlesAnimHFrames() 2433 { 2434 return getParticlesAnimHFrames(); 2435 } 2436 /// ditto 2437 @property void particlesAnimHFrames(long v) 2438 { 2439 setParticlesAnimHFrames(v); 2440 } 2441 /** 2442 If `true`, particle animations are looped. Only enabled when using $(D constant BILLBOARD_PARTICLES). See $(D paramsBillboardMode). 2443 */ 2444 @property bool particlesAnimLoop() 2445 { 2446 return getParticlesAnimLoop(); 2447 } 2448 /// ditto 2449 @property void particlesAnimLoop(bool v) 2450 { 2451 setParticlesAnimLoop(v); 2452 } 2453 /** 2454 The number of vertical frames in the particle sprite sheet. Only enabled when using $(D constant BILLBOARD_PARTICLES). See $(D paramsBillboardMode). 2455 */ 2456 @property long particlesAnimVFrames() 2457 { 2458 return getParticlesAnimVFrames(); 2459 } 2460 /// ditto 2461 @property void particlesAnimVFrames(long v) 2462 { 2463 setParticlesAnimVFrames(v); 2464 } 2465 /** 2466 Distance over which the fade effect takes place. The larger the distance the longer it takes for an object to fade. 2467 */ 2468 @property double proximityFadeDistance() 2469 { 2470 return getProximityFadeDistance(); 2471 } 2472 /// ditto 2473 @property void proximityFadeDistance(double v) 2474 { 2475 setProximityFadeDistance(v); 2476 } 2477 /** 2478 If `true`, the proximity fade effect is enabled. The proximity fade effect fades out each pixel based on its distance to another object. 2479 */ 2480 @property bool proximityFadeEnable() 2481 { 2482 return isProximityFadeEnabled(); 2483 } 2484 /// ditto 2485 @property void proximityFadeEnable(bool v) 2486 { 2487 setProximityFade(v); 2488 } 2489 /** 2490 If `true`, the refraction effect is enabled. Distorts transparency based on light from behind the object. 2491 */ 2492 @property bool refractionEnabled() 2493 { 2494 return getFeature(10); 2495 } 2496 /// ditto 2497 @property void refractionEnabled(bool v) 2498 { 2499 setFeature(10, v); 2500 } 2501 /** 2502 The strength of the refraction effect. 2503 */ 2504 @property double refractionScale() 2505 { 2506 return getRefraction(); 2507 } 2508 /// ditto 2509 @property void refractionScale(double v) 2510 { 2511 setRefraction(v); 2512 } 2513 /** 2514 Texture that controls the strength of the refraction per-pixel. Multiplied by $(D refractionScale). 2515 */ 2516 @property Texture refractionTexture() 2517 { 2518 return getTexture(12); 2519 } 2520 /// ditto 2521 @property void refractionTexture(Texture v) 2522 { 2523 setTexture(12, v); 2524 } 2525 /** 2526 Specifies the channel of the $(D 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. 2527 */ 2528 @property SpatialMaterial.TextureChannel refractionTextureChannel() 2529 { 2530 return getRefractionTextureChannel(); 2531 } 2532 /// ditto 2533 @property void refractionTextureChannel(long v) 2534 { 2535 setRefractionTextureChannel(v); 2536 } 2537 /** 2538 Sets the strength of the rim lighting effect. 2539 */ 2540 @property double rim() 2541 { 2542 return getRim(); 2543 } 2544 /// ditto 2545 @property void rim(double v) 2546 { 2547 setRim(v); 2548 } 2549 /** 2550 If `true`, rim effect is enabled. Rim lighting increases the brightness at glancing angles on an object. 2551 $(B Note:) Rim lighting is not visible if the material has $(D flagsUnshaded) set to `true`. 2552 */ 2553 @property bool rimEnabled() 2554 { 2555 return getFeature(3); 2556 } 2557 /// ditto 2558 @property void rimEnabled(bool v) 2559 { 2560 setFeature(3, v); 2561 } 2562 /** 2563 Texture used to set the strength of the rim lighting effect per-pixel. Multiplied by $(D rim). 2564 */ 2565 @property Texture rimTexture() 2566 { 2567 return getTexture(5); 2568 } 2569 /// ditto 2570 @property void rimTexture(Texture v) 2571 { 2572 setTexture(5, v); 2573 } 2574 /** 2575 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. 2576 */ 2577 @property double rimTint() 2578 { 2579 return getRimTint(); 2580 } 2581 /// ditto 2582 @property void rimTint(double v) 2583 { 2584 setRimTint(v); 2585 } 2586 /** 2587 Surface reflection. A value of `0` represents a perfect mirror while a value of `1` completely blurs the reflection. See also $(D metallic). 2588 */ 2589 @property double roughness() 2590 { 2591 return getRoughness(); 2592 } 2593 /// ditto 2594 @property void roughness(double v) 2595 { 2596 setRoughness(v); 2597 } 2598 /** 2599 Texture used to control the roughness per-pixel. Multiplied by $(D roughness). 2600 */ 2601 @property Texture roughnessTexture() 2602 { 2603 return getTexture(2); 2604 } 2605 /// ditto 2606 @property void roughnessTexture(Texture v) 2607 { 2608 setTexture(2, v); 2609 } 2610 /** 2611 Specifies the channel of the $(D 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. 2612 */ 2613 @property SpatialMaterial.TextureChannel roughnessTextureChannel() 2614 { 2615 return getRoughnessTextureChannel(); 2616 } 2617 /// ditto 2618 @property void roughnessTextureChannel(long v) 2619 { 2620 setRoughnessTextureChannel(v); 2621 } 2622 /** 2623 If `true`, subsurface scattering is enabled. Emulates light that penetrates an object's surface, is scattered, and then emerges. 2624 */ 2625 @property bool subsurfScatterEnabled() 2626 { 2627 return getFeature(8); 2628 } 2629 /// ditto 2630 @property void subsurfScatterEnabled(bool v) 2631 { 2632 setFeature(8, v); 2633 } 2634 /** 2635 The strength of the subsurface scattering effect. 2636 */ 2637 @property double subsurfScatterStrength() 2638 { 2639 return getSubsurfaceScatteringStrength(); 2640 } 2641 /// ditto 2642 @property void subsurfScatterStrength(double v) 2643 { 2644 setSubsurfaceScatteringStrength(v); 2645 } 2646 /** 2647 Texture used to control the subsurface scattering strength. Stored in the red texture channel. Multiplied by $(D subsurfScatterStrength). 2648 */ 2649 @property Texture subsurfScatterTexture() 2650 { 2651 return getTexture(10); 2652 } 2653 /// ditto 2654 @property void subsurfScatterTexture(Texture v) 2655 { 2656 setTexture(10, v); 2657 } 2658 /** 2659 The color used by the transmission effect. Represents the light passing through an object. 2660 */ 2661 @property Color transmission() 2662 { 2663 return getTransmission(); 2664 } 2665 /// ditto 2666 @property void transmission(Color v) 2667 { 2668 setTransmission(v); 2669 } 2670 /** 2671 If `true`, the transmission effect is enabled. 2672 */ 2673 @property bool transmissionEnabled() 2674 { 2675 return getFeature(9); 2676 } 2677 /// ditto 2678 @property void transmissionEnabled(bool v) 2679 { 2680 setFeature(9, v); 2681 } 2682 /** 2683 Texture used to control the transmission effect per-pixel. Added to $(D transmission). 2684 */ 2685 @property Texture transmissionTexture() 2686 { 2687 return getTexture(11); 2688 } 2689 /// ditto 2690 @property void transmissionTexture(Texture v) 2691 { 2692 setTexture(11, v); 2693 } 2694 /** 2695 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. 2696 */ 2697 @property Vector3 uv1Offset() 2698 { 2699 return getUv1Offset(); 2700 } 2701 /// ditto 2702 @property void uv1Offset(Vector3 v) 2703 { 2704 setUv1Offset(v); 2705 } 2706 /** 2707 How much to scale the `UV` coordinates. This is multiplied by `UV` in the vertex function. 2708 */ 2709 @property Vector3 uv1Scale() 2710 { 2711 return getUv1Scale(); 2712 } 2713 /// ditto 2714 @property void uv1Scale(Vector3 v) 2715 { 2716 setUv1Scale(v); 2717 } 2718 /** 2719 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. 2720 */ 2721 @property bool uv1Triplanar() 2722 { 2723 return getFlag(8); 2724 } 2725 /// ditto 2726 @property void uv1Triplanar(bool v) 2727 { 2728 setFlag(8, v); 2729 } 2730 /** 2731 A lower number blends the texture more softly while a higher number blends the texture more sharply. 2732 */ 2733 @property double uv1TriplanarSharpness() 2734 { 2735 return getUv1TriplanarBlendSharpness(); 2736 } 2737 /// ditto 2738 @property void uv1TriplanarSharpness(double v) 2739 { 2740 setUv1TriplanarBlendSharpness(v); 2741 } 2742 /** 2743 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. 2744 */ 2745 @property Vector3 uv2Offset() 2746 { 2747 return getUv2Offset(); 2748 } 2749 /// ditto 2750 @property void uv2Offset(Vector3 v) 2751 { 2752 setUv2Offset(v); 2753 } 2754 /** 2755 How much to scale the `UV2` coordinates. This is multiplied by `UV2` in the vertex function. 2756 */ 2757 @property Vector3 uv2Scale() 2758 { 2759 return getUv2Scale(); 2760 } 2761 /// ditto 2762 @property void uv2Scale(Vector3 v) 2763 { 2764 setUv2Scale(v); 2765 } 2766 /** 2767 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. 2768 */ 2769 @property bool uv2Triplanar() 2770 { 2771 return getFlag(9); 2772 } 2773 /// ditto 2774 @property void uv2Triplanar(bool v) 2775 { 2776 setFlag(9, v); 2777 } 2778 /** 2779 A lower number blends the texture more softly while a higher number blends the texture more sharply. 2780 */ 2781 @property double uv2TriplanarSharpness() 2782 { 2783 return getUv2TriplanarBlendSharpness(); 2784 } 2785 /// ditto 2786 @property void uv2TriplanarSharpness(double v) 2787 { 2788 setUv2TriplanarBlendSharpness(v); 2789 } 2790 /** 2791 If `true`, the model's vertex colors are processed as sRGB mode. 2792 */ 2793 @property bool vertexColorIsSrgb() 2794 { 2795 return getFlag(4); 2796 } 2797 /// ditto 2798 @property void vertexColorIsSrgb(bool v) 2799 { 2800 setFlag(4, v); 2801 } 2802 /** 2803 If `true`, the vertex color is used as albedo color. 2804 */ 2805 @property bool vertexColorUseAsAlbedo() 2806 { 2807 return getFlag(3); 2808 } 2809 /// ditto 2810 @property void vertexColorUseAsAlbedo(bool v) 2811 { 2812 setFlag(3, v); 2813 } 2814 }