core

type AiAABB struct {
	Min *common.AiVector3D
	Max *common.AiVector3D
}

type AiAnimBehaviour int

type AiAnimMesh struct {
	/**Anim Mesh name */
	Name string

	/** Replacement for aiMesh::mVertices. If this array is non-nullptr,
	 *  it *must* contain mNumVertices entries. The corresponding
	 *  array in the host mesh must be non-nullptr as well - animation
	 *  meshes may neither add or nor remove vertex components (if
	 *  a replacement array is nullptr and the corresponding source
	 *  array is not, the source data is taken instead)*/
	Vertices []*common.AiVector3D

	/** Replacement for aiMesh::mNormals.  */
	Normals []*common.AiVector3D

	/** Replacement for aiMesh::mTangents. */
	Tangents []*common.AiVector3D

	/** Replacement for aiMesh::mBitangents. */
	Bitangents []*common.AiVector3D

	/** Replacement for aiMesh::mColors */
	Colors [][]*common.AiColor4D

	/** Replacement for aiMesh::mTextureCoords */
	TextureCoords [][]*common.AiVector3D
	/**
	 * Weight of the AnimMesh.
	 */
	Weight float32
}

type AiAnimation struct {
	/** The name of the animation. If the modeling package this data was
	 *  exported from does support only a single animation channel, this
	 *  name is usually empty (length is zero). */
	Name string

	/** Duration of the animation in ticks.  */
	Duration float64

	/** Ticks per second. 0 if not specified in the imported file */
	TicksPerSecond float64
	/** The node animation channels. Each channel affects a single node.
	 *  The array is mNumChannels in size. */
	Channels []*AiNodeAnim

	/** The mesh animation channels. Each channel affects a single mesh.
	 *  The array is mNumMeshChannels in size. */
	MeshChannels []*AiMeshAnim
	/** The morph mesh animation channels. Each channel affects a single mesh.
	 *  The array is mNumMorphMeshChannels in size. */
	MorphMeshChannels []*AiMeshMorphAnim
}

type AiBlendMode int

type AiBone struct {
	/**
	 * The name of the bone.
	 */
	Name string
	/**
	 * The bone armature node - used for skeleton conversion
	 * you must enable aiProcess_PopulateArmatureData to populate this
	 */
	Armature []*AiNode

	/**
	 * The bone node in the scene - used for skeleton conversion
	 * you must enable aiProcess_PopulateArmatureData to populate this
	 */
	Node []*AiNode

	/**
	 * The influence weights of this bone, by vertex index.
	 */
	Weights []*common.AiVertexWeight

	/**
	 * Matrix that transforms from mesh space to bone space in bind pose.
	 *
	 * This matrix describes the position of the mesh
	 * in the local space of this bone when the skeleton was bound.
	 * Thus it can be used directly to determine a desired vertex position,
	 * given the world-space transform of the bone when animated,
	 * and the position of the vertex in mesh space.
	 *
	 * It is sometimes called an inverse-bind matrix,
	 * or inverse bind pose matrix.
	 */
	OffsetMatrix *common.AiMatrix4x4
}

