collada

type Accessor ¶

type Accessor struct {
	HasCount
	Stride int          `xml:"stride,attr"`
	Param  []*ParamCore `xml:"param"`
}

Accessor declares an access pattern to one of the array elements <float_array>, <int_array>, <Name_array>, <bool_array>, and <IDREF_array>.

type According ¶

type According struct {
}

According the Phong BRDF approximation.

type Alpha ¶

type Alpha struct {
}

type AmbientCore ¶

type AmbientCore struct {
}

AmbientCore (core) Describes an ambient light source.

type Animation ¶

type Animation struct {
}

Animation ategorizes the declaration of animation information.

type AnimationClip ¶

type AnimationClip struct {
}

AnimationClip defines a section of the animation curves to be used together as an animation clip.

type Annotate ¶

type Annotate struct {
}

Annotate Adds a strongly typed annotation remark to the parent object.

type Argument ¶

type Argument struct {
}

type Array ¶

type Array struct {
}

Array Creates a parameter of a one-dimensional array type.

type Asset ¶

type Asset struct {
	Contributor []*Contributor `xml:"contributor"`
	Coverage    *Coverage      `xml:"coverage"`
	Created     string         `xml:"created"`
	Keywords    string         `xml:"keywords,omitempty"`
	Modified    string         `xml:"modified"`
	Revision    string         `xml:"revision,omitempty"`
	Subject     string         `xml:"subject,omitempty"`
	Title       string         `xml:"title,omitempty"`
	Unit        *Unit          `xml:"unit"`
	UpAxis      UpAxis         `xml:"up_axis,omitempty"`
}

Asset defines asset-management information regarding its parent element.

type Binary ¶

type Binary struct {
}

Binary Identifies or provides a shader in binary form.

type BindAttribute ¶

type BindAttribute struct {
}

BindAttribute Binds semantics to vertex attribute inputs of a shader.

type BindMaterial ¶

type BindMaterial struct {
	Param []*ParamCore `xml:"param"`
	HasTechniqueCommon
	HasTechnique
	HasExtra
}

BindMaterial Binds a specific material to a piece of geometry, binding varying and uniform parameters at the same time.

type BindUniform ¶

type BindUniform struct {
}

BindUniform Binds values to uniform inputs of a shader or binds values to effect parameters upon instantiation.

type BindVertexInput ¶

type BindVertexInput struct {
}

BindVertexInput Binds geometry vertex inputs to effect vertex inputs upon instantiation.

type Blinn ¶

type Blinn struct {
}

type BoolArray ¶

type BoolArray struct {
	HasCount
	HasId
	HasName
	Bools
}

BoolArray declares the storage for a homogenous array of Boolean values.

type Bools ¶

type Bools struct {
	Values
}

type Camera ¶

type Camera struct {
	HasId
	HasName
	HasAsset
	Optics Optics  `xml:"optics"`
	Imager *Imager `xml:"imager"`
	HasExtra
}

Camera declares a view into the scene hierarchy or scene graph. The camera contains elements that describe the camera’s optics and imager.

type Channel ¶

type Channel struct {
}

Channel declares an output channel of an animation.

type Code ¶

type Code struct {
}

Code Provides an inline block of source code.

type Collada ¶

type Collada struct {
	XMLName string  `xml:"COLLADA"`
	Xmlns   Uri     `xml:"xmlns,attr,omitempty"`
	Version Version `xml:"version,attr"`
	Base    Uri     `xml:"base,attr,omitempty"`
	HasAsset
	LibraryAnimationClips []*LibraryAnimationClips `xml:"library_animation_clips"`
	LibraryAnimations     []*LibraryAnimations     `xml:"library_animations"`
	// LibraryArticulatedSystems []*LibraryArticulatedSystems `xml:"library_animation_clips"`
	LibraryCameras     []*LibraryCameras     `xml:"library_cameras"`
	LibraryControllers []*LibraryControllers `xml:"library_controllers"`
	LibraryLights      []*LibraryLights      `xml:"library_lights"`
	LibraryImages      []*LibraryImages      `xml:"library_images"`
	LibraryEffects     []*LibraryEffects     `xml:"library_effects"`
	// LibraryForceFields []*LibraryForceFields `xml:"library_force_fields"`
	LibraryFormulas []*LibraryFormulas `xml:"library_formulas"`
	// LibraryJoints []*LibraryJoints `xml:"library_joints"`
	// LibraryKinematicModels []*LibraryKinematicModels `xml:"library_kinematic_models"`
	// LibraryKinematicScenes []*LibraryKinematicScenes `xml:"library_kinematic_scenes"`
	LibraryMaterials  []*LibraryMaterials  `xml:"library_materials"`
	LibraryGeometries []*LibraryGeometries `xml:"library_geometries"`
	// LibraryPhysicsNodes []*LibraryPhysicsNodes `xml:"library_physics_nodes"`
	// LibraryPhysicsMaterials []*LibraryPhysicsMaterials `xml:"library_physics_materials"`
	// LibraryPhysicsScenes []*LibraryPhysicsScenes `xml:"library_physics_scenes"`
	// LibraryPhysicsScenes []*LibraryPhysicsScenes `xml:"library_physics_scenes"`
	LibraryVisualScenes []*LibraryVisualScenes `xml:"library_visual_scenes"`
	Scene               *Scene                 `xml:"scene"`
	HasExtra
}

