collada

package module
Version: v0.0.0-...-3911290 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Sep 26, 2013 License: MIT Imports: 7 Imported by: 0

README

go-collada

A Go package for working with Collada V1.5 (*.dae) documents.

See Collada 1.5 Specification http://www.khronos.org/files/collada_spec_1_5.pdf

IMPORTANT

Currently, not all of the schema has been completed, classes with TODO annotated in the struct definition imply that there is content missing

TESTING

The package test suit validates the correctness of the schema by importing/exporting and comparing against an external collada document.

More complex scenes can be added to the test suite to validate completness of the implementation

KNOWN ISSUES

  • Partially Complete Schema

Only a subset of all classes have complete definitions, this will cause the importer to ignore xml which do not match the struct definitions

  • Order of anonymous arrays

In the Node struct, a sequence of transform operations with a strict order is defined, however due to the nature of the golang xml unmarshal decoder, this ordering is lost.

Possible solutions invlove manually parsing the node content, but this will add significant complexity to the parsing logic, which is at the moment completely declaritive using xml tags

Documentation

Overview

Package collada implements a schema for importing and exporting collada V1.5 (.dea) documents

Index

Constants

View Source
const (
	OpaqueAlphaZero = "A_ZERO"
	OpaqueAlphaOne  = "A_ONE"
	OpaqueRgbZero   = "RGB_ZERO"
	OpaqueRgbOne    = "RGB_ONE"
)

Variables

This section is empty.

Functions

This section is empty.

Types

type Accessor

type Accessor struct {
}

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

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

func LoadDocumentFromReader

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

func (*Collada) Export

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

func (*Collada) ExportToWriter

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) F

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

func (*Floats) F32

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 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) I

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

Light declares a light source that illuminates a scene.

type Lines

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

type Linestrips

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) HasGeometry

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

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

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"`
}

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"`
	Phone      *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

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

type Trifans

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

type Tristrips

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) Id

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) Components

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.

Source Files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
t or T : Toggle theme light dark auto
y or Y : Canonical URL