type AiCamera struct {
	/** The name of the camera.
	 *
	 *  There must be a node in the scenegraph with the same name.
	 *  This node specifies the position of the camera in the scene
	 *  hierarchy and can be animated.
	 */
	Name string

	/** Position of the camera relative to the coordinate space
	 *  defined by the corresponding node.
	 *
	 *  The default value is 0|0|0.
	 */
	Position *common.AiVector3D

	/** 'Up' - vector of the camera coordinate system relative to
	 *  the coordinate space defined by the corresponding node.
	 *
	 *  The 'right' vector of the camera coordinate system is
	 *  the cross product of  the up and lookAt vectors.
	 *  The default value is 0|1|0. The vector
	 *  may be normalized, but it needn't.
	 */
	Up *common.AiVector3D

	/** 'LookAt' - vector of the camera coordinate system relative to
	 *  the coordinate space defined by the corresponding node.
	 *
	 *  This is the viewing direction of the user.
	 *  The default value is 0|0|1. The vector
	 *  may be normalized, but it needn't.
	 */
	LookAt *common.AiVector3D

	/** Horizontal field of view angle, in radians.
	 *
	 *  The field of view angle is the angle between the center
	 *  line of the screen and the left or right border.
	 *  The default value is 1/4PI.
	 */
	HorizontalFOV float32

	/** Distance of the near clipping plane from the camera.
	 *
	 * The value may not be 0.f (for arithmetic reasons to prevent
	 * a division through zero). The default value is 0.1f.
	 */
	ClipPlaneNear float32

	/** Distance of the far clipping plane from the camera.
	 *
	 * The far clipping plane must, of course, be further away than the
	 * near clipping plane. The default value is 1000.f. The ratio
	 * between the near and the far plane should not be too
	 * large (between 1000-10000 should be ok) to avoid floating-point
	 * inaccuracies which could lead to z-fighting.
	 */
	ClipPlaneFar float32

	/** Screen aspect ratio.
	 *
	 * This is the ration between the width and the height of the
	 * screen. Typical values are 4/3, 1/2 or 1/1. This value is
	 * 0 if the aspect ratio is not defined in the source file.
	 * 0 is also the default value.
	 */
	Aspect float32

	/** Half horizontal orthographic width, in scene units.
	 *
	 *  The orthographic width specifies the half width of the
	 *  orthographic view box. If non-zero the camera is
	 *  orthographic and the mAspect should define to the
	 *  ratio between the orthographic width and height
	 *  and mHorizontalFOV should be set to 0.
	 *  The default value is 0 (not orthographic).
	 */
	OrthographicWidth float32
}

type AiFace struct {
	//! Pointer to the indices array. Size of the array is given in numIndices.
	Indices []uint32
}

type AiImporterDesc struct {
	/** Full name of the importer (i.e. Blender3D importer)*/
	Name string

	/** Original author (left blank if unknown or whole assimp team) */
	Author string

	/** Current maintainer, left blank if the author maintains */
	Maintainer string

	/** Implementation comments, i.e. unimplemented features*/
	Comments string

	/** These flags indicate some characteristics common to many
	  importers. */
	Flags AiImporterFlags

	/** Minimum format version that can be loaded im major.minor format,
	  both are set to 0 if there is either no version scheme
	  or if the loader doesn't care. */
	MinMajor int
	MinMinor int

	/** Maximum format version that can be loaded im major.minor format,
	  both are set to 0 if there is either no version scheme
	  or if the loader doesn't care. Loaders that expect to be
	  forward-compatible to potential future format versions should
	  indicate  zero, otherwise they should specify the current
	  maximum version.*/
	MaxMajor int
	MaxMinor int

	/** List of file extensions this importer can handle.
	  List entries are separated by space characters.
	  All entries are lower case without a leading dot (i.e.
	  "xml dae" would be a valid value. Note that multiple
	  importers may respond to the same file extension -
	  assimp calls all importers in the order in which they
	  are registered and each importer gets the opportunity
	  to load the file until one importer "claims" the file. Apart
	  from file extension checks, importers typically use
	  other methods to quickly reject files (i.e. magic
	  words) so this does not mean that common or generic
	  file extensions such as XML would be tediously slow. */
	FileExtensions []string
	Magic          string
}

type AiImporterFlags int