COLLADA declares the root of the document that contains some of the content in the COLLADA schema.

func LoadDocument(filename string) (*Collada, error)

func LoadDocumentFromReader(reader io.Reader) (*Collada, error)

func (collada *Collada) Export(filename string) error

func (collada *Collada) ExportToWriter(writer io.Writer) error

type Color ¶

type Color struct {
	HasSid
	Float3
}

Color describes the color of its parent light element.

type ColorClear ¶

type ColorClear struct {
}

type ColorTarget ¶

type ColorTarget struct {
}

type Compiler ¶

type Compiler struct {
}

Compiler Contains command-line or runtime-invocation options for a shader compiler.

type ConstantFx ¶

type ConstantFx struct {
}

Constant Produces a constantly shaded surface that is independent of lighting.

type Contributor ¶

type Contributor struct {
	Author        string `xml:"author,omitempty"`
	AuthorEmail   string `xml:"author_email,omitempty"`
	AuthorWebsite string `xml:"author_website,omitempty"`
	AuthoringTool string `xml:"authoring_tool,omitempty"`
	Comments      string `xml:"comments,omitempty"`
	Copyright     string `xml:"copyright,omitempty"`
	SourceData    Uri    `xml:"source_data,omitempty"`
}

Contributor defines authoring information for asset management.

type ControlVertices ¶

type ControlVertices struct {
}

ControlVertices describes the control vertices (CVs) of a spline.

type Controller ¶

type Controller struct {
}

Controller categorizes the declaration of generic control information.

type Coverage ¶

type Coverage struct {
	GeographicLocation []*GeographicLocation `xml:"geographic_location"`
}

Coverage provides information about the location of the visual scene in physical space.

type Create2d ¶

type Create2d struct {
}

type Create3d ¶

type Create3d struct {
}

type CreateCube ¶

type CreateCube struct {
}

type DepthClear ¶

type DepthClear struct {
}

DepthClear Specifies whether a render target image is to be cleared, and which value to use.

type DepthTarget ¶

type DepthTarget struct {
}

DepthTarget Specifies which <image> will receive the depth information from the output of this pass.

type Directional ¶

type Directional struct {
}

Directional describes a directional light source.

type Draw ¶

type Draw struct {
}

Draw Instructs the FX Runtime what kind of geometry to submit.

type Effect ¶

type Effect struct {
	HasId
	HasName
	HasAsset
	HasAnnotate
	HasNewparam
	ProfileBridge *ProfileBridge `xml:"profile_BRIDGE"`
	ProfileCg     *ProfileCg     `xml:"profile_CG"`
	ProfileGles   *ProfileGles   `xml:"profile_GLES"`
	ProfileGles2  *ProfileGles2  `xml:"profile_GLES2"`
	ProfileGlsl   *ProfileGlsl   `xml:"profile_GLSL"`
	ProfileCommon *ProfileCommon `xml:"profile_COMMON"`
	HasExtra
}

Effect Provides a self-contained description of a COLLADA effect.

type Evaluate ¶

type Evaluate struct {
}

Evaluate Contains evaluation elements for a rendering pass.

type EvaluateScene ¶

type EvaluateScene struct {
}

EvaluateScene declares information specifying how to evaluate a <visual_scene>.

type Extra ¶

type Extra struct {
	HasId
	HasName
	HasType
	HasAsset
	HasTechnique
}

