gltf

type Accessor struct {
	ChildOfRootProperty
	BufferView    *GltfId               `json:"bufferView,omitempty"` // The index of the buffer view. When undefined, the accessor **MUST** be initialized with zeros; `sparse` property or extensions **MAY** override zeros with actual values.
	ByteOffset    int                   `json:"byteOffset,omitempty"` // The offset relative to the start of the buffer view in bytes.  This **MUST** be a multiple of the size of the component datatype. This property **MUST NOT** be defined when `bufferView` is undefined.
	ComponentType AccessorComponentType `json:"componentType"`        // The datatype of the accessor's components.  UNSIGNED_INT type **MUST NOT** be used for any accessor that is not referenced by `mesh.primitive.indices`.
	Normalized    bool                  `json:"normalized,omitempty"` // Specifies whether integer data values are normalized (`true`) to [0, 1] (for unsigned types) or to [-1, 1] (for signed types) when they are accessed. This property **MUST NOT** be set to `true` for accessors with `FLOAT` or `UNSIGNED_INT` component type.
	Type          AccessorType          `json:"type"`                 // Specifies if the accessor's elements are scalars, vectors, or matrices.
	Count         int                   `json:"count"`                // The number of elements referenced by this accessor, not to be confused with the number of bytes or number of components.
	Max           []float64             `json:"max,omitempty"`        // Maximum value of each component in this accessor.  Array elements **MUST** be treated as having the same data type as accessor's `componentType`. Both `min` and `max` arrays have the same length.  The length is determined by the value of the `type` property; it can be 1, 2, 3, 4, 9, or 16.\n\n`normalized` property has no effect on array values: they always correspond to the actual values stored in the buffer. When the accessor is sparse, this property **MUST** contain maximum values of accessor data with sparse substitution applied.
	Min           []float64             `json:"min,omitempty"`        // Minimum value of each component in this accessor.  Array elements **MUST** be treated as having the same data type as accessor's `componentType`. Both `min` and `max` arrays have the same length.  The length is determined by the value of the `type` property; it can be 1, 2, 3, 4, 9, or 16.\n\n`normalized` property has no effect on array values: they always correspond to the actual values stored in the buffer. When the accessor is sparse, this property **MUST** contain minimum values of accessor data with sparse substitution applied.

}

type AccessorComponentType int

type AccessorType string

type Animation struct {
	ChildOfRootProperty
	Channels []AnimationChannel `json:"channels"` // An array of animation channels. An animation channel combines an animation sampler with a target property being animated. Different channels of the same animation **MUST NOT** have the same targets.
	Samplers []AnimationSampler `json:"samplers"` // An array of animation samplers. An animation sampler combines timestamps with a sequence of output values and defines an interpolation algorithm.
}

type AnimationChannel struct {
	Property
	Sampler GltfId                 `json:"sampler"` // The index of a sampler in this animation used to compute the value for the target, e.g., a node's translation, rotation, or scale (TRS).
	Target  AnimationChannelTarget `json:"target"`  // The descriptor of the animated property.
}

type AnimationChannelTarget struct {
	Property
	Node GltfId                     `json:"node,omitempty"`
	Path AnimationChannelTargetPath `json:"path"`
}

type AnimationChannelTargetPath string

type AnimationSampler struct {
	Property
	Input         GltfId                        `json:"input"`                   // The index of an accessor containing keyframe timestamps. The accessor **MUST** be of scalar type with floating-point components. The values represent time in seconds with `time[0] >= 0.0`, and strictly increasing values, i.e., `time[n + 1] > time[n]`.
	Output        GltfId                        `json:"output"`                  // The index of an accessor, containing keyframe output values.
	Interpolation AnimationSamplerInterpolation `json:"interpolation,omitempty"` // The index of an accessor, containing keyframe output values.
}

type AnimationSamplerInterpolation string

type Artifact struct {
	Scene PolyformScene
}

type Asset struct {
	Property
	Version    string `json:"version"`              // The glTF version in the form of `<major>.<minor>` that this asset targets.
	Generator  string `json:"generator,omitempty"`  // Tool that generated this glTF model.  Useful for debugging.
	Copyright  string `json:"copyright,omitempty"`  // A copyright message suitable for display to credit the content creator.
	MinVersion string `json:"minVersion,omitempty"` // The minimum glTF version in the form of `<major>.<minor>` that this asset targets. This property **MUST NOT** be greater than the asset version.
}