type AiLight struct {
	/** The name of the light source.
	 *
	 *  There must be a node in the scene-graph with the same name.
	 *  This node specifies the position of the light in the scene
	 *  hierarchy and can be animated.
	 */
	Name string

	/** The type of the light source.
	 *
	 * aiLightSource_UNDEFINED is not a valid value for this member.
	 */
	Type AiLightSourceType

	/** Position of the light source in space. Relative to the
	 *  transformation of the node corresponding to the light.
	 *
	 *  The position is undefined for directional lights.
	 */
	Position *common.AiVector3D

	/** Direction of the light source in space. Relative to the
	 *  transformation of the node corresponding to the light.
	 *
	 *  The direction is undefined for point lights. The vector
	 *  may be normalized, but it needn't.
	 */
	Direction *common.AiVector3D

	/** Up direction of the light source in space. Relative to the
	 *  transformation of the node corresponding to the light.
	 *
	 *  The direction is undefined for point lights. The vector
	 *  may be normalized, but it needn't.
	 */
	Up *common.AiVector3D

	/** Constant light attenuation factor.
	 *
	 *  The intensity of the light source at a given distance 'd' from
	 *  the light's position is
	 *  @code
	 *  Atten = 1/( att0 + att1 * d + att2 * d*d)
	 *  @endcode
	 *  This member corresponds to the att0 variable in the equation.
	 *  Naturally undefined for directional lights.
	 */
	AttenuationConstant float32

	/** Linear light attenuation factor.
	 *
	 *  The intensity of the light source at a given distance 'd' from
	 *  the light's position is
	 *  @code
	 *  Atten = 1/( att0 + att1 * d + att2 * d*d)
	 *  @endcode
	 *  This member corresponds to the att1 variable in the equation.
	 *  Naturally undefined for directional lights.
	 */
	AttenuationLinear float32

	/** Quadratic light attenuation factor.
	 *
	 *  The intensity of the light source at a given distance 'd' from
	 *  the light's position is
	 *  @code
	 *  Atten = 1/( att0 + att1 * d + att2 * d*d)
	 *  @endcode
	 *  This member corresponds to the att2 variable in the equation.
	 *  Naturally undefined for directional lights.
	 */
	AttenuationQuadratic float32

	/** Diffuse color of the light source
	 *
	 *  The diffuse light color is multiplied with the diffuse
	 *  material color to obtain the final color that contributes
	 *  to the diffuse shading term.
	 */
	ColorDiffuse *common.AiColor3D

	/** Specular color of the light source
	 *
	 *  The specular light color is multiplied with the specular
	 *  material color to obtain the final color that contributes
	 *  to the specular shading term.
	 */
	ColorSpecular *common.AiColor3D

	/** Ambient color of the light source
	 *
	 *  The ambient light color is multiplied with the ambient
	 *  material color to obtain the final color that contributes
	 *  to the ambient shading term. Most renderers will ignore
	 *  this value it, is just a remaining of the fixed-function pipeline
	 *  that is still supported by quite many file formats.
	 */
	ColorAmbient *common.AiColor3D

	/** Inner angle of a spot light's light cone.
	 *
	 *  The spot light has maximum influence on objects inside this
	 *  angle. The angle is given in radians. It is 2PI for point
	 *  lights and undefined for directional lights.
	 */
	AngleInnerCone float32

	/** Outer angle of a spot light's light cone.
	 *
	 *  The spot light does not affect objects outside this angle.
	 *  The angle is given in radians. It is 2PI for point lights and
	 *  undefined for directional lights. The outer angle must be
	 *  greater than or equal to the inner angle.
	 *  It is assumed that the application uses a smooth
	 *  interpolation between the inner and the outer cone of the
	 *  spot light.
	 */
	AngleOuterCone float32

	/** Size of area light source. */
	Size *common.AiVector2D
}

type AiLightSourceType int

type AiMaterial struct {
	/** List of all material properties loaded. */
	Properties []*AiMaterialProperty
}