Extra provides arbitrary additional information about or related to its parent element.

type Float ¶

type Float struct {
	HasSid
	Value float64 `xml:",chardata"`
}

type Float3 ¶

type Float3 struct {
	Floats
}

type Float3x3 ¶

type Float3x3 struct {
	Floats
}

type Float4 ¶

type Float4 struct {
	Floats
}

type Float4x4 ¶

type Float4x4 struct {
	Floats
}

type FloatArray ¶

type FloatArray struct {
	HasId
	HasCount
	HasName
	Digits    uint8  `xml:"digits,attr,omitempty"`
	Magnitude uint16 `xml:"magnitude,attr,omitempty"`
	Floats
}

FloatArray declares the storage for a homogenous array of floating-point values.

type Floats ¶

type Floats struct {
	Values
}

func (floats *Floats) F() []float64

func (floats *Floats) F32() []float32

type Format ¶

type Format struct {
}

type Formula ¶

type Formula struct {
}

Formula defines a formula.

type FxCommonColorOrTextureType ¶

type FxCommonColorOrTextureType struct {
	Opaque  Opaque          `xml:"opaque,attr,omitempty"`
	Color   *Color          `xml:"color"`
	Param   *ParamReference `xml:"param"`
	Texture *Texture        `xml:"texture"`
}

A type that describes color attributes of fixed-function shader elements

type FxCommonFloatOrParamType ¶

type FxCommonFloatOrParamType struct {
	Float *Float          `xml:"float"`
	Param *ParamReference `xml:"param"`
}

A type that describes the scalar attributes of fixed-function shader elements inside <profile_COMMON> effects. See main entry.

type FxSamplerCommon ¶

type FxSamplerCommon struct {
}

type GeographicLocation ¶

type GeographicLocation struct {
}

GeographicLocation defines an asset’s location for asset management.

type Geometry ¶

type Geometry struct {
	HasId
	HasName
	HasAsset
	//TODO
	// ConvexMesh *ConvexMesh `xml:"convex_mesh"`
	Mesh   *Mesh   `xml:"mesh"`
	Spline *Spline `xml:"spline"`
	//TODO
	// Brep *Brep `xml:"brep"`
	HasExtra
}

Geometry describes the visual shape and appearance of an object in a scene.

type H ¶

type H Ints

type HasAnnotate ¶

type HasAnnotate struct {
	Annotate []*Annotate `xml:"annotate"`
}

type HasAsset ¶

type HasAsset struct {
	Asset *Asset `xml:"asset,omitempty"`
}

type HasCount ¶

type HasCount struct {
	Count int `xml:"count,attr,omitempty"`
}

type HasExtra ¶

type HasExtra struct {
	Extra []*Extra `xml:"extra"`
}

type HasId ¶

type HasId struct {
	Id Id `xml:"id,attr,omitempty"`
}

type HasMaterial ¶

type HasMaterial struct {
	Material string `xml:"material,attr,omitempty"`
}

type HasName ¶

type HasName struct {
	Name string `xml:"name,attr,omitempty"`
}

type HasNewparam ¶

type HasNewparam struct {
	Newparam []*Newparam `xml:"newparam"`
}

type HasNodes ¶

type HasNodes struct {
	Node []*Node `xml:"node"`
}

type HasP ¶

type HasP struct {
	P *P `xml:"p"`
}

type HasPhs ¶

type HasPhs struct {
	Ph []*Ph `xml:"ph"`
}

type HasPs ¶

type HasPs struct {
	P []*P `xml:"p"`
}

type HasSharedInput ¶

type HasSharedInput struct {
	Input []*InputShared `xml:"input"`
}

type HasSid ¶

type HasSid struct {
	Sid string `xml:"sid,attr,omitempty"`
}

type HasTechnique ¶

type HasTechnique struct {
	TechniqueCore []*TechniqueCore `xml:"technique,omitempty"`
}

type HasTechniqueCommon ¶

type HasTechniqueCommon struct {
	TechniqueCommon TechniqueCommon `xml:"technique_common"`
}

type HasTechniqueFx ¶

type HasTechniqueFx struct {
	TechniqueFx []*TechniqueFx `xml:"technique,omitempty"`
}

type HasType ¶

type HasType struct {
	Type string `xml:"type,attr,omitempty"`
}

type HasUrl ¶

