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 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 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 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 ImageMimeType string

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

type KHR_LightsPunctualType string

type Material struct {
	ChildOfRootProperty
	PbrMetallicRoughness *PbrMetallicRoughness `json:"pbrMetallicRoughness,omitempty"` // 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.
	NormalTexture        *NormalTexture        `json:"normalTexture,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.
	OcclusionTexture     *OcclusionTexture     `json:"occlusionTexture,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.
	EmissiveTexture      *TextureInfo          `json:"emissiveTexture,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.
	EmissiveFactor       *[3]float64           `json:"emissiveFactor,omitempty"`       // The factors for the emissive color of the material. This value defines linear multipliers for the sampled texels of the emissive texture.
	AlphaMode            *MaterialAlphaMode    `json:"alphaMode,omitempty"`            // The material's alpha rendering mode enumeration specifying the interpretation of the alpha value of the base color."
	AlphaCutoff          *float64              `json:"alphaCutoff,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.
	DoubleSided          *bool                 `json:"doubleSided,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.
}

type MaterialAlphaMode string

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

type Mesh struct {
	ChildOfRootProperty
	Primitives []Primitive `json:"primitives"`
	Weights    []float64   `json:"weights,omitempty"`
}

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.
}

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 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 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 PolyformMaterial struct {
	Name                 string
	Extras               map[string]any
	PbrMetallicRoughness *PolyformPbrMetallicRoughness
	Extensions           []MaterialExtension
	NormalTexture        *PolyformNormal
}

type PolyformMaterialsUnlit struct {
}

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

	Skeleton   *animation.Skeleton
	Animations []animation.Sequence
}

type PolyformNormal struct {
	PolyformTexture
	Scale *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
}

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

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

	// The F0 color of the specular reflection (linear RGB).
	SpecularColorFactor 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.
	SpecularColorTexture *PolyformTexture
}

type PolyformTexture struct {
	URI     string
	Sampler *Sampler
}

type PolyformTransmission struct {

	// The base percentage of light that is transmitted through the surface.
	// Default: 0.0
	TransmissionFactor float64

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

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 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 SamplerMinFilter int

type SamplerWrap int

type Scene struct {
	ChildOfRootProperty
	Nodes []GltfId `json:"nodes"` // 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 Texture struct {
	ChildOfRootProperty
	Sampler *GltfId `json:"sampler,omitempty"`
	Source  *GltfId `json:"source,omitempty"`
}

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.
}

type Writer struct {
	// contains filtered or unexported fields
}