type AiMaterialProperty struct {
	/** Specifies the name of the property (key)
	 *  Keys are generally case insensitive.
	 */
	Key string

	/** Textures: Specifies their exact usage semantic.
	 * For non-texture properties, this member is always 0
	 * (or, better-said, #AiTextureType_NONE).
	 */
	Semantic uint32

	/** Textures: Specifies the index of the texture.
	 *  For non-texture properties, this member is always 0.
	 */
	Index uint32
	/** Type information for the property.
	 *
	 * Defines the data layout inside the data buffer. This is used
	 * by the library internally to perform debug checks and to
	 * utilize proper type conversions.
	 * (It's probably a hacky solution, but it works.)
	 */
	Type pb_msg.AiMaterialPropertyType
	Data []byte
}

type AiMesh struct {
	/**
	 * Bitwise combination of the members of the #AiPrimitiveType enum.
	 * This specifies which types of primitives are present in the mesh.
	 * The "SortByPrimitiveType"-Step can be used to make sure the
	 * output meshes consist of one primitive type each.
	 */
	PrimitiveTypes AiPrimitiveType
	/**
	 * @brief Vertex positions.
	 *
	 * This array is always present in a mesh. The array is
	 * mNumVertices in size.
	 */
	Vertices []*common.AiVector3D

	/**
	 * @brief Vertex normals.
	 *
	 * The array contains normalized vectors, nullptr if not present.
	 * The array is mNumVertices in size. Normals are undefined for
	 * point and line primitives. A mesh consisting of points and
	 * lines only may not have normal vectors. Meshes with mixed
	 * primitive types (i.e. lines and triangles) may have normals,
	 * but the normals for vertices that are only referenced by
	 * point or line primitives are undefined and set to QNaN (WARN:
	 * qNaN compares to inequal to *everything*, even to qNaN itself.
	 * Using code like this to check whether a field is qnan is:
	 * @code
	 * IS_QNAN(f) (f != f)
	 * @endcode
	 * still dangerous because even 1.f == 1.f could evaluate to false! (
	 * remember the subtleties of IEEE754 artithmetics). Use stuff like
	 * @c fpclassify instead.
	 * @note Normal vectors computed by Assimp are always unit-length.
	 * However, this needn't apply for normals that have been taken
	 * directly from the model file.
	 */
	Normals []*common.AiVector3D

	/**
	 * @brief Vertex tangents.
	 *
	 * The tangent of a vertex points in the direction of the positive
	 * X texture axis. The array contains normalized vectors, nullptr if
	 * not present. The array is mNumVertices in size. A mesh consisting
	 * of points and lines only may not have normal vectors. Meshes with
	 * mixed primitive types (i.e. lines and triangles) may have
	 * normals, but the normals for vertices that are only referenced by
	 * point or line primitives are undefined and set to qNaN.  See
	 * the #mNormals member for a detailed discussion of qNaNs.
	 * @note If the mesh contains tangents, it automatically also
	 * contains bitangents.
	 */
	Tangents []*common.AiVector3D

	/**
	 * @brief Vertex bitangents.
	 *
	 * The bitangent of a vertex points in the direction of the positive
	 * Y texture axis. The array contains normalized vectors, nullptr if not
	 * present. The array is mNumVertices in size.
	 * @note If the mesh contains tangents, it automatically also contains
	 * bitangents.
	 */
	Bitangents []*common.AiVector3D

	/**
	 * @brief Vertex color sets.
	 *
	 * A mesh may contain 0 to #AI_MAX_NUMBER_OF_COLOR_SETS vertex
	 * colors per vertex. nullptr if not present. Each array is
	 * mNumVertices in size if present.
	 */
	Colors [][]*common.AiColor4D

	/**
	 * @brief Vertex texture coordinates, also known as UV channels.
	 *
	 * A mesh may contain 0 to AI_MAX_NUMBER_OF_TEXTURECOORDS per
	 * vertex. nullptr if not present. The array is mNumVertices in size.
	 */
	TextureCoords [][]*common.AiVector3D

	/**
	 * @brief Specifies the number of components for a given UV channel.
	 *
	 * Up to three channels are supported (UVW, for accessing volume
	 * or cube maps). If the value is 2 for a given channel n, the
	 * component p.z of mTextureCoords[n][p] is set to 0.0f.
	 * If the value is 1 for a given channel, p.y is set to 0.0f, too.
	 * @note 4D coordinates are not supported
	 */
	NumUVComponents []uint32

	/**
	 * @brief The faces the mesh is constructed from.
	 *
	 * Each face refers to a number of vertices by their indices.
	 * This array is always present in a mesh, its size is given
	 *  in mNumFaces. If the #AI_SCENE_FLAGS_NON_VERBOSE_FORMAT
	 * is NOT set each face references an unique set of vertices.
	 */
	Faces []*AiFace
	/**
	 * @brief The bones of this mesh.
	 *
	 * A bone consists of a name by which it can be found in the
	 * frame hierarchy and a set of vertex weights.
	 */
	Bones []*AiBone

	/**
	 * @brief The material used by this mesh.
	 *
	 * A mesh uses only a single material. If an imported model uses
	 * multiple materials, the import splits up the mesh. Use this value
	 * as index into the scene's material list.
	 */
	MaterialIndex int32

	/**
	 *  Name of the mesh. Meshes can be named, but this is not a
	 *  requirement and leaving this field empty is totally fine.
	 *  There are mainly three uses for mesh names:
	 *   - some formats name nodes and meshes independently.
	 *   - importers tend to split meshes up to meet the
	 *      one-material-per-mesh requirement. Assigning
	 *      the same (dummy) name to each of the result meshes
	 *      aids the caller at recovering the original mesh
	 *      partitioning.
	 *   - Vertex animations refer to meshes by their names.
	 */
	Name string
	/**
	 * Attachment meshes for this mesh, for vertex-based animation.
	 * Attachment meshes carry replacement data for some of the
	 * mesh'es vertex components (usually positions, normals).
	 * Currently known to work with loaders:
	 * - Collada
	 * - gltf
	 */
	AnimMeshes []*AiAnimMesh

	/**
	 *  Method of morphing when anim-meshes are specified.
	 *  @see aiMorphingMethod to learn more about the provided morphing targets.
	 */
	Method AiMorphingMethod

	/**
	 *  The bounding box.
	 */
	AABB *AiAABB

	/**
	 * Vertex UV stream names. Pointer to array of size AI_MAX_NUMBER_OF_TEXTURECOORDS
	 */
	TextureCoordsNames []string
}