type HasUrl struct {
	Url Uri `xml:"url,attr,omitempty"`
}

type Id ¶

type Id string

type IdRefArray ¶

type IdRefArray struct {
	HasCount
	HasId
	HasName
	IdRefs
}

IdRefArray declares the storage for a homogenous array of ID reference values.

type IdRefs ¶

type IdRefs struct {
	Values
}

type Image ¶

type Image struct {
}

type Imager ¶

type Imager struct {
	HasTechnique
	HasExtra
}

Imager represents the image sensor of a camera (for example, film or CCD).

type Include ¶

type Include struct {
}

Include Imports source code or precompiled binary shaders into the FX Runtime by referencing an external resource.

type InitFrom ¶

type InitFrom struct {
}

type InputShared ¶

type InputShared struct {
	Offset   uint   `xml:"offset,attr"`
	Semantic string `xml:"semantic,attr"`
	Source   Uri    `xml:"source,attr"`
	Set      uint   `xml:"set,attr,omitempty"`
}

InputShared declares the input semantics of a data source.

type InputUnshared ¶

type InputUnshared struct {
	Semantic string `xml:"semantic,attr"`
	Source   Uri    `xml:"source,attr"`
}

InputUnshared declares the input semantics of a data source.

type InstanceAnimation ¶

type InstanceAnimation struct {
}

InstanceAnimation instantiates a COLLADA animation resource.

type InstanceCamera ¶

type InstanceCamera struct {
	HasSid
	HasName
	HasUrl
	HasExtra
}

InstanceCamera instantiates a COLLADA camera resource.

type InstanceController ¶

type InstanceController struct {
	HasSid
	HasName
	HasUrl
	Skeleton     []*Skeleton   `xml:"skeleton"`
	BindMaterial *BindMaterial `xml:"bind_material"`
	HasExtra
}

InstanceController instantiates a a COLLADA controller resource.

type InstanceEffect ¶

type InstanceEffect struct {
	HasId
	HasName
	HasUrl
	TechniqueHint []*TechniqueHint `xml:"technique_hint"`
	Setparam      []*Setparam      `xml:"setparam"`
}

InstanceEffect Instantiates a COLLADA effect.

type InstanceFormula ¶

type InstanceFormula struct {
}

InstanceFormula instantiates a COLLADA formula resource.

type InstanceGeometry ¶

type InstanceGeometry struct {
	HasSid
	HasName
	HasUrl
	BindMaterial *BindMaterial `xml:"bind_material"`
	HasExtra
}

InstanceGeometry instantiates a COLLADA geometry resource.

type InstanceImage ¶

type InstanceImage struct {
}

type InstanceKinematicsScene ¶

type InstanceKinematicsScene struct {
}

type InstanceLight ¶

type InstanceLight struct {
	HasSid
	HasName
	HasUrl
	HasExtra
}

InstanceLight instantiates a COLLADA light resource.

type InstanceMaterial ¶

type InstanceMaterial struct {
	Symbol string `xml:"symbol,attr"`
	Target string `xml:"target,attr"`
}

type InstanceMaterialGeometry ¶

type InstanceMaterialGeometry struct {
}

InstanceMaterialGeometry Instantiates a COLLADA material resource.

type InstanceMaterialRendering ¶

type InstanceMaterialRendering struct {
}

InstanceMaterialRendering Instantiates a COLLADA material resource for a screen effect.

type InstanceNode ¶

type InstanceNode struct {
	HasSid
	HasName
	HasUrl
	Proxy Uri `xml:"proxy,attr,omitempty"`
	HasExtra
}

InstanceNode instantiates a COLLADA node resource.

type InstancePhysicsScene ¶

type InstancePhysicsScene struct {
}

type InstanceVisualScene ¶

type InstanceVisualScene struct {
	HasSid
	HasName
	HasUrl
	HasExtra
}

InstanceVisualScene instantiates a COLLADA visual_scene resource.

type IntArray ¶

type IntArray struct {
	HasCount
	HasId
	HasName
	MinInclusive *int `xml:"minInclusive,attr"`
	MaxInclusive *int `xml:"maxInclusive,attr"`
	Ints
}

IntArray stores a homogenous array of integer values.

type Ints ¶

type Ints struct {
	Values
}

func (ints *Ints) I() []int

type Joints ¶

type Joints struct {
}

Joints associates joint, or skeleton, nodes with attribute data.

