Spatial

type AmbientOcclusion struct {
	Strength    float.X `gd:"AO"`       // Strength of ambient occlusion. For use with pre-baked AO.
	LightEffect float.X `gd:"AO_LIGHT"` // How much ambient occlusion affects direct light (range of [0.0, 1.0], default 0.0).
}

type Fragment struct {
	VertexPosition        vec3.XYZ         `gd:"VERTEX"`                   // Position of the vertex, in model space. In world space if world_vertex_coords is used.
	Position              vec3.XYZ         `gd:"POSITION"`                 // If written to, overrides final vertex position in clip space.
	Normal                vec3.XYZ         `gd:"NORMAL"`                   // Normal in model space. In world space if world_vertex_coords is used.
	Tangent               vec3.XYZ         `gd:"TANGENT"`                  // Tangent in model space. In world space if world_vertex_coords is used.
	Binormal              vec3.XYZ         `gd:"BINORMAL"`                 // Binormal in model space. In world space if world_vertex_coords is used.
	UV                    vec2.XY          `gd:"UV"`                       // UV main channel.
	UV2                   vec2.XY          `gd:"UV2"`                      // UV secondary channel.
	Color                 vec4.RGBA        `gd:"COLOR"`                    // Color from vertices.
	Roughness             float.X          `gd:"ROUGHNESS"`                // Roughness for vertex lighting.
	PointSize             float.X          `gd:"POINT_SIZE"`               // Point size for point rendering.
	ModelViewMatrix       mat4.ColumnMajor `gd:"MODEL_VIEW_MATRIX"`        // Model/local space to view space transform (use if possible).
	ModelViewNormalMatrix mat4.ColumnMajor `gd:"MODEL_VIEW_NORMAL_MATRIX"` //
	ProjectionMatrix      mat4.ColumnMajor `gd:"PROJECTION_MATRIX"`        // View space to clip space transform.
}

type Lighting struct {
	Diffuse  vec3.RGB `gd:"DIFFUSE"`  // Diffuse light result.
	Specular vec3.RGB `gd:"SPECULAR"` // Specular light result.
	Alpha    float.X  `gd:"ALPHA"`    // Alpha (range of [0.0, 1.0]). If written to, the material will go to the transparent pipeline.
}