type AiMeshAnim struct {
	/** Name of the mesh to be animated. An empty string is not allowed,
	 *  animated meshes need to be named (not necessarily uniquely,
	 *  the name can basically serve as wild-card to select a group
	 *  of meshes with similar animation setup)*/
	Name string

	/** Key frames of the animation. May not be nullptr. */
	Keys []*AiMeshKey
}

type AiMeshKey struct {
	/** The time of this key */
	Time float64

	/** Index into the aiMesh::mAnimMeshes array of the
	 *  mesh corresponding to the #aiMeshAnim hosting this
	 *  key frame. The referenced anim mesh is evaluated
	 *  according to the rules defined in the docs for #aiAnimMesh.*/
	Value uint32
}

type AiMeshMorphAnim struct {
	/** Name of the mesh to be animated. An empty string is not allowed,
	 *  animated meshes need to be named (not necessarily uniquely,
	 *  the name can basically serve as wildcard to select a group
	 *  of meshes with similar animation setup)*/
	Name string
	/** Key frames of the animation. May not be nullptr. */
	Keys []*AiMeshMorphKey
}

type AiMeshMorphKey struct {
	/** The time of this key */
	Time float64

	/** The values and weights at the time of this key
	 *   - mValues: index of attachment mesh to apply weight at the same position in mWeights
	 *   - mWeights: weight to apply to the blend shape index at the same position in mValues
	 */
	Values  []uint32
	Weights []float64
}

type AiMetadata struct {
	/** Arrays of keys, may not be NULL. Entries in this array may not be NULL as well. */
	Keys []string

	/** Arrays of values, may not be NULL. Entries in this array may be NULL if the
	 * corresponding property key has no assigned value. */
	Values []*AiMetadataEntry
}