type Lambert ¶

type Lambert struct {
}

Lambert Produces a diffuse shaded surface that is independent of lighting.

type LibraryAnimationClips ¶

type LibraryAnimationClips struct {
}

LibraryAnimationClips provides a library in which to place <animation_clip> elements.

type LibraryAnimations ¶

type LibraryAnimations struct {
}

LibraryAnimations provides a library in which to place <animation> elements.

type LibraryCameras ¶

type LibraryCameras struct {
	HasId
	HasName
	HasAsset
	Camera []*Camera `xml:"camera"`
	HasExtra
}

Provides a library in which to place <camera> elements.

type LibraryControllers ¶

type LibraryControllers struct {
}

LibraryControllers provides a library in which to place <controller> elements.

type LibraryEffects ¶

type LibraryEffects struct {
	HasId
	HasName
	HasAsset
	Effect []*Effect `xml:"effect"`
	HasExtra
}

LibraryEffects Provides a library in which to place <effect> assets.

type LibraryFormulas ¶

type LibraryFormulas struct {
}

LibraryFormulas provides a library in which to place <formula> elements.

type LibraryGeometries ¶

type LibraryGeometries struct {
	HasId
	HasName
	HasAsset
	Geometry []*Geometry `xml:"geometry"`
	HasExtra
}

LibraryGeometries provides a library in which to place <geometry> elements.

type LibraryImages ¶

type LibraryImages struct {
}

type LibraryLights ¶

type LibraryLights struct {
	HasId
	HasName
	HasAsset
	Light []*Light `xml:"light"`
	HasExtra
}

LibraryLights provides a library in which to place <image> elements.

type LibraryMaterials ¶

type LibraryMaterials struct {
	HasId
	HasName
	HasAsset
	Material []*Material `xml:"material"`
	HasExtra
}

LibraryMaterials Provides a library in which to place <material> assets.

type LibraryNodes ¶

type LibraryNodes struct {
}

LibraryNodes provides a library in which to place <node> elements.

type LibraryVisualScenes ¶

type LibraryVisualScenes struct {
	HasId
	HasName
	HasAsset
	VisualScene []*VisualScene `xml:"visual_scene"`
	HasExtra
}

LibraryVisualScenes provides a library in which to place <visual_scene> elements.

type Light ¶

type Light struct {
	HasId
	HasName
	HasAsset
	HasTechniqueCommon
	HasTechnique
	HasExtra
}

Light declares a light source that illuminates a scene.

type Lines ¶

type Lines struct {
	HasName
	HasCount
	HasMaterial
	HasSharedInput
	HasP
	HasExtra
}

Lines declares the binding of geometric primitives and vertex attributes for a <mesh>element.

type Linestrips ¶

type Linestrips struct {
	HasName
	HasCount
	HasMaterial
	HasSharedInput
	HasPs
	HasExtra
}

Linestrips declares a binding of geometric primitives and vertex attributes for a <mesh>element.

type Linker ¶

type Linker struct {
}

Linker Contains command-line or runtime-invocation options for shader linkers to combine shaders into programs.

type Lookat ¶

type Lookat struct {
	HasSid
	Float3x3
}

Lookat contains a position and orientation transformation suitable for aiming a camera.

type Material ¶

type Material struct {
	HasId
	HasName
	HasAsset
	InstanceEffect InstanceEffect `xml:"instance_effect"`
	HasExtra
}

Material Defines the equations necessary for the visual appearance of geometry and screenspace image processing

type Matrix ¶

type Matrix struct {
	HasSid
	Float4x4
}

Matrix describes transformations that embody mathematical changes to points within a coordinate system or the coordinate system itself.

type Mesh ¶

type Mesh struct {
	Source     []*Source     `xml:"source"`
	Vertices   Vertices      `xml:"vertices"`
	Lines      []*Lines      `xml:"lines"`
	Linestrips []*Linestrips `xml:"linestrips"`
	Polygons   []*Polygons   `xml:"polygons"`
	Polylist   []*Polylist   `xml:"polylist"`
	Triangles  []*Triangles  `xml:"triangles"`
	Trifans    []*Trifans    `xml:"trifans"`
	Tristrips  []*Tristrips  `xml:"tristrips"`
	HasExtra
}

Mesh describes basic geometric meshes using vertex and primitive information.

type Modifier ¶

type Modifier struct {
}