type Buffer struct {
	ChildOfRootProperty
	ByteLength int    `json:"byteLength"`    // The length of the buffer in bytes.
	URI        string `json:"uri,omitempty"` // The URI (or IRI) of the buffer.  Relative paths are relative to the current glTF asset.  Instead of referencing an external file, this field **MAY** contain a `data:`-URI.
}

type BufferEmbeddingStrategy int

type BufferLoader interface {
	// LoadBuffer loads binary data for the given URI.
	// The URI may be a relative path, absolute path, or custom scheme.
	LoadBuffer(uri string) ([]byte, error)
}

type BufferView struct {
	ChildOfRootProperty
	Buffer     int              `json:"buffer"`               // The index of the buffer
	ByteOffset int              `json:"byteOffset,omitempty"` // The offset into the buffer in bytes.
	ByteLength int              `json:"byteLength"`           // The length of the bufferView in bytes.
	ByteStride *int             `json:"byteStride,omitempty"` // The stride, in bytes, between vertex attributes.  When this is not defined, data is tightly packed. When two or more accessors use the same buffer view, this field **MUST** be defined.
	Target     BufferViewTarget `json:"target,omitempty"`     // The hint representing the intended GPU buffer type to use with this buffer view.
}

type BufferViewTarget int

type Camera struct{}

type ChildOfRootProperty struct {
	Property
	// The user-defined name of this object.  This is not necessarily unique, e.g.,
	// an accessor and a buffer could have the same name, or two accessors could
	// even have the same name.
	Name string `json:"name,omitempty"`
}

type ExtGpuInstancing struct {
	Attributes map[string]int `json:"attributes"`
}

type Extensions = map[string]any

type Extra = map[string]any

type Gltf struct {
	Property

	ExtensionsUsed     []string `json:"extensionsUsed,omitempty"`     // Names of glTF extensions used in this asset.
	ExtensionsRequired []string `json:"extensionsRequired,omitempty"` // Names of glTF extensions required to properly load this asset.

	Accessors   []Accessor   `json:"accessors,omitempty"`   // An array of accessors.  An accessor is a typed view into a bufferView.
	Animations  []Animation  `json:"animations,omitempty"`  // An array of keyframe animations.
	Asset       Asset        `json:"asset"`                 // Metadata about the glTF asset.
	Buffers     []Buffer     `json:"buffers,omitempty"`     // An array of buffers.  A buffer points to binary geometry, animation, or skins.
	BufferViews []BufferView `json:"bufferViews,omitempty"` // An array of bufferViews.  A bufferView is a view into a buffer generally representing a subset of the buffer
	Cameras     []Camera     `json:"cameras,omitempty"`     // An array of cameras.  A camera defines a projection matrix.
	Images      []Image      `json:"images,omitempty"`      // An array of images.  An image defines data used to create a texture.
	Materials   []Material   `json:"materials,omitempty"`   // An array of materials.  A material defines the appearance of a primitive.
	Meshes      []Mesh       `json:"meshes,omitempty"`      // An array of meshes.  A mesh is a set of primitives to be rendered
	Nodes       []Node       `json:"nodes,omitempty"`       // An array of nodes.
	Samplers    []Sampler    `json:"samplers,omitempty"`    // An array of samplers.  A sampler contains properties for texture filtering and wrapping modes.
	Scene       *int         `json:"scene,omitempty"`       // The index of the default scene.  This property **MUST NOT** be defined, when `scenes` is undefined.
	Scenes      []Scene      `json:"scenes,omitempty"`      // An array of scenes.
	Skins       []Skin       `json:"skins,omitempty"`       // An array of skins.  A skin is defined by joints and matrices.
	Textures    []Texture    `json:"textures,omitempty"`    // An array of textures
}

type GltfId = int