type Material struct {
	LightVertexPosition    vec3.XYZ `gd:"LIGHT_VERTEX"`             // A writable version of VERTEX that can be used to alter light and shadows. Writing to this will not change the position of the fragment.
	Depth                  float.X  `gd:"DEPTH"`                    // Custom depth value (range of [0.0, 1.0]). If DEPTH is being written to in any shader branch, then you are responsible for setting the DEPTH for all other branches. Otherwise, the graphics API will leave them uninitialized.
	Normal                 vec3.XYZ `gd:"NORMAL"`                   // Normal that comes from the vertex() function, in view space. If skip_vertex_transform is enabled, it may not be in view space.
	Tangent                vec3.XYZ `gd:"TANGENT"`                  // Tangent that comes from the vertex() function, in view space. If skip_vertex_transform is enabled, it may not be in view space.
	Binormal               vec3.XYZ `gd:"BINORMAL"`                 // Binormal that comes from the vertex() function, in view space. If skip_vertex_transform is enabled, it may not be in view space.
	NormalMap              vec3.XYZ `gd:"NORMAL_MAP"`               // Set normal here if reading normal from a texture instead of NORMAL.
	NormalMapDepth         float.X  `gd:"NORMAL_MAP_DEPTH"`         // Depth from NORMAL_MAP. Defaults to 1.0.
	Albedo                 vec3.RGB `gd:"ALBEDO"`                   // Albedo (default white). Base color.
	Alpha                  float.X  `gd:"ALPHA"`                    // Alpha (range of [0.0, 1.0]). If read from or written to, the material will go to the transparent pipeline.
	AlphaScizzorThreshold  float.X  `gd:"ALPHA_SCISSOR_THRESHOLD"`  // If written to, values below a certain amount of alpha are discarded.
	AlphaHashScale         float.X  `gd:"ALPHA_HASH_SCALE"`         // Alpha hash scale when using the alpha hash transparency mode. Defaults to 1.0. Higher values result in more visible pixels in the dithering pattern.
	AlphaAntialiasingEdge  float.X  `gd:"ALPHA_ANTIALIASING_EDGE"`  // The threshold below which alpha to coverage antialiasing should be used. Defaults to 0.0. Requires the alpha_to_coverage render mode. Should be set to a value lower than ALPHA_SCISSOR_THRESHOLD to be effective.
	AlphaTextureCoordinate vec2.XY  `gd:"ALPHA_TEXTURE_COORDINATE"` // The texture coordinate to use for alpha-to-coverge antialiasing. Requires the alpha_to_coverage render mode. Typically set to UV * vec2(albedo_texture_size) where albedo_texture_size is the size of the albedo texture in pixels.
	PremultiplyAlphaFactor float.X  `gd:"PREMUL_ALPHA_FACTOR"`      // Premultiplied alpha factor. Only effective if render_mode blend_premul_alpha; is used. This should be written to when using a shaded material with premultiplied alpha blending for interaction with lighting. This is not required for unshaded materials.
	Metallic               float.X  `gd:"METALLIC"`                 // Metallic (range of [0.0, 1.0]).
	Specular               float.X  `gd:"SPECULAR"`                 // Specular (not physically accurate to change). Defaults to 0.5. 0.0 disables reflections.
	Roughness              float.X  `gd:"ROUGHNESS"`                // Roughness (range of [0.0, 1.0]).
	Rim                    float.X  `gd:"RIM"`                      // Rim (range of [0.0, 1.0]). If used, Godot calculates rim lighting. Rim size depends on ROUGHNESS.
	RimTint                float.X  `gd:"RIM_TINT"`                 // Rim Tint, range of 0.0 (white) to 1.0 (albedo). If used, Godot calculates rim lighting.
	ClearCoat              float.X  `gd:"CLEARCOAT"`                // Small specular blob added on top of the existing one. If used, Godot calculates clearcoat.
	ClearCoatGloss         float.X  `gd:"CLEARCOAT_GLOSS"`          // Gloss of clearcoat. If used, Godot calculates clearcoat.
	Anisotropy             float.X  `gd:"ANISOTROPY"`               // For distorting the specular blob according to tangent space.
	AnisotropyFlow         vec2.XY  `gd:"ANISOTROPY_FLOW"`          // Distortion direction, use with flowmaps.
	SubsurfaceScattering   SubsurfaceScattering
	Backlight              float.X `gd:"BACKLIGHT"` // Color of backlighting (works like direct light, but it's received even if the normal is slightly facing away from the light). If used, backlighting will be applied to the object. Can be used as a cheaper approximation of subsurface scattering.
	AmbientOcclusion       AmbientOcclusion
	Emission               vec3.RGB  `gd:"EMISSION"`   // Emission color (can go over (1.0, 1.0, 1.0) for HDR).
	Fog                    vec4.RGBA `gd:"FOG"`        // If written to, blends final pixel color with FOG.rgb based on FOG.a.
	Radiance               vec4.RGBA `gd:"RADIANCE"`   // If written to, blends environment map radiance with RADIANCE.rgb based on RADIANCE.a.
	Irradiance             vec4.RGBA `gd:"IRRADIANCE"` // If written to, blends environment map irradiance with IRRADIANCE.rgb based on IRRADIANCE.a.
}

type RenderMode string

type Shader[T gdclass.Interface] struct {
	ShaderMaterial.Extension[T]
}

type SubsurfaceScattering struct {
	Strength           float.X   `gd:"SUBSURFACE_SCATTERING"` // Strength of subsurface scattering. If used, subsurface scattering will be applied to the object.
	TransmittanceColor vec4.RGBA `gd:"TRANSMITTANCE_COLOR"`   // Color of subsurface scattering transmittance. If used, subsurface scattering transmittance will be applied to the object.
	TransmittanceDepth float.X   `gd:"TRANSMITTANCE_DEPTH"`   // Depth of subsurface scattering transmittance. Higher values allow the effect to reach deeper into the object.
	TransmittanceBoost float.X   `gd:"TRANSMITTANCE_BOOST"`   // Boosts the subsurface scattering transmittance if set above 0.0. This makes the effect show up even on directly lit surfaces
}