Modifier Provides additional information about the volatility or linkage of a <newparam>declaration.

type Morph ¶

type Morph struct {
}

Morph describes the data required to blend between sets of static meshes.

type NameArray ¶

type NameArray struct {
	HasCount
	HasId
	HasName
	Names
}

NameArray stores a homogenous array of symbolic name values.

type Names ¶

type Names struct {
	Values
}

type Newparam ¶

type Newparam struct {
}

Newparam Creates a new, named parameter object and assigns it a type and an initial value. See Chapter 5: Core Elements Reference.

type Node ¶

type Node struct {
	HasId
	HasName
	HasSid
	HasType
	Layer string `xml:"layer,attr,omitempty"`
	HasAsset
	Lookat             []*Lookat             `xml:"lookat"`
	Matrix             []*Matrix             `xml:"matrix"`
	Translate          []*Translate          `xml:"translate"`
	Rotate             []*Rotate             `xml:"rotate"`
	Scale              []*Scale              `xml:"scale"`
	Skew               []*Skew               `xml:"skew"`
	InstanceCamera     []*InstanceCamera     `xml:"instance_camera"`
	InstanceController []*InstanceController `xml:"instance_controller"`
	InstanceGeometry   []*InstanceGeometry   `xml:"instance_geometry"`
	InstanceLight      []*InstanceLight      `xml:"instance_light"`
	InstanceNode       []*InstanceNode       `xml:"instance_node"`
	HasNodes
	HasExtra
}

Node embodies the hierarchical relationship of elements in a scene.

func (node *Node) HasGeometry() bool

type Opaque ¶

type Opaque string

type Optics ¶

type Optics struct {
	HasTechniqueCommon
	HasTechnique
	HasExtra
}

Optics represents the apparatus on a camera that projects the image onto the image sensor.

type Orthographic ¶

type Orthographic struct {
}

Orthographic describes the field of view of an orthographic camera.

type P ¶

type P struct {
	Ints
}

type ParamCore ¶

type ParamCore struct {
	HasName
	HasType
}

ParamCore declares parametric information for its parent element.

type ParamReference ¶

type ParamReference struct {
}

ParamReference (reference) References a predefined parameter. See Chapter 5: Core Elements Reference.

type Pass ¶

type Pass struct {
}

Pass Provides a static declaration of all the render states, shaders, and settings for one rendering pipeline.

type Perspective ¶

type Perspective struct {
}

Perspective describes the field of view of a perspective camera.

type Ph ¶

type Ph struct {
	P P    `xml:"p"`
	H []*H `xml:"h"`
}

type Phong ¶

type Phong struct {
	Emission          *FxCommonColorOrTextureType `xml:"emission"`
	AmbientFx         *FxCommonColorOrTextureType `xml:"ambient"`
	Diffuse           *FxCommonColorOrTextureType `xml:"diffuse"`
	Specular          *FxCommonColorOrTextureType `xml:"specular"`
	Shininess         *FxCommonFloatOrParamType   `xml:"shininess"`
	Reflective        *FxCommonColorOrTextureType `xml:"reflective"`
	Reflectivity      *FxCommonFloatOrParamType   `xml:"reflectivity"`
	Transparent       *FxCommonColorOrTextureType `xml:"transparent"`
	Transparency      *FxCommonFloatOrParamType   `xml:"transparency"`
	IndexOfRefraction *FxCommonFloatOrParamType   `xml:"index_of_refraction"`
}

Phong Produces a shaded surface where the specular reflection is shaded

type Point ¶

type Point struct {
}

Point describes a point light source.

type Polygons ¶

type Polygons struct {
	HasName
	HasCount
	HasMaterial
	HasSharedInput
	HasPs
	HasPhs
	HasExtra
}

Polygons declares the binding of geometric primitives and vertex attributes for a <mesh>element.

type Polylist ¶

type Polylist struct {
	HasName
	HasCount
	HasMaterial
	HasSharedInput
	VCount *Ints `xml:"vcount"`
	HasP
	HasExtra
}

Polylist declares the binding of geometric primitives and vertex attributes for a <mesh>element.

type ProfileBridge ¶

type ProfileBridge struct {
	HasId
	HasAsset
	HasNewparam
}

ProfileBridge Provides support for referencing effect profiles written with external standards.

type ProfileCg ¶

type ProfileCg struct {
}

ProfileCg Declares a platform-specific representation of an effect written in the NVIDIA®Cg language.