type AiMetadataEntry struct {
	Type AiMetadataType
	Data any
}

type AiMetadataType int

type AiMorphingMethod int

type AiNode struct {
	/** The name of the node.
	 *
	 * The name might be empty (length of zero) but all nodes which
	 * need to be referenced by either bones or animations are named.
	 * Multiple nodes may have the same name, except for nodes which are referenced
	 * by bones (see #aiBone and #aiMesh::mBones). Their names *must* be unique.
	 *
	 * Cameras and lights reference a specific node by name - if there
	 * are multiple nodes with this name, they are assigned to each of them.
	 * <br>
	 * There are no limitations with regard to the characters contained in
	 * the name string as it is usually taken directly from the source file.
	 *
	 * Implementations should be able to handle tokens such as whitespace, tabs,
	 * line feeds, quotation marks, ampersands etc.
	 *
	 * Sometimes assimp introduces new nodes not present in the source file
	 * into the hierarchy (usually out of necessity because sometimes the
	 * source hierarchy format is simply not compatible). Their names are
	 * surrounded by @verbatim <> @endverbatim e.g.
	 *  @verbatim<DummyRootNode> @endverbatim.
	 */
	Name string
	/** The transformation relative to the node's parent. */
	Transformation *common.AiMatrix4x4
	/** Parent node. nullptr if this node is the root node. */
	Parent *AiNode
	/** The child nodes of this node. nullptr if mNumChildren is 0. */
	Children []*AiNode
	/** The meshes of this node. Each entry is an index into the
	 * mesh list of the #aiScene.
	 */
	Meshes []int32
	/** Metadata associated with this node or nullptr if there is no metadata.
	 *  Whether any metadata is generated depends on the source file format. See the
	 * @link importer_notes @endlink page for more information on every source file
	 * format. Importers that don't document any metadata don't write any.
	 */
	MetaData *AiMetadata
}

type AiNodeAnim struct {
	/** The name of the node affected by this animation. The node
	 *  must exist and it must be unique.*/
	NodeName string

	/** The position keys of this animation channel. Positions are
	 * specified as 3D vector. The array is mNumPositionKeys in size.
	 *
	 * If there are position keys, there will also be at least one
	 * scaling and one rotation key.*/
	PositionKeys []*common.AiVectorKey
	/** The rotation keys of this animation channel. Rotations are
	 *  given as quaternions,  which are 4D vectors. The array is
	 *  mNumRotationKeys in size.
	 *
	 * If there are rotation keys, there will also be at least one
	 * scaling and one position key. */
	RotationKeys []*common.AiQuatKey
	/** The scaling keys of this animation channel. Scalings are
	 *  specified as 3D vector. The array is mNumScalingKeys in size.
	 *
	 * If there are scaling keys, there will also be at least one
	 * position and one rotation key.*/
	ScalingKeys []*common.AiVectorKey

	/** Defines how the animation behaves before the first
	 *  key is encountered.
	 *
	 *  The default value is aiAnimBehaviour_DEFAULT (the original
	 *  transformation matrix of the affected node is used).*/
	PreState AiAnimBehaviour

	/** Defines how the animation behaves after the last
	 *  key was processed.
	 *
	 *  The default value is aiAnimBehaviour_DEFAULT (the original
	 *  transformation matrix of the affected node is taken).*/
	PostState AiAnimBehaviour
}

type AiPrimitiveType int

type AiPropertyTypeInfo uint32