type Image struct {
	ChildOfRootProperty
	MimeType   ImageMimeType `json:"mimeType,omitempty"`   // The image's media type. This field **MUST** be defined when `bufferView` is defined.
	URI        string        `json:"uri,omitempty"`        // The URI (or IRI) of the image.  Relative paths are relative to the current glTF asset.  Instead of referencing an external file, this field **MAY** contain a `data:`-URI. This field **MUST NOT** be defined when `bufferView` is defined.
	BufferView *GltfId       `json:"bufferView,omitempty"` // The index of the bufferView that contains the image. This field **MUST NOT** be defined when `uri` is defined.
}

type ImageLoader interface {
	// LoadImage loads an image for the given URI.
	// The URI may be a relative path, absolute path, or custom scheme.
	LoadImage(uri string) (image.Image, string, error)
}

type ImageMimeType string

type JsonFormat int

type KHR_LightsPunctual struct {
	Type      KHR_LightsPunctualType
	Name      *string
	Color     color.Color
	Intensity *float64
	Range     *float64
	Position  vector3.Float64
}

type KHR_LightsPunctualType string

type ManifestNode struct {
	Models []nodes.Output[PolyformModel]
}

type Material struct {
	ChildOfRootProperty
	// A set of parameter values that are used to define the metallic-roughness material model from Physically Based Rendering (PBR) methodology. When undefined, all the default values of `pbrMetallicRoughness` **MUST** apply.
	PbrMetallicRoughness *PbrMetallicRoughness `json:"pbrMetallicRoughness,omitempty"`

	// The tangent space normal texture. The texture encodes RGB components with linear transfer function. Each texel represents the XYZ components of a normal vector in tangent space. The normal vectors use the convention +X is right and +Y is up. +Z points toward the viewer. If a fourth component (A) is present, it **MUST** be ignored. When undefined, the material does not have a tangent space normal texture.
	NormalTexture *NormalTexture `json:"normalTexture,omitempty"`

	// The occlusion texture. The occlusion values are linearly sampled from the R channel. Higher values indicate areas that receive full indirect lighting and lower values indicate no indirect lighting. If other channels are present (GBA), they **MUST** be ignored for occlusion calculations. When undefined, the material does not have an occlusion texture.
	OcclusionTexture *OcclusionTexture `json:"occlusionTexture,omitempty"`

	// The emissive texture. It controls the color and intensity of the light being emitted by the material. This texture contains RGB components encoded with the sRGB transfer function. If a fourth component (A) is present, it **MUST** be ignored. When undefined, the texture **MUST** be sampled as having `1.0` in RGB components.
	EmissiveTexture *TextureInfo `json:"emissiveTexture,omitempty"`

	// The factors for the emissive color of the material. This value defines linear multipliers for the sampled texels of the emissive texture.
	EmissiveFactor *[3]float64 `json:"emissiveFactor,omitempty"`

	// The material's alpha rendering mode enumeration specifying the interpretation of the alpha value of the base color."
	AlphaMode *MaterialAlphaMode `json:"alphaMode,omitempty"`

	// Specifies the cutoff threshold when in `MASK` alpha mode. If the alpha value is greater than or equal to this value then it is rendered as fully opaque, otherwise, it is rendered as fully transparent. A value greater than `1.0` will render the entire material as fully transparent. This value **MUST** be ignored for other alpha modes. When `alphaMode` is not defined, this value **MUST NOT** be defined.
	AlphaCutoff *float64 `json:"alphaCutoff,omitempty"`

	// Specifies whether the material is double sided. When this value is false, back-face culling is enabled. When this value is true, back-face culling is disabled and double-sided lighting is enabled. The back-face **MUST** have its normals reversed before the lighting equation is evaluated.
	DoubleSided *bool `json:"doubleSided,omitempty"`
}

type MaterialAlphaMode string

type MaterialAnisotropyExtensionNode struct {
	AnisotropyStrength nodes.Output[float64] `` /* 134-byte string literal not displayed */
	AnisotropyRotation nodes.Output[float64] `` /* 240-byte string literal not displayed */
}

type MaterialClearcoatExtensionNode struct {
	ClearcoatFactor          nodes.Output[float64]
	ClearcoatRoughnessFactor nodes.Output[float64]
}

type MaterialExtension interface {
	ExtensionID() string
	ToMaterialExtensionData(w *Writer) map[string]any
}