type ProfileCommon ¶

type ProfileCommon struct {
	HasId
	HasAsset
	HasNewparam
	HasTechniqueFx
	HasExtra
}

ProfileCommon Opens a block of platform-independent declarations for the common, fixed-function shader.

type ProfileGles ¶

type ProfileGles struct {
}

type ProfileGles2 ¶

type ProfileGles2 struct {
}

type ProfileGlsl ¶

type ProfileGlsl struct {
}

type Program ¶

type Program struct {
}

Program Links multiple shaders together to produce a pipeline for geometry processing.

type Render ¶

type Render struct {
}

Render Describes one effect pass to evaluate a scene.

type Rgb ¶

type Rgb struct {
}

type Rotate ¶

type Rotate struct {
	HasSid
	Float4
}

Rotate specifies how to rotate an object around an axis.

type Sampler ¶

type Sampler struct {
}

Sampler declares an interpolation sampling function for an animation.

type Sampler1D ¶

type Sampler1D struct {
}

type Sampler2D ¶

type Sampler2D struct {
}

type Sampler3D ¶

type Sampler3D struct {
}

type SamplerCube ¶

type SamplerCube struct {
}

type SamplerDepth ¶

type SamplerDepth struct {
}

type SamplerRect ¶

type SamplerRect struct {
}

type SamplerStates ¶

type SamplerStates struct {
}

SamplerStates Allows users to modify an effect’s sampler state from a material.

type Scale ¶

type Scale struct {
	HasSid
	Float3
}

Scale specifies how to change an object’s size.

type Scene ¶

type Scene struct {
	InstancePhysicsScene    []*InstancePhysicsScene  `xml:"instance_physics_scene"`
	InstanceVisualScene     *InstanceVisualScene     `xml:"instance_visual_scene"`
	InstanceKinematicsScene *InstanceKinematicsScene `xml:"instance_kinematics_scene"`
	HasExtra
}

Scene embodies the entire set of information that can be visualized from the contents of a COLLADA resource.

type Semantic ¶

type Semantic struct {
}

Semantic Provides metadata that describes the purpose of a parameter declaration.

type Setparam ¶

type Setparam struct {
	Ref string `xml:"ref,attr"`
}

Setparam Assigns a new value to a previously defined parameter. See main entry in Chapter 5: Core Elements Reference.

type Shader ¶

type Shader struct {
}

type SidRefArray ¶

type SidRefArray struct {
	HasCount
	HasId
	HasName
	SidRefs
}

SidRefArray declares the storage for a homogenous array of scoped-identifier reference values.

type SidRefs ¶

type SidRefs struct {
	Values
}

type Skeleton ¶

type Skeleton struct {
}

Skeleton indicates where a skin controller is to start searching for the joint nodes that it needs.

type Skew ¶

type Skew struct {
	HasSid
	Float3
}

Skew specifies how to deform an object along one axis.

type Skin ¶

type Skin struct {
}

Skin contains vertex and primitive information sufficient to describe blend-weight skinning.

type Source ¶

type Source struct {
	HasId
	HasName
	HasAsset
	BoolArray   *BoolArray   `xml:"bool_array"`
	FloatArray  *FloatArray  `xml:"float_array"`
	IdRefArray  *IdRefArray  `xml:"IDREF_array"`
	IntArray    *IntArray    `xml:"int_array"`
	NameArray   *NameArray   `xml:"Name_array"`
	SidRefArray *SidRefArray `xml:"SIDREF_array"`
	// TokenArray *TokenArray `xml:"token_array"`
	HasTechniqueCommon
	HasTechnique
}

Source declares a data repository that provides values according to the semantics of an <input> element that refers to it.

type Sources ¶

type Sources struct {
}

type Spline ¶

type Spline struct {
}

Spline describes a multisegment spline with control vertex (CV) and segment information.

type Spot ¶

type Spot struct {
}

Spot describes a spot light source.

type States ¶

type States struct {
}

States Contains all rendering states to set up for the parent pass.

type StencilClear ¶

type StencilClear struct {
}

StencilClear Specifies whether a render target image is to be cleared, and which value to use.

type StencilTarget ¶

type StencilTarget struct {
}

StencilTarget Specifies which <image> will receive the stencil information from the output of this pass

type Targets ¶

type Targets struct {
}