type AiScene struct {
	/** Any combination of the AI_SCENE_FLAGS_XXX flags. By default
	 * this value is 0, no flags are set. Most applications will
	 * want to reject all scenes with the AI_SCENE_FLAGS_INCOMPLETE
	 * bit set.
	 */
	Flags uint32

	/** The root node of the hierarchy.
	 *
	 * There will always be at least the root node if the import
	 * was successful (and no special flags have been set).
	 * Presence of further nodes depends on the format and content
	 * of the imported file.
	 */
	RootNode *AiNode
	/** The array of meshes.
	 *
	 * Use the indices given in the aiNode structure to access
	 * this array. The array is mNumMeshes in size. If the
	 * AI_SCENE_FLAGS_INCOMPLETE flag is not set there will always
	 * be at least ONE material.
	 */
	Meshes []*AiMesh
	/** The array of materials.
	 *
	 * Use the index given in each aiMesh structure to access this
	 * array. The array is mNumMaterials in size. If the
	 * AI_SCENE_FLAGS_INCOMPLETE flag is not set there will always
	 * be at least ONE material.
	 */
	Materials []*AiMaterial
	/** The array of animations.
	 *
	 * All animations imported from the given file are listed here.
	 * The array is mNumAnimations in size.
	 */
	Animations []*AiAnimation
	/** The array of embedded textures.
	 *
	 * Not many file formats embed their textures into the file.
	 * An example is Quake's MDL format (which is also used by
	 * some GameStudio versions)
	 */
	Textures []*AiTexture
	/** The array of light sources.
	 *
	 * All light sources imported from the given file are
	 * listed here. The array is mNumLights in size.
	 */
	Lights []*AiLight
	/** The array of cameras.
	 *
	 * All cameras imported from the given file are listed here.
	 * The array is mNumCameras in size. The first camera in the
	 * array (if existing) is the default camera view into
	 * the scene.
	 */
	Cameras []*AiCamera

	/**
	 *  @brief  The global metadata assigned to the scene itself.
	 *
	 *  This data contains global metadata which belongs to the scene like
	 *  unit-conversions, versions, vendors or other model-specific data. This
	 *  can be used to store format-specific metadata as well.
	 */
	MetaData []*AiMetadata

	/** The name of the scene itself.
	 */
	Name string
	/**
	 *
	 */
	Skeletons []*AiSkeleton
}

type AiShadingMode int

type AiSkeleton struct {
	/**
	 *  @brief The name of the skeleton instance.
	 */
	Name string
	/**
	 *  @brief The bone instance in the skeleton.
	 */
	Bones []*AiSkeletonBone
}

type AiSkeletonBone struct {
	/// The parent bone index, is -1 one if this bone represents the root bone.
	Parent int32
	/// @brief The bone armature node - used for skeleton conversion
	/// you must enable aiProcess_PopulateArmatureData to populate this
	Armature []*AiNode

	/// @brief The bone node in the scene - used for skeleton conversion
	/// you must enable aiProcess_PopulateArmatureData to populate this
	Node []*AiNode
	/// The mesh index, which will get influenced by the weight.
	MeshId []*AiMesh

	/// The influence weights of this bone, by vertex index.
	Weights []*common.AiVertexWeight

	/** Matrix that transforms from bone space to mesh space in bind pose.
	 *
	 * This matrix describes the position of the mesh
	 * in the local space of this bone when the skeleton was bound.
	 * Thus it can be used directly to determine a desired vertex position,
	 * given the world-space transform of the bone when animated,
	 * and the position of the vertex in mesh space.
	 *
	 * It is sometimes called an inverse-bind matrix,
	 * or inverse bind pose matrix.
	 */
	OffsetMatrix common.AiMatrix4x4

	/// Matrix that transforms the locale bone in bind pose.
	LocalMatrix common.AiMatrix4x4
}

type AiTexel struct {
	B, G, R, A uint8
}