type MaterialNode struct {
	Color                    nodes.Output[coloring.WebColor] `` /* 149-byte string literal not displayed */
	ColorTexture             nodes.Output[PolyformTexture]   `` /* 498-byte string literal not displayed */
	MetallicFactor           nodes.Output[float64]           `` /* 166-byte string literal not displayed */
	RoughnessFactor          nodes.Output[float64]           `` /* 166-byte string literal not displayed */
	MetallicRoughnessTexture nodes.Output[PolyformTexture]   `` /* 392-byte string literal not displayed */
	EmissiveFactor           nodes.Output[coloring.WebColor] `` /* 151-byte string literal not displayed */
	NormalTexture            nodes.Output[PolyformNormal]    `` /* 421-byte string literal not displayed */

	// Extensions
	IndexOfRefraction nodes.Output[float64]
	Transmission      nodes.Output[PolyformTransmission]
	Volume            nodes.Output[PolyformVolume]
	Anisotropy        nodes.Output[PolyformAnisotropy]
	Clearcoat         nodes.Output[PolyformClearcoat]
	EmissiveStrength  nodes.Output[float64]
}

type MaterialTransmissionExtensionNode struct {
	Factor  nodes.Output[float64]         `description:"The base percentage of light that is transmitted through the surface"`
	Texture nodes.Output[PolyformTexture] `` /* 152-byte string literal not displayed */
}

type MaterialVolumeExtensionNode struct {
	ThicknessFactor     nodes.Output[float64]           `` /* 291-byte string literal not displayed */
	AttenuationDistance nodes.Output[float64]           `` /* 189-byte string literal not displayed */
	AttenuationColor    nodes.Output[coloring.WebColor] `description:"The color that white light turns into due to absorption when reaching the attenuation distance."`
}

type Mesh struct {
	ChildOfRootProperty
	Primitives []Primitive `json:"primitives"`        // An array of primitives, each defining geometry to be rendered.
	Weights    []float64   `json:"weights,omitempty"` // Array of weights to be applied to the morph targets. The number of array elements **MUST** match the number of morph targets.
}

type ModelNode struct {
	Mesh     nodes.Output[modeling.Mesh]
	Material nodes.Output[PolyformMaterial]

	Translation nodes.Output[vector3.Float64]
	Rotation    nodes.Output[quaternion.Quaternion]
	Scale       nodes.Output[vector3.Float64]

	GpuInstances nodes.Output[[]trs.TRS]
}

type NoOpImageLoader struct{}

type Node struct {
	ChildOfRootProperty
	Camera      *GltfId      `json:"camera,omitempty"`      // The index of the camera referenced by this node.
	Children    []GltfId     `json:"children,omitempty"`    // The indices of this node's children.
	Skin        *GltfId      `json:"skin,omitempty"`        // The index of the skin referenced by this node. When a skin is referenced by a node within a scene, all joints used by the skin **MUST** belong to the same scene. When defined, `mesh` **MUST** also be defined.
	Matrix      *[16]float64 `json:"matrix,omitempty"`      // A floating-point 4x4 transformation matrix stored in column-major order.
	Mesh        *GltfId      `json:"mesh,omitempty"`        // The index of the mesh in this node.
	Rotation    *[4]float64  `json:"rotation,omitempty"`    // The node's unit quaternion rotation in the order (x, y, z, w), where w is the scalar.
	Scale       *[3]float64  `json:"scale,omitempty"`       // The node's non-uniform scale, given as the scaling factors along the x, y, and z axes.
	Translation *[3]float64  `json:"translation,omitempty"` // The node's translation along the x, y, and z axes.
	Weights     []float64    `json:"weights,omitempty"`     // The weights of the instantiated morph target. The number of array elements **MUST** match the number of morph targets of the referenced mesh. When defined, `mesh` **MUST** also be defined.
	Name        string       `json:"name,omitempty"`
}

type NormalTexture struct {
	TextureInfo
	Scale *float64 `json:"scale,omitempty"` // The scalar parameter applied to each normal vector of the texture. This value scales the normal vector in X and Y directions using the formula: `scaledNormal =  normalize((<sampled normal texture value> * 2.0 - 1.0) * vec3(<normal scale>, <normal scale>, 1.0))`.
}

type NormalTextureNode struct {
	Texture nodes.Output[PolyformTexture]
	Scale   nodes.Output[float64]
}