type Vertex struct {
	ViewportSize          vec2.XY          `gd:"VIEWPORT_SIZE"`            // Size of viewport (in pixels).
	ViewMatrix            mat4.ColumnMajor `gd:"VIEW_MATRIX"`              // View matrix. Transforms from world space to camera space.
	InvViewMatrix         mat4.ColumnMajor `gd:"INV_VIEW_MATRIX"`          // View space to world space transform.
	MainCamInvViewMatrix  mat4.ColumnMajor `gd:"MAIN_CAM_INV_VIEW_MATRIX"` // View space to world space transform of camera used to draw the current viewport.
	InvProjectionMatrix   mat4.ColumnMajor `gd:"INV_PROJECTION_MATRIX"`    // Clip space to view space transform.
	NodePositionWorld     vec3.XYZ         `gd:"NODE_POSITION_WORLD"`      // Node position in world space.
	NodePositionView      vec3.XYZ         `gd:"NODE_POSITION_VIEW"`       // Node position in view space.
	CameraPositionWorld   vec3.XYZ         `gd:"CAMERA_POSITION_WORLD"`    // Camera position in world space.
	CameraPositionView    vec3.XYZ         `gd:"CAMERA_POSITION_VIEW"`     // Camera position in view space.
	CameraDirectionWorld  vec3.XYZ         `gd:"CAMERA_DIRECTION_WORLD"`   // Camera direction in world space.
	CameraVisibleLayers   uint.X           `gd:"CAMERA_VISIBLE_LAYERS"`    // Camera visible layers.
	InstanceID            int.X            `gd:"INSTANCE_ID"`              // InstanceID for instancing.
	InstanceCustom        vec4.XYZW        `gd:"INSTANCE_CUSTOM"`          // Instance custom data (for particles, mostly).
	ViewIndex             int.X            `gd:"VIEW_INDEX"`               // The view that we are rendering. VIEW_MONO_LEFT (0) for Mono (not multiview) or left eye, VIEW_RIGHT (1) for right eye.
	ViewMonoLeft          int.X            `gd:"VIEW_MONO_LEFT"`           // Constant for Mono or left eye, always 0.
	ViewRight             int.X            `gd:"VIEW_RIGHT"`               // Constant for right eye, always 1.
	EyeOffset             vec3.XYZ         `gd:"EYE_OFFSET"`               // Position offset for the eye being rendered. Only applicable for multiview rendering.
	Position              vec3.XYZ         `gd:"VERTEX"`                   // Position of the vertex, in model space. In world space if world_vertex_coords is used.
	VertexID              int.X            `gd:"VERTEX_ID"`                // The index of the current vertex in the vertex buffer.
	Normal                vec3.XYZ         `gd:"NORMAL"`                   // Normal in model space. In world space if world_vertex_coords is used.
	Tangent               vec3.XYZ         `gd:"TANGENT"`                  // Tangent in model space. In world space if world_vertex_coords is used.
	Binormal              vec3.XYZ         `gd:"BINORMAL"`                 // Binormal in model space. In world space if world_vertex_coords is used.
	UV                    vec2.XY          `gd:"UV"`                       // UV main channel.
	UV2                   vec2.XY          `gd:"UV2"`                      // UV secondary channel.
	Color                 vec4.RGBA        `gd:"COLOR"`                    // Color from vertices.
	PointSize             float.X          `gd:"POINT_SIZE"`               // Point size for point rendering.
	ModelViewMatrix       mat4.ColumnMajor `gd:"MODEL_VIEW_MATRIX"`        // Model/local space to view space transform (use if possible).
	ModelViewNormalMatrix mat4.ColumnMajor `gd:"MODEL_VIEW_NORMAL_MATRIX"` //
	ModelMatrix           mat4.ColumnMajor `gd:"MODEL_MATRIX"`             // Model/local space to world space transform.
	ModelNormalMatrix     mat4.ColumnMajor `gd:"MODEL_NORMAL_MATRIX"`      //
	ProjectionMatrix      mat4.ColumnMajor `gd:"PROJECTION_MATRIX"`        // View space to clip space transform.
	BoneIndices           uvec4.XYZW       `gd:"BONE_INDICES"`             //
	BoneWeights           vec4.XYZW        `gd:"BONE_WEIGHTS"`             //
	Custom0               vec4.XYZW        `gd:"CUSTOM0"`                  //
	Custom1               vec4.XYZW        `gd:"CUSTOM1"`                  //
	Custom2               vec4.XYZW        `gd:"CUSTOM2"`                  //
	Custom3               vec4.XYZW        `gd:"CUSTOM3"`                  //
}