Targets teclares morph targets, their weights, and any user-defined attributes associated with them.

type TechniqueCommon ¶

type TechniqueCommon struct {
	XML              string            `xml:",innerxml"`
	Accessor         *Accessor         `xml:"accessor"`
	InstanceMaterial *InstanceMaterial `xml:"instance_material"`
	Param            []*ParamCore      `xml:"param"`
}

TechniqueCommon specifies the information for a specific element for the common profile that all COLLADA implementations must support.

type TechniqueCore ¶

type TechniqueCore struct {
	Profile string `xml:"profile,attr"`
	Xmlns   string `xml:"xmlns,attr,omitempty"`
	XML     string `xml:",innerxml"`
}

Technique (core) Declares the information used to process some portion of the content. Each technique conforms to an associated profile.

type TechniqueFx ¶

type TechniqueFx struct {
	HasId
	HasSid
	HasAsset
	HasAnnotate
	Blinn      *Blinn      `xml:"blinn"`
	ConstantFx *ConstantFx `xml:"constant"`
	Lambert    *Lambert    `xml:"lambert"`
	Phong      *Phong      `xml:"phong"`
	Pass       *Pass       `xml:"pass"`
	HasExtra
}

TechniqueFx Holds a description of the textures, samplers, shaders, parameters, and passes necessary for rendering this effect using one method.

type TechniqueHint ¶

type TechniqueHint struct {
	Platform string `xml:"platform,attr,omitempty"`
	Ref      string `xml:"ref,attr"`
	Profile  string `xml:"profile,attr,omitempty"`
}

TechniqueHint Adds a hint for a platform of which technique to use in this effect

type Texcombiner ¶

type Texcombiner struct {
}

type Texenv ¶

type Texenv struct {
}

type Texture ¶

type Texture struct {
	Texture  string `xml:"texture,attr"`
	TexCoord string `xml:"texcoord,attr"`
	HasExtra
}

type TexturePipeline ¶

type TexturePipeline struct {
}

TexturePipeline Defines a set of texturing commands that will be converted into multitexturing operations using glTexEnv in regular and combiner mode.

type Tokens ¶

type Tokens struct {
	Values
}

type Translate ¶

type Translate struct {
	HasSid
	Float3
}

Translate changes the position of an object in a coordinate system without any rotation.

type Triangles ¶

type Triangles struct {
	HasName
	HasCount
	HasMaterial
	HasSharedInput
	HasP
	HasExtra
}

Triangles provides the information needed to bind vertex attributes together and then organize those vertices into individual triangles.

type Trifans ¶

type Trifans struct {
	HasName
	HasCount
	HasMaterial
	HasSharedInput
	HasP
	HasExtra
}

Trifans provides the information needed to bind vertex attributes together and then organize those vertices into connected triangles.

type Tristrips ¶

type Tristrips struct {
	HasName
	HasCount
	HasMaterial
	HasSharedInput
	HasP
	HasExtra
}

Tristrips provides the information needed to bind vertex attributes together and then organize those vertices into connected triangles

type Unit ¶

type Unit struct {
	HasName
	Meter float64 `xml:"meter,attr"`
}

Unit defines unit of distance for COLLADA elements and objects.

type UpAxis ¶

type UpAxis string

const (
	Xup UpAxis = "X_UP"
	Yup UpAxis = "Y_UP"
	Zup UpAxis = "Z_UP"
)

type Uri ¶

type Uri string

func (uri *Uri) Id() (Id, bool)

type Usertype ¶

type Usertype struct {
}

Usertype Creates an instance of a structured class for a parameter.

type Values ¶

type Values struct {
	V string `xml:",chardata"`
}

func (values *Values) Components() []string

type Version ¶

type Version string

const (
	Version1_5_0 Version = "1.5.0"
)

type VertexWeights ¶

type VertexWeights struct {
}

VertexWeights describes the combination of joints and weights used by a skin.

type Vertices ¶

type Vertices struct {
	HasId
	HasName
	Input []*InputUnshared `xml:"input"`
	HasExtra
}

Vertices declares the attributes and identity of mesh-vertices.

type VisualScene ¶

type VisualScene struct {
	HasId
	HasName
	HasAsset
	HasNodes
	EvaluateScene []*EvaluateScene `xml:"evaluate_scene"`
	HasExtra
}

VisualScene embodies the entire set of information that can be visualized from the contents of a COLLADA resource.