type OcclusionTexture struct {
	TextureInfo
	Strength *float64 `json:"strength,omitempty"` // A scalar parameter controlling the amount of occlusion applied. A value of `0.0` means no occlusion. A value of `1.0` means full occlusion. This value affects the final occlusion value as: `1.0 + strength * (<sampled occlusion texture value> - 1.0)`.
}

type PbrMetallicRoughness struct {
	Property
	BaseColorFactor          *[4]float64  `json:"baseColorFactor,omitempty"`          // The factors for the base color of the material. This value defines linear multipliers for the sampled texels of the base color texture.
	BaseColorTexture         *TextureInfo `json:"baseColorTexture,omitempty"`         // The base color texture. The first three components (RGB) **MUST** be encoded with the sRGB transfer function. They specify the base color of the material. If the fourth component (A) is present, it represents the linear alpha coverage of the material. Otherwise, the alpha coverage is equal to `1.0`. The `material.alphaMode` property specifies how alpha is interpreted. The stored texels **MUST NOT** be premultiplied. When undefined, the texture **MUST** be sampled as having `1.0` in all components.
	MetallicFactor           *float64     `json:"metallicFactor,omitempty"`           // The factor for the metalness of the material. This value defines a linear multiplier for the sampled metalness values of the metallic-roughness texture.
	RoughnessFactor          *float64     `json:"roughnessFactor,omitempty"`          // The factor for the roughness of the material. This value defines a linear multiplier for the sampled roughness values of the metallic-roughness texture.
	MetallicRoughnessTexture *TextureInfo `json:"metallicRoughnessTexture,omitempty"` // The metallic-roughness texture. The metalness values are sampled from the B channel. The roughness values are sampled from the G channel. These values **MUST** be encoded with a linear transfer function. If other channels are present (R or A), they **MUST** be ignored for metallic-roughness calculations. When undefined, the texture **MUST** be sampled as having `1.0` in G and B components.
}

type PolyformAnisotropy struct {
	// The anisotropy strength. When the anisotropy texture is present, this
	// value is multiplied by the texture's blue channel.
	AnisotropyStrength float64

	// The rotation of the anisotropy in tangent, bitangent space, measured in
	// radians counter-clockwise from the tangent. When the anisotropy texture
	// is present, this value provides additional rotation to the vectors in
	// the texture.
	AnisotropyRotation float64

	// The anisotropy texture. Red and green channels represent the anisotropy
	// direction in $[-1, 1]$ tangent, bitangent space, to be rotated by the
	// anisotropy rotation. The blue channel contains strength as $[0, 1]$ to
	// be multiplied by the anisotropy strength.
	AnisotropyTexture *PolyformTexture
}

type PolyformClearcoat struct {
	ClearcoatFactor           float64
	ClearcoatTexture          *PolyformTexture
	ClearcoatRoughnessFactor  float64
	ClearcoatRoughnessTexture *PolyformTexture
	ClearcoatNormalTexture    *PolyformNormal
}

type PolyformDispersion struct {
	// This parameter defines dispersion in terms of the 20/Abbe number
	// formulation.
	Dispersion float64
}

type PolyformEmissiveStrength struct {
	// The strength adjustment to be multiplied with the material's emissive value.
	EmissiveStrength *float64
}

type PolyformIndexOfRefraction struct {
	// The index of refraction
	// Air	           1.0
	// Water     	   1.33
	// Eyes	           1.38
	// Window Glass	   1.52
	// Sapphire	       1.76
	// Diamond	       2.42
	IOR *float64
}

type PolyformIridescence struct {
	// The iridescence intensity factor
	IridescenceFactor float64

	// The iridescence intensity texture. The values are sampled from the R
	// channel. These values are linear. If a texture is not given, a value
	// of `1.0` **MUST** be assumed. If other channels are present (GBA), they
	// are ignored for iridescence intensity calculations
	IridescenceTexture *PolyformTexture

	// The index of refraction of the dielectric thin-film layer.
	IridescenceIor *float64

	// The minimum thickness of the thin-film layer given in nanometers. The
	// value **MUST** be less than or equal to the value of
	// `iridescenceThicknessMaximum`.
	IridescenceThicknessMinimum *float64

	// The maximum thickness of the thin-film layer given in nanometers. The
	// value **MUST** be greater than or equal to the value of
	// `iridescenceThicknessMinimum`.
	IridescenceThicknessMaximum *float64

	// The thickness texture of the thin-film layer to linearly interpolate
	// between the minimum and maximum thickness given by the corresponding
	// properties, where a sampled value of `0.0` represents the minimum
	// thickness and a sampled value of `1.0` represents the maximum thickness.
	// The values are sampled from the G channel. These values are linear. If a
	// texture is not given, the maximum thickness **MUST** be assumed. If
	// other channels are present (RBA), they are ignored for thickness
	// calculations.
	IridescenceThicknessTexture *PolyformTexture
}