type AiTexture struct {
	/** Width of the texture, in pixels
	 *
	 * If mHeight is zero the texture is compressed in a format
	 * like JPEG. In this case mWidth specifies the size of the
	 * memory area pcData is pointing to, in bytes.
	 */
	Width uint32

	/** Height of the texture, in pixels
	 *
	 * If this value is zero, pcData points to an compressed texture
	 * in any format (e.g. JPEG).
	 */
	Height uint32

	/** A hint from the loader to make it easier for applications
	 *  to determine the type of embedded textures.
	 *
	 * If mHeight != 0 this member is show how data is packed. Hint will consist of
	 * two parts: channel order and channel bitness (count of the bits for every
	 * color channel). For simple parsing by the viewer it's better to not omit
	 * absent color channel and just use 0 for bitness. For example:
	 * 1. Image contain RGBA and 8 bit per channel, achFormatHint == "rgba8888";
	 * 2. Image contain ARGB and 8 bit per channel, achFormatHint == "argb8888";
	 * 3. Image contain RGB and 5 bit for R and B channels and 6 bit for G channel, achFormatHint == "rgba5650";
	 * 4. One color image with B channel and 1 bit for it, achFormatHint == "rgba0010";
	 * If mHeight == 0 then achFormatHint is set set to '\\0\\0\\0\\0' if the loader has no additional
	 * information about the texture file format used OR the
	 * file extension of the format without a trailing dot. If there
	 * are multiple file extensions for a format, the shortest
	 * extension is chosen (JPEG maps to 'jpg', not to 'jpeg').
	 * E.g. 'dds\\0', 'pcx\\0', 'jpg\\0'.  All characters are lower-case.
	 * The fourth character will always be '\\0'.
	 */
	AchFormatHint []uint8 // 8 for string + 1 for terminator.

	/** Data of the texture.
	 *
	 * Points to an array of mWidth * mHeight aiTexel's.
	 * The format of the texture data is always ARGB8888 to
	 * make the implementation for user of the library as easy
	 * as possible. If mHeight = 0 this is a pointer to a memory
	 * buffer of size mWidth containing the compressed texture
	 * data. Good luck, have fun!
	 */
	PcData []*AiTexel

	/** Texture original filename
	 *
	 * Used to get the texture reference
	 */
	Filename string
}

type AiTextureFlags int

type AiTextureType int

type AiUVTransform struct {
	/** Translation on the u and v axes.
	 *
	 *  The default value is (0|0).
	 */
	Translation *common.AiVector2D

	/** Scaling on the u and v axes.
	 *
	 *  The default value is (1|1).
	 */
	Scaling *common.AiVector2D

	/** Rotation - in counter-clockwise direction.
	 *
	 *  The rotation angle is specified in radians. The
	 *  rotation center is 0.5f|0.5f. The default value
	 *  0.f.
	 */
	Rotation float32
}

type Algorithm int

type BinFloat uint64

type CatmullClarkSubdivider struct {
	EdgeMap    map[int]Edge
	UIntVector []int
}

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

type SpatialSort struct {
	/** Normal of the sorting plane, normalized.
	 */
	PlaneNormal common.AiVector3D

	/** The centroid of the positions, which is used as a point on the sorting plane
	 * when calculating distance. This value is calculated in Finalize.
	 */
	Centroid common.AiVector3D

	/** An entry in a spatially sorted position array. Consists of a vertex index,
	 * its position and its pre-calculated distance from the reference plane */
	// all positions, sorted by distance to the sorting plane
	Positions []*SpatialSortEntry

	/// false until the Finalize method is called.
	Finalized bool
}

type SpatialSortEntry struct {
	Index    int               ///< The vertex referred by this entry
	Position common.AiVector3D ///< Position
	/// Distance of this vertex to the sorting plane. This is set by Finalize.
	Distance float64
}

type SubDivision interface {
	// ---------------------------------------------------------------
	/** Create a subdivider of a specific type
	 *
	 *  @param algo Algorithm to be used for subdivision
	 *  @return Subdivider instance. */
	SubdivideOneMesh(mesh *AiMesh,
		num int,
		discard_input bool) *AiMesh
	Subdivide(smesh []*AiMesh,
		out []*AiMesh,
		num int,
		discard_input bool)
}

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