type PolyformMaterial struct {
	Name                 string
	Extras               map[string]any
	AlphaMode            *MaterialAlphaMode
	AlphaCutoff          *float64
	PbrMetallicRoughness *PolyformPbrMetallicRoughness
	Extensions           []MaterialExtension
	NormalTexture        *PolyformNormal
	OcclusionTexture     *PolyformOcclusion
	EmissiveTexture      *PolyformTexture
	EmissiveFactor       color.Color
}

type PolyformModel struct {
	Name     string
	Mesh     *modeling.Mesh
	Material *PolyformMaterial

	// TRS contains the transformation (translation, rotation, scale) for this model
	// This is optional and it will be used if the models are deduplicated and collapsed into a list of instances.
	TRS *trs.TRS

	// Utilizes the EXT_mesh_gpu_instancing extension to duplicate the model
	// without increasing the mesh data footprint on the GPU.
	// This is a list of transformations where this model should be repeated.
	// This can only used if the UseGpuInstancing flag is set on the scene.
	// If flag is not set, populating this list will cause the scene writing to fail.
	GpuInstances []trs.TRS

	// Animation is a list of animations that are applied to this model.
	// Models with animations defined will never be deduplicated into a single list.
	// However, these models can utilize GpuInstances and in that case the same animation will be applied to all of them.
	// Limitations on using GpuInstances still apply.
	Skeleton   *animation.Skeleton
	Animations []animation.Sequence
}

type PolyformNormal struct {
	*PolyformTexture
	Scale *float64
}

type PolyformOcclusion struct {
	*PolyformTexture
	Strength *float64
}

type PolyformPbrMetallicRoughness struct {
	BaseColorFactor          color.Color
	BaseColorTexture         *PolyformTexture
	MetallicFactor           *float64
	RoughnessFactor          *float64
	MetallicRoughnessTexture *PolyformTexture
}

type PolyformPbrSpecularGlossiness struct {
	// The RGBA components of the reflected diffuse color of the material.
	// Metals have a diffuse value of [0.0, 0.0, 0.0]. The fourth component (A)
	// is the opacity of the material. The values are linear.
	DiffuseFactor color.Color

	// The diffuse texture. This texture contains RGB(A) components of the
	// reflected diffuse color of the material in sRGB color space. If the
	// fourth component (A) is present, it represents the alpha coverage of the
	// material. Otherwise, an alpha of 1.0 is assumed. The alphaMode property
	// specifies how alpha is interpreted. The stored texels must not be
	// premultiplied.
	DiffuseTexture *PolyformTexture

	// The specular RGB color of the material. This value is linear.
	SpecularFactor color.Color

	// The glossiness or smoothness of the material. A value of 1.0 means the
	// material has full glossiness or is perfectly smooth. A value of 0.0
	// means the material has no glossiness or is perfectly rough. This value
	// is linear.
	// Default value is 1.0
	GlossinessFactor *float64

	// The specular-glossiness texture is a RGBA texture, containing the
	// specular color (RGB) in sRGB space and the glossiness value (A) in
	// linear space.
	SpecularGlossinessTexture *PolyformTexture
}

type PolyformScene struct {
	Models []PolyformModel
	Lights []KHR_LightsPunctual

	// UseGpuInstancing indicates that the EXT_mesh_gpu_instancing extension should be used
	// when appropriate for mesh instances. This must be set if GPU instances are defined on any of the models in the scene.
	// If not set while GPU instances are defined - the scene serialisation will fail.
	// This is a global setting for the scene and cannot be set on a per-model basis.
	//
	// The model deduplication applies regardless, and models that have exactly the same mesh pointer reference,
	// and material value will be collapsed into a single list.
	// If this flag is set, this single list will be converted into GPU instances as well.
	UseGpuInstancing bool
}

type PolyformSheen struct {
	// Color of the sheen layer (in linear space).
	SheenColorFactor color.Color

	// The sheen color (RGB) texture. Stored in channel RGB, the sheen color is
	// in sRGB transfer function.
	SheenColorTexture *PolyformTexture

	// The sheen layer roughness of the material.
	SheenRoughnessFactor float64

	// The sheen roughness (Alpha) texture. Stored in alpha channel, the
	// roughness value is in linear space.
	SheenRoughnessTexture *PolyformTexture
}

type PolyformSpecular struct {
	// The strength of the specular reflection.
	// Default: 1.0
	Factor *float64

	// A texture that defines the strength of the specular reflection, stored
	// in the alpha (A) channel. This will be multiplied by specularFactor.
	Texture *PolyformTexture

	// The F0 color of the specular reflection (linear RGB).
	ColorFactor color.Color

	// 	A texture that defines the F0 color of the specular reflection, stored
	// in the RGB channels and encoded in sRGB. This texture will be multiplied
	// by specularColorFactor.
	ColorTexture *PolyformTexture
}

type PolyformTexture struct {
	URI        string
	Image      image.Image
	Sampler    *Sampler
	Extensions []TextureExtension
}

type PolyformTextureTransform struct {
	// Whether to make this extension required for the given model.
	// If set - extension will be added to `extensionsRequired` list at the GLTF file top level.
	Required bool

	Offset   *vector2.Float64 // The offset of the UV coordinate origin as a factor of the texture dimensions.
	Rotation *float64         // Rotate the UVs by this many radians counter-clockwise around the origin. This is equivalent to a similar rotation of the image clockwise.
	Scale    *vector2.Float64 // The scale factor applied to the components of the UV coordinates.
	TexCoord *int             // Overrides the textureInfo texCoord value if supplied, and if this extension is supported.
}

type PolyformTransmission struct {
	// The base percentage of light that is transmitted through the surface.
	// Default: 0.0
	Factor float64

	// A texture that defines the transmission percentage of the surface,
	// stored in the R channel. This will be multiplied by transmissionFactor.
	Texture *PolyformTexture
}

type PolyformUnlit struct {
}

type PolyformVolume struct {
	// The thickness of the volume beneath the surface. The value is given in
	// the coordinate space of the mesh. If the value is 0 the material is
	// thin-walled. Otherwise the material is a volume boundary. The
	// doubleSided property has no effect on volume boundaries. Range is
	// [0, +inf).
	// Default: 0
	ThicknessFactor float64

	// A texture that defines the thickness, stored in the G channel. This will
	// be multiplied by thicknessFactor. Range is [0, 1].
	ThicknessTexture *PolyformTexture

	// Density of the medium given as the average distance that light travels
	// in the medium before interacting with a particle. The value is given in
	// world space. Range is (0, +inf).
	// Default: +Infinity
	AttenuationDistance *float64

	// The color that white light turns into due to absorption when reaching
	// the attenuation distance.
	AttenuationColor color.Color
}

type Primitive struct {
	Property
	Attributes map[string]GltfId `json:"attributes"`         // A plain JSON object, where each key corresponds to a mesh attribute semantic and each value is the index of the accessor containing attribute's data.
	Indices    *GltfId           `json:"indices,omitempty"`  // The index of the accessor that contains the vertex indices.  When this is undefined, the primitive defines non-indexed geometry.  When defined, the accessor **MUST** have `SCALAR` type and an unsigned integer component type.
	Material   *GltfId           `json:"material,omitempty"` // The index of the material to apply to this primitive when rendering.
	Targets    []GltfId          `json:"targets,omitempty"`  // A plain JSON object specifying attributes displacements in a morph target, where each key corresponds to one of the three supported attribute semantic (`POSITION`, `NORMAL`, or `TANGENT`) and each value is the index of the accessor containing the attribute displacements' data.
	Mode       *PrimitiveMode    `json:"mode,omitempty"`     // The topology type of primitives to render.
}

type PrimitiveMode int

type Property struct {
	Extensions Extensions `json:"extensions,omitempty"`
	Extras     Extra      `json:"extras,omitempty"`
}

type ReaderOptions struct {
	// BufferLoader provides custom buffer resolution. If nil, uses default file loading.
	BufferLoader BufferLoader

	// ImageLoader provides custom image resolution. If nil, uses default file loading.
	ImageLoader ImageLoader

	// BasePath overrides the base path for resolving relative URIs.
	// If empty, uses the directory of the GLTF file (for file-based loading) or current directory.
	BasePath string
}

type Sampler struct {
	ChildOfRootProperty
	MagFilter SamplerMagFilter `json:"magFilter,omitempty"` // Magnification filter.
	MinFilter SamplerMinFilter `json:"minFilter,omitempty"` // Minification filter
	WrapS     SamplerWrap      `json:"wrapS,omitempty"`     // S (U) wrapping mode.  All valid values correspond to WebGL enums.
	WrapT     SamplerWrap      `json:"wrapT,omitempty"`     // T (V) wrapping mode.
}

type SamplerMagFilter int

type SamplerMagFilterNode struct {
}

type SamplerMinFilter int

type SamplerMinFilterNode struct {
}

type SamplerNode struct {
	MagFilter nodes.Output[SamplerMagFilter] `description:"Magnification filter"`
	MinFilter nodes.Output[SamplerMinFilter] `description:"Minification filter"`
	WrapS     nodes.Output[SamplerWrap]      `description:"S (U) wrapping mode"`
	WrapT     nodes.Output[SamplerWrap]      `description:"T (V) wrapping mode"`
}

type SamplerWrap int

type SamplerWrapNode struct {
}

type Scene struct {
	ChildOfRootProperty
	Nodes []GltfId `json:"nodes,omitempty"` // The indices of each root node.
}

type Skin struct {
	ChildOfRootProperty
	InverseBindMatrices GltfId   `json:"inverseBindMatrices,omitempty"` // The index of the accessor containing the floating-point 4x4 inverse-bind matrices. Its `accessor.count` property **MUST** be greater than or equal to the number of elements of the `joints` array. When undefined, each matrix is a 4x4 identity matrix.
	Skeleton            GltfId   `json:"skeleton,omitempty"`            // The index of the node used as a skeleton root. The node **MUST** be the closest common root of the joints hierarchy or a direct or indirect parent node of the closest common root.
	Joints              []GltfId `json:"joints"`                        // Indices of skeleton nodes, used as joints in this skin.
}

type StandardLoader struct {
	// BasePath is used to resolve relative file paths
	BasePath string
}

type Texture struct {
	ChildOfRootProperty
	Sampler    *GltfId    `json:"sampler,omitempty"`
	Source     *GltfId    `json:"source,omitempty"`
	Extensions Extensions `json:"extensions,omitempty"`
}

type TextureExtension interface {
	ExtensionID() string
	ToTextureExtensionData(w *Writer) map[string]any
	IsRequired() bool

	// indicates if the extension should be applied to Texture or TextureInfo object
	IsInfo() bool
}

type TextureInfo struct {
	Property
	Index      GltfId     `json:"index"`              // The index of the texture.
	TexCoord   int        `json:"texCoord,omitempty"` // "This integer value is used to construct a string in the format `TEXCOORD_<set index>` which is a reference to a key in `mesh.primitives.attributes` (e.g. a value of `0` corresponds to `TEXCOORD_0`). A mesh primitive **MUST** have the corresponding texture coordinate attributes for the material to be applicable to it.
	Extensions Extensions `json:"extensions,omitempty"`
}

type TextureNode struct {
	Image   nodes.Output[image.Image]
	Sampler nodes.Output[Sampler]
}

type TextureReferenceNode struct {
	URI     nodes.Output[string]
	Sampler nodes.Output[Sampler]
}

type Writer struct {

	// EmbedTextures forces texture images to be embedded as data URIs instead of external file references
	EmbedTextures bool
	// contains filtered or unexported fields
}

type WriterOptions struct {
	// EmbedTextures forces texture images to be embedded as data URIs instead of external file references
	EmbedTextures bool

	// JsonFormat specifies the JSON output format (default is pretty-printed with indentation)
	JsonFormat JsonFormat
}