gltf

package module
Version: v0.20.2 Latest Latest
Warning

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

Go to latest
Published: Apr 9, 2021 License: BSD-2-Clause Imports: 16 Imported by: 17

README

gltf PkgGoDev Build Status Coverage Status License Mentioned in Awesome Go

A Go module for efficient and robust serialization/deserialization of glTF 2.0, a royalty-free specification for the efficient transmission and loading of 3D scenes and models by applications, also known as "the JPEG of 3D".

Main FeaturesGetting StartedContributingAbout The Project

Gopher glTF

⭐ Main Features

📜 Getting started

Data Model

qmuntal/gltf implements the whole glTF 2.0 specification. The top level element is the gltf.Document and it contains all the information to hold a gltf document in memory:

// This document does not produce any valid glTF, it is just an example.
gltf.Document{
  Accessors: []*gltf.Accessor{
      {BufferView: gltf.Index(0), ComponentType: gltf.ComponentUshort, Type: gltf.AccessorScalar},
  },
  Asset: gltf.Asset{Version: "2.0", Generator: "qmuntal/gltf"},
  BufferViews: []*gltf.BufferView{
      {ByteLength: 72, ByteOffset: 0, Target: gltf.TargetElementArrayBuffer},
  },
  Buffers: []*gltf.Buffer{{ByteLength: 1033, URI: bufferData}},
  Meshes: []*gltf.Mesh{{
    Name: "Cube",
  }},
  Nodes: []*gltf.Node{{Name: "Cube", Mesh: gltf.Index(0)}},
  Scene:    gltf.Index(0),
  Scenes:   []*gltf.Scene{{Name: "Root Scene", Nodes: []uint32{0}}},
}
Optional parameters

All optional properties whose default value does not match with the golang type zero value are defines as pointers. Take the following guidelines into account when working with optional values:

  • It is safe to not define them when writing the glTF if the desired value is the default one.
  • It is safe to expect that the optional values are not nil when reading a glTF.
  • When assigning values to optional properties it may be helpful to use these utility functions:
    • gltf.Index(1)
    • gltf.Float(0.5)
Reading a document

A gltf.Document can be decoded from any io.Reader by using gltf.Decoder:

resp, _ := http.Get("https://example.com/static/foo.gltf")
var doc gltf.Document
gltf.NewDecoder(resp.Body).Decode(&doc)
fmt.Print(doc.Asset)

When working with the file system it is more convenient to use gltf.Open as it automatically manages relative external buffers:

doc, _ := gltf.Open("./foo.gltf")
fmt.Print(doc.Asset)

In both cases the decoder will automatically detect if the file is JSON/ASCII (gltf) or Binary (glb) based on its content.

Writing a document

A gltf.Document can be encoded to any io.Writer by using gltf.Encoder:

var buf bytes.Buffer
gltf.NewEncoder(&buf).Encode(&doc)
http.Post("http://example.com/upload", "model/gltf+binary", &buf)

By default gltf.NewEncoder outputs a binary file, to generate a JSON/ASCII file set AsBinary to false:

var buf bytes.Buffer
enc := gltf.NewEncoder(&buf)
enc.AsBinary = false
enc.Encode(&doc)
http.Post("http://example.com/upload", "model/gltf+json", &buf)

When working with the file system it is more convenient to use gltf.Save and gltf.SaveBinary as it automatically manages relative external buffers:

gltf.Save(&doc, "./foo.gltf")
gltf.SaveBinary(&doc, "./foo.glb")
Manipulating buffer views and accessors

The package gltf/modeler defines a friendly API to read and write accessors and buffer views, abstracting away all the byte manipulation work and the idiosyncrasy of the glTF spec.

The following example creates a single colored triangle:

screenshot

doc := gltf.NewDocument()
doc.Meshes = []*gltf.Mesh{{
    Name: "Pyramid",
    Primitives: []*gltf.Primitive{{
        Indices: gltf.Index(modeler.WriteIndices(doc, []uint16{0, 1, 2})),
        Attributes: map[string]uint32{
          gltf.POSITION: modeler.WritePosition(doc, [][3]float32{{0, 0, 0}, {0, 10, 0}, {0, 0, 10}}),
          gltf.COLOR_0:  modeler.WriteColor(doc, [][3]uint8{{255, 0, 0}, {0, 255, 0}, {0, 0, 255}}),
        },
    }},
}}
Data interleaving

The data of the attributes that are stored in a single bufferView may be stored as an Array-Of-Structures, which may produce a rendering perfomance boost in static attributes. qmuntal/gltf/modeler facilitates the creation of interleaved accessors and buffer views with the methods WriteAttributesInterleaved, WriteAccessorsInterleaved, and WriteBufferViewInterleaved being the first one the most recommended for creating mesh primitives:

doc := gltf.NewDocument()
attrs, _ := modeler.WriteAttributesInterleaved(doc, modeler.Attributes{
  Position:       [][3]float32{{0, 0, 0}, {0, 10, 0}, {0, 0, 10}},
  Color:          [][3]uint8{{255, 0, 0}, {0, 255, 0}, {0, 0, 255}},
})
doc.Meshes = []*gltf.Mesh{{
    Name: "Pyramid",
    Primitives: []*gltf.Primitive{{
        Indices: gltf.Index(modeler.WriteIndices(doc, []uint16{0, 1, 2})),
        Attributes: attrs,
    }},
}}
Manipulating bytes

The package gltf/binary defines a friendly and efficient API to read and write bytes from buffers, abstracting away all the byte manipulation work. This package is very low level and normal users should use gltf/modeler instead as it provides another level of abstraction that understands how bytes are associated to other entities.

This package is very similary to the Go binary package, the main differences are that it is highly specialized in glTF data types and that it only have to deal with little endian encoding.

Dealing with extensions

qmuntal/gltf is designed to support dynamic extensions. By default only the core specification is decoded and the data inside the extensions objects are stored as json.RawMessage so they can be decoded by the caller or automatically encoded when saving the document.

Some of the official extensions are implemented under ext.

To decode one of the supported extensions the only required action is to import the associated package, this way the extension will not be stored as json.RawMessage but as the type defined in the extension package:

import (
  "github.com/qmuntal/gltf"
  "github.com/qmuntal/gltf/ext/lightspuntual"
)

func main() {
  doc, _ := gltf.Open("./foo.gltf")
    if v, ok := doc.Extensions[lightspuntual.ExtensionName]; ok {
        for _, l := range v.(lightspuntual.Lights) {
            fmt.Print(l.Type)
        }
    }
}

It is not necessary to call gltf.RegisterExtension for built-in extensions, as these auto-register themselves when the package is initialized.

External extension

This list is the list of known extensions implemented in other modules:

Custom extensions

To implement a custom extension encoding, provide a struct that can be encoded as a JSON object as dictated by the spec.

To implement a custom extension decoding, call gltf.RegisterExtension at least once before decoding, providing the identifier of the extension and a function that decodes the JSON bytes to the desired struct:

const ExtensionName = "FAKE_Extension"

type Foo struct {
    BufferView uint32          `json:"bufferView"`
    Attributes gltf.Attribute  `json:"attributes"`
}

func init() {
    gltf.RegisterExtension(ExtensionName, Unmarshal)
}

func Unmarshal(data []byte) (interface{}, error) {
    foo := new(Foo)
    err := json.Unmarshal(data, foo)
    return foo, err
}

🙋 Contributing

PRs, issues, and feedback from ninja gophers are very welcomed.

About The Project

This library is a complete implementation of glTF 2.0, and its explicit aim is to provide a production-ready, idiomatic and curated API to perform any kind of glTF manipulation.

It is out of the scope to implement convertes to/from other file formats and to provide mechanisms to create and manipulate 3D geometry.

The current API is still not frozen and can suffer minor changes until it reached v1.0.

Please use the issue tracker or the if you'd like to report problems or discuss features.

Documentation

Index

Examples

Constants

View Source
const (
	POSITION   = "POSITION"
	NORMAL     = "NORMAL"
	TANGENT    = "TANGENT"
	TEXCOORD_0 = "TEXCOORD_0"
	TEXCOORD_1 = "TEXCOORD_1"
	WEIGHTS_0  = "WEIGHTS_0"
	JOINTS_0   = "JOINTS_0"
	COLOR_0    = "COLOR_0"
)

Attribute names defined in the spec.

View Source
const (
	// TargetNone is used when the buffer should not bound to a target, for example when referenced by an sparce indices.
	TargetNone = 0
	// TargetArrayBuffer corresponds to an array buffer.
	TargetArrayBuffer Target = 34962
	// TargetElementArrayBuffer corresponds to an element array buffer.
	TargetElementArrayBuffer = 34963
)

Variables

View Source
var (
	// DefaultMatrix defines an identity matrix.
	DefaultMatrix = [16]float32{1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1}
	// DefaultRotation defines a quaternion without rotation.
	DefaultRotation = [4]float32{0, 0, 0, 1}
	// DefaultScale defines a scaling that does not modify the size of the object.
	DefaultScale = [3]float32{1, 1, 1}
	// DefaultTranslation defines a translation that does not move the object.
	DefaultTranslation = [3]float32{0, 0, 0}
)

Functions

func DenormalizeByte

func DenormalizeByte(v int8) float32

NormalizeByte denormalize a int8 into a float32

func DenormalizeRGB

func DenormalizeRGB(v [3]uint8) [3]float32

DenormalizeRGB transform a RGB uint8 color (from 0 to 255) to its float represtation (from 0 to 1).

func DenormalizeRGB64

func DenormalizeRGB64(v [3]uint16) [3]float32

DenormalizeRGB64 transform a RGB uint16 color (from 0 to 65535) to its float represtation (from 0 to 1).

func DenormalizeRGBA

func DenormalizeRGBA(v [4]uint8) [4]float32

DenormalizeRGBA transform a RGBA uint8 color (from 0 to 255) to its float represtation (from 0 to 1).

func DenormalizeRGBA64

func DenormalizeRGBA64(v [4]uint16) [4]float32

DenormalizeRGBA64 transform a RGBA uint16 color (from 0 to 65535) to its float represtation (from 0 to 1).

func DenormalizeShort

func DenormalizeShort(v int16) float32

DenormalizeShort denormalize a int16 into a float32

func DenormalizeUbyte

func DenormalizeUbyte(v uint8) float32

DenormalizeUbyte denormalize a uint8 into a float32

func DenormalizeUshort

func DenormalizeUshort(v uint16) float32

DenormalizeuShort denormalize a uint16 into a float32

func Float

func Float(val float32) *float32

Float is an utility function that returns a pointer to a float32.

func Index

func Index(i uint32) *uint32

Index is an utility function that returns a pointer to a uint32.

func NormalizeByte

func NormalizeByte(v float32) int8

NormalizeByte normalize a float32 into a int8

func NormalizeRGB

func NormalizeRGB(v [3]float32) [3]uint8

NormalizeRGB transform a RGB float32 color (from 0 to 1) to its uint8 represtation (from 0 to 255).

func NormalizeRGB64

func NormalizeRGB64(v [3]float32) [3]uint16

NormalizeRGB64 transform a RGB float32 color (from 0 to 1) to its uint16 represtation (from 0 to 65535).

func NormalizeRGBA

func NormalizeRGBA(v [4]float32) [4]uint8

NormalizeRGB transform a RGBA float32 color (from 0 to 1) to its uint8 represtation (from 0 to 255).

func NormalizeRGBA64

func NormalizeRGBA64(v [4]float32) [4]uint16

NormalizeRGBA64 transform a RGBA float32 color (from 0 to 1) to its uint16 represtation (from 0 to 65535).

func NormalizeShort

func NormalizeShort(v float32) int16

NormalizeShort normalize a float32 into a int16

func NormalizeUbyte

func NormalizeUbyte(v float32) uint8

NormalizeUbyte normalize a float32 into a uint8

func NormalizeUshort

func NormalizeUshort(v float32) uint16

NormalizeUshort normalize a float32 into a uint16

func RegisterExtension

func RegisterExtension(key string, f func([]byte) (interface{}, error))

RegisterExtension registers a function that returns a new extension of the given byte array. This is intended to be called from the init function in packages that implement extensions.

func Save

func Save(doc *Document, name string) error

Save will save a document as a glTF with the specified by name.

Example
package main

import (
	"github.com/qmuntal/gltf"
)

func main() {
	doc := &gltf.Document{
		Accessors: []*gltf.Accessor{
			{BufferView: gltf.Index(0), ComponentType: gltf.ComponentUshort, Count: 36, Type: gltf.AccessorScalar},
			{BufferView: gltf.Index(1), ComponentType: gltf.ComponentFloat, Count: 24, Max: []float32{0.5, 0.5, 0.5}, Min: []float32{-0.5, -0.5, -0.5}, Type: gltf.AccessorVec3},
			{BufferView: gltf.Index(2), ComponentType: gltf.ComponentFloat, Count: 24, Type: gltf.AccessorVec3},
			{BufferView: gltf.Index(3), ComponentType: gltf.ComponentFloat, Count: 24, Type: gltf.AccessorVec4},
			{BufferView: gltf.Index(4), ComponentType: gltf.ComponentFloat, Count: 24, Type: gltf.AccessorVec2},
		},
		Asset: gltf.Asset{Version: "2.0", Generator: "FBX2glTF"},
		BufferViews: []*gltf.BufferView{
			{Buffer: 0, ByteLength: 72, ByteOffset: 0, Target: gltf.TargetElementArrayBuffer},
			{Buffer: 0, ByteLength: 288, ByteOffset: 72, Target: gltf.TargetArrayBuffer},
			{Buffer: 0, ByteLength: 288, ByteOffset: 360, Target: gltf.TargetArrayBuffer},
			{Buffer: 0, ByteLength: 384, ByteOffset: 648, Target: gltf.TargetArrayBuffer},
			{Buffer: 0, ByteLength: 192, ByteOffset: 1032, Target: gltf.TargetArrayBuffer},
		},
		Buffers: []*gltf.Buffer{{ByteLength: 1224, Data: []byte{97, 110, 121, 32, 99, 97, 114, 110, 97, 108, 32, 112, 108, 101, 97, 115}}},
		Materials: []*gltf.Material{{
			Name: "Default", AlphaMode: gltf.AlphaOpaque, AlphaCutoff: gltf.Float(0.5),
			PBRMetallicRoughness: &gltf.PBRMetallicRoughness{BaseColorFactor: &[4]float32{0.8, 0.8, 0.8, 1}, MetallicFactor: gltf.Float(0.1), RoughnessFactor: gltf.Float(0.99)},
		}},
		Meshes: []*gltf.Mesh{{Name: "Cube", Primitives: []*gltf.Primitive{{Indices: gltf.Index(0), Material: gltf.Index(0), Mode: gltf.PrimitiveTriangles, Attributes: map[string]uint32{gltf.POSITION: 1, gltf.COLOR_0: 3, gltf.NORMAL: 2, gltf.TEXCOORD_0: 4}}}}},
		Nodes: []*gltf.Node{
			{Name: "RootNode", Children: []uint32{1, 2, 3}},
			{Name: "Mesh"},
			{Name: "Cube", Mesh: gltf.Index(0)},
			{Name: "Texture Group"},
		},
		Samplers: []*gltf.Sampler{{WrapS: gltf.WrapRepeat, WrapT: gltf.WrapRepeat}},
		Scene:    gltf.Index(0),
		Scenes:   []*gltf.Scene{{Name: "Root Scene", Nodes: []uint32{0}}},
	}
	if err := gltf.SaveBinary(doc, "./example.glb"); err != nil {
		panic(err)
	}
}
Output:

func SaveBinary

func SaveBinary(doc *Document, name string) error

SaveBinary will save a document as a GLB file with the specified by name.

func SizeOfElement

func SizeOfElement(c ComponentType, t AccessorType) uint32

SizeOfElement returns the size, in bytes, of an element. The element size may not be (component size) * (number of components), as some of the elements are tightly packed in order to ensure that they are aligned to 4-byte boundaries.

Types

type Accessor

type Accessor struct {
	Extensions    Extensions    `json:"extensions,omitempty"`
	Extras        interface{}   `json:"extras,omitempty"`
	Name          string        `json:"name,omitempty"`
	BufferView    *uint32       `json:"bufferView,omitempty"`
	ByteOffset    uint32        `json:"byteOffset,omitempty"`
	ComponentType ComponentType `json:"componentType" validate:"lte=5"`
	Normalized    bool          `json:"normalized,omitempty"`      // Specifies whether integer data values should be normalized.
	Count         uint32        `json:"count" validate:"required"` // The number of attributes referenced by this accessor.
	Type          AccessorType  `json:"type" validate:"lte=6"`
	Max           []float32     `json:"max,omitempty" validate:"omitempty,lte=16"` // Maximum value of each component in this attribute.
	Min           []float32     `json:"min,omitempty" validate:"omitempty,lte=16"` // Minimum value of each component in this attribute.
	Sparse        *Sparse       `json:"sparse,omitempty"`                          // Sparse storage of attributes that deviate from their initialization value.
}

An Accessor is a typed view into a bufferView. An accessor provides a typed view into a bufferView or a subset of a bufferView similar to how WebGL's vertexAttribPointer() defines an attribute in a buffer.

type AccessorType

type AccessorType uint8

AccessorType specifies if the attribute is a scalar, vector, or matrix.

const (
	// AccessorScalar corresponds to a single dimension value.
	AccessorScalar AccessorType = iota
	// AccessorVec2 corresponds to a two dimensions array.
	AccessorVec2
	// AccessorVec3 corresponds to a three dimensions array.
	AccessorVec3
	// AccessorVec4 corresponds to a four dimensions array.
	AccessorVec4
	// AccessorMat2 corresponds to a 2x2 matrix.
	AccessorMat2
	// AccessorMat3 corresponds to a 3x3 matrix.
	AccessorMat3
	// AccessorMat4 corresponds to a 4x4 matrix.
	AccessorMat4
)

func (AccessorType) Components

func (a AccessorType) Components() uint32

Components returns the number of components of an accessor type.

func (*AccessorType) MarshalJSON

func (a *AccessorType) MarshalJSON() ([]byte, error)

MarshalJSON marshal the accessor type with the correct default values.

func (*AccessorType) UnmarshalJSON

func (a *AccessorType) UnmarshalJSON(data []byte) error

UnmarshalJSON unmarshal the accessor type with the correct default values.

type AlphaMode

type AlphaMode uint8

The AlphaMode enumeration specifying the interpretation of the alpha value of the main factor and texture.

const (
	// AlphaOpaque corresponds to an AlphaOpaque material.
	AlphaOpaque AlphaMode = iota
	// AlphaMask corresponds to a masked material.
	AlphaMask
	// AlphaBlend corresponds to a AlphaBlend material.
	AlphaBlend
)

func (*AlphaMode) MarshalJSON

func (a *AlphaMode) MarshalJSON() ([]byte, error)

MarshalJSON marshal the alpha mode with the correct default values.

func (*AlphaMode) UnmarshalJSON

func (a *AlphaMode) UnmarshalJSON(data []byte) error

UnmarshalJSON unmarshal the alpha mode with the correct default values.

type Animation

type Animation struct {
	Extensions Extensions          `json:"extensions,omitempty"`
	Extras     interface{}         `json:"extras,omitempty"`
	Name       string              `json:"name,omitempty"`
	Channels   []*Channel          `json:"channels" validate:"required,gt=0,dive"`
	Samplers   []*AnimationSampler `json:"samplers" validate:"required,gt=0,dive"`
}

An Animation keyframe.

type AnimationSampler

type AnimationSampler struct {
	Extensions    Extensions    `json:"extensions,omitempty"`
	Extras        interface{}   `json:"extras,omitempty"`
	Input         *uint32       `json:"input,omitempty"` // The index of an accessor containing keyframe input values.
	Interpolation Interpolation `json:"interpolation,omitempty" validate:"lte=2"`
	Output        *uint32       `json:"output,omitempty"` // The index of an accessor containing keyframe output values.
}

AnimationSampler combines input and output accessors with an interpolation algorithm to define a keyframe graph (but not its target).

type Asset

type Asset struct {
	Extensions Extensions  `json:"extensions,omitempty"`
	Extras     interface{} `json:"extras,omitempty"`
	Copyright  string      `json:"copyright,omitempty"`         // A copyright message suitable for display to credit the content creator.
	Generator  string      `json:"generator,omitempty"`         // Tool that generated this glTF model. Useful for debugging.
	Version    string      `json:"version" validate:"required"` // The glTF version that this asset targets.
	MinVersion string      `json:"minVersion,omitempty"`        // The minimum glTF version that this asset targets.
}

An Asset is metadata about the glTF asset.

type Attribute

type Attribute = map[string]uint32

Attribute is a map that each key corresponds to mesh attribute semantic and each value is the index of the accessor containing attribute's data.

type Buffer

type Buffer struct {
	Extensions Extensions  `json:"extensions,omitempty"`
	Extras     interface{} `json:"extras,omitempty"`
	Name       string      `json:"name,omitempty"`
	URI        string      `json:"uri,omitempty" validate:"omitempty"`
	ByteLength uint32      `json:"byteLength" validate:"required"`
	Data       []byte      `json:"-"`
}

A Buffer points to binary geometry, animation, or skins. If Data length is 0 and the Buffer is an external resource the Data won't be flushed, which can be useful when there is no need to load data in memory.

func (*Buffer) EmbeddedResource

func (b *Buffer) EmbeddedResource()

EmbeddedResource defines the buffer as an embedded resource and encodes the URI so it points to the the resource.

func (*Buffer) IsEmbeddedResource

func (b *Buffer) IsEmbeddedResource() bool

IsEmbeddedResource returns true if the buffer points to an embedded resource.

type BufferView

type BufferView struct {
	Extensions Extensions  `json:"extensions,omitempty"`
	Extras     interface{} `json:"extras,omitempty"`
	Buffer     uint32      `json:"buffer"`
	ByteOffset uint32      `json:"byteOffset,omitempty"`
	ByteLength uint32      `json:"byteLength" validate:"required"`
	ByteStride uint32      `json:"byteStride,omitempty" validate:"omitempty,gte=4,lte=252"`
	Target     Target      `json:"target,omitempty" validate:"omitempty,oneof=34962 34963"`
}

BufferView is a view into a buffer generally representing a subset of the buffer.

type Camera

type Camera struct {
	Extensions   Extensions    `json:"extensions,omitempty"`
	Extras       interface{}   `json:"extras,omitempty"`
	Name         string        `json:"name,omitempty"`
	Orthographic *Orthographic `json:"orthographic,omitempty"`
	Perspective  *Perspective  `json:"perspective,omitempty"`
}

A Camera projection. A node can reference a camera to apply a transform to place the camera in the scene.

func (*Camera) MarshalJSON

func (c *Camera) MarshalJSON() ([]byte, error)

MarshalJSON marshal the camera with the correct default values.

type Channel

type Channel struct {
	Extensions Extensions    `json:"extensions,omitempty"`
	Extras     interface{}   `json:"extras,omitempty"`
	Sampler    *uint32       `json:"sampler,omitempty"`
	Target     ChannelTarget `json:"target"`
}

The Channel targets an animation's sampler at a node's property.

type ChannelTarget

type ChannelTarget struct {
	Extensions Extensions  `json:"extensions,omitempty"`
	Extras     interface{} `json:"extras,omitempty"`
	Node       *uint32     `json:"node,omitempty"`
	Path       TRSProperty `json:"path" validate:"lte=4"`
}

ChannelTarget describes the index of the node and TRS property that an animation channel targets. The Path represents the name of the node's TRS property to modify, or the "weights" of the Morph Targets it instantiates. For the "translation" property, the values that are provided by the sampler are the translation along the x, y, and z axes. For the "rotation" property, the values are a quaternion in the order (x, y, z, w), where w is the scalar. For the "scale" property, the values are the scaling factors along the x, y, and z axes.

type ComponentType

type ComponentType uint16

The ComponentType is the datatype of components in the attribute. All valid values correspond to WebGL enums. 5125 (UNSIGNED_INT) is only allowed when the accessor contains indices.

const (
	// ComponentFloat corresponds to a Float32Array.
	ComponentFloat ComponentType = iota
	// ComponentByte corresponds to a Int8Array.
	ComponentByte
	// ComponentUbyte corresponds to a Uint8Array.
	ComponentUbyte
	// ComponentShort corresponds to a Int16Array.
	ComponentShort
	// ComponentUshort corresponds to a Uint16Array.
	ComponentUshort
	// ComponentUint corresponds to a Uint32Array.
	ComponentUint
)

func (ComponentType) ByteSize

func (c ComponentType) ByteSize() uint32

ByteSize returns the size of a component in bytes.

func (*ComponentType) MarshalJSON

func (c *ComponentType) MarshalJSON() ([]byte, error)

MarshalJSON marshal the component type with the correct default values.

func (*ComponentType) UnmarshalJSON

func (c *ComponentType) UnmarshalJSON(data []byte) error

UnmarshalJSON unmarshal the component type with the correct default values.

type Decoder

type Decoder struct {
	ReadHandler            ReadHandler
	MaxExternalBufferCount int
	MaxMemoryAllocation    uint64
	// contains filtered or unexported fields
}

A Decoder reads and decodes glTF and GLB values from an input stream. ReadHandler is called to read external resources.

func NewDecoder

func NewDecoder(r io.Reader) *Decoder

NewDecoder returns a new decoder that reads from r with relative external buffers support.

func (*Decoder) Decode

func (d *Decoder) Decode(doc *Document) error

Decode reads the next JSON-encoded value from its input and stores it in the value pointed to by doc.

func (*Decoder) WithReadHandler

func (d *Decoder) WithReadHandler(h ReadHandler) *Decoder

WithReadHandler sets the ReadHandler.

type Document

type Document struct {
	Extensions         Extensions    `json:"extensions,omitempty"`
	Extras             interface{}   `json:"extras,omitempty"`
	ExtensionsUsed     []string      `json:"extensionsUsed,omitempty"`
	ExtensionsRequired []string      `json:"extensionsRequired,omitempty"`
	Accessors          []*Accessor   `json:"accessors,omitempty" validate:"dive"`
	Animations         []*Animation  `json:"animations,omitempty" validate:"dive"`
	Asset              Asset         `json:"asset"`
	Buffers            []*Buffer     `json:"buffers,omitempty" validate:"dive"`
	BufferViews        []*BufferView `json:"bufferViews,omitempty" validate:"dive"`
	Cameras            []*Camera     `json:"cameras,omitempty" validate:"dive"`
	Images             []*Image      `json:"images,omitempty" validate:"dive"`
	Materials          []*Material   `json:"materials,omitempty" validate:"dive"`
	Meshes             []*Mesh       `json:"meshes,omitempty" validate:"dive"`
	Nodes              []*Node       `json:"nodes,omitempty" validate:"dive"`
	Samplers           []*Sampler    `json:"samplers,omitempty" validate:"dive"`
	Scene              *uint32       `json:"scene,omitempty"`
	Scenes             []*Scene      `json:"scenes,omitempty" validate:"dive"`
	Skins              []*Skin       `json:"skins,omitempty" validate:"dive"`
	Textures           []*Texture    `json:"textures,omitempty" validate:"dive"`
}

Document defines the root object for a glTF asset.

func NewDocument

func NewDocument() *Document

NewDocument returns a new Document with sane defaults.

func Open

func Open(name string) (*Document, error)

Open will open a glTF or GLB file specified by name and return the Document.

Example
package main

import (
	"fmt"

	"github.com/qmuntal/gltf"
)

func main() {
	doc, err := gltf.Open("fake")
	if err != nil {
		panic(err)
	}
	fmt.Print(doc.Asset)
}
Output:

type Encoder

type Encoder struct {
	AsBinary     bool
	WriteHandler WriteHandler
	// contains filtered or unexported fields
}

An Encoder writes a GLTF to an output stream with relative external buffers support.

func NewEncoder

func NewEncoder(w io.Writer) *Encoder

NewEncoder returns a new encoder that writes to w as a normal glTF file.

func (*Encoder) Encode

func (e *Encoder) Encode(doc *Document) error

Encode writes the encoding of doc to the stream.

func (*Encoder) WithWriteHandler

func (e *Encoder) WithWriteHandler(h WriteHandler) *Encoder

WithWriteHandler sets the WriteHandler.

type Extensions

type Extensions map[string]interface{}

Extensions is map where the keys are the extension identifiers and the values are the extensions payloads. If a key matches with one of the supported extensions the value will be marshalled as a pointer to the extension struct. If a key does not match with any of the supported extensions the value will be a json.RawMessage so its decoding can be delayed.

func (*Extensions) UnmarshalJSON

func (ext *Extensions) UnmarshalJSON(data []byte) error

UnmarshalJSON unmarshal the extensions with the supported extensions initialized.

type Image

type Image struct {
	Extensions Extensions  `json:"extensions,omitempty"`
	Extras     interface{} `json:"extras,omitempty"`
	Name       string      `json:"name,omitempty"`
	URI        string      `json:"uri,omitempty" validate:"omitempty"`
	MimeType   string      `json:"mimeType,omitempty" validate:"omitempty,oneof=image/jpeg image/png"` // Manadatory if BufferView is defined.
	BufferView *uint32     `json:"bufferView,omitempty"`                                               // Use this instead of the image's uri property.
}

Image data used to create a texture. Image can be referenced by URI or bufferView index. mimeType is required in the latter case.

func (*Image) IsEmbeddedResource

func (im *Image) IsEmbeddedResource() bool

IsEmbeddedResource returns true if the buffer points to an embedded resource.

func (*Image) MarshalData

func (im *Image) MarshalData() ([]byte, error)

MarshalData decode the image from the URI. If the image is not en embedded resource the returned array will be empty.

type Interpolation

type Interpolation uint8

Interpolation algorithm.

const (
	// InterpolationLinear corresponds to a linear interpolation.
	InterpolationLinear Interpolation = iota
	// InterpolationStep corresponds to a step interpolation.
	InterpolationStep
	// InterpolationCubicSpline corresponds to a cubic spline interpolation.
	InterpolationCubicSpline
)

func (*Interpolation) MarshalJSON

func (i *Interpolation) MarshalJSON() ([]byte, error)

MarshalJSON marshal the interpolation with the correct default values.

func (*Interpolation) UnmarshalJSON

func (i *Interpolation) UnmarshalJSON(data []byte) error

UnmarshalJSON unmarshal the interpolation with the correct default values.

type MagFilter

type MagFilter uint16

MagFilter is the magnification filter.

const (
	// MagUndefined indicates to not specified any magnification filters.
	MagUndefined MagFilter = iota
	// MagLinear corresponds to a linear magnification filter.
	MagLinear
	// MagNearest corresponds to a nearest magnification filter.
	MagNearest
)

func (*MagFilter) MarshalJSON

func (m *MagFilter) MarshalJSON() ([]byte, error)

MarshalJSON marshal the alpha mode with the correct default values.

func (*MagFilter) UnmarshalJSON

func (m *MagFilter) UnmarshalJSON(data []byte) error

UnmarshalJSON unmarshal the mag filter with the correct default values.

type Material

type Material struct {
	Extensions           Extensions            `json:"extensions,omitempty"`
	Extras               interface{}           `json:"extras,omitempty"`
	Name                 string                `json:"name,omitempty"`
	PBRMetallicRoughness *PBRMetallicRoughness `json:"pbrMetallicRoughness,omitempty"`
	NormalTexture        *NormalTexture        `json:"normalTexture,omitempty"`
	OcclusionTexture     *OcclusionTexture     `json:"occlusionTexture,omitempty"`
	EmissiveTexture      *TextureInfo          `json:"emissiveTexture,omitempty"`
	EmissiveFactor       [3]float32            `json:"emissiveFactor,omitempty" validate:"dive,gte=0,lte=1"`
	AlphaMode            AlphaMode             `json:"alphaMode,omitempty" validate:"lte=2"`
	AlphaCutoff          *float32              `json:"alphaCutoff,omitempty" validate:"omitempty,gte=0"`
	DoubleSided          bool                  `json:"doubleSided,omitempty"`
}

The Material appearance of a primitive.

func (*Material) AlphaCutoffOrDefault

func (m *Material) AlphaCutoffOrDefault() float32

AlphaCutoffOrDefault returns the scale if it is not nil, else return the default one.

func (*Material) MarshalJSON

func (m *Material) MarshalJSON() ([]byte, error)

MarshalJSON marshal the material with the correct default values.

func (*Material) UnmarshalJSON

func (m *Material) UnmarshalJSON(data []byte) error

UnmarshalJSON unmarshal the material with the correct default values.

type Mesh

type Mesh struct {
	Extensions Extensions   `json:"extensions,omitempty"`
	Extras     interface{}  `json:"extras,omitempty"`
	Name       string       `json:"name,omitempty"`
	Primitives []*Primitive `json:"primitives" validate:"required,gt=0,dive"`
	Weights    []float32    `json:"weights,omitempty"`
}

A Mesh is a set of primitives to be rendered. A node can contain one mesh. A node's transform places the mesh in the scene.

type MinFilter

type MinFilter uint16

MinFilter is the minification filter.

const (
	// MinUndefined indicates to not specified any minification filters.
	MinUndefined MinFilter = iota
	// MinLinear corresponds to a linear minification filter.
	MinLinear
	// MinNearestMipMapLinear corresponds to a nearest mipmap linear minification filter.
	MinNearestMipMapLinear
	// MinNearest corresponds to a nearest minification filter.
	MinNearest
	// MinNearestMipMapNearest corresponds to a nearest mipmap nearest minification filter.
	MinNearestMipMapNearest
	// MinLinearMipMapNearest corresponds to a linear mipmap nearest minification filter.
	MinLinearMipMapNearest
	// MinLinearMipMapLinear corresponds to a linear mipmap linear minification filter.
	MinLinearMipMapLinear
)

func (*MinFilter) MarshalJSON

func (m *MinFilter) MarshalJSON() ([]byte, error)

MarshalJSON marshal the min filter with the correct default values.

func (*MinFilter) UnmarshalJSON

func (m *MinFilter) UnmarshalJSON(data []byte) error

UnmarshalJSON unmarshal the min filter with the correct default values.

type Node

type Node struct {
	Extensions  Extensions  `json:"extensions,omitempty"`
	Extras      interface{} `json:"extras,omitempty"`
	Name        string      `json:"name,omitempty"`
	Camera      *uint32     `json:"camera,omitempty"`
	Children    []uint32    `json:"children,omitempty" validate:"omitempty,unique"`
	Skin        *uint32     `json:"skin,omitempty"`
	Matrix      [16]float32 `json:"matrix"` // A 4x4 transformation matrix stored in column-major order.
	Mesh        *uint32     `json:"mesh,omitempty"`
	Rotation    [4]float32  `json:"rotation" validate:"omitempty,dive,gte=-1,lte=1"` // The node's unit quaternion rotation in the order (x, y, z, w), where w is the scalar.
	Scale       [3]float32  `json:"scale"`
	Translation [3]float32  `json:"translation"`
	Weights     []float32   `json:"weights,omitempty"` // The weights of the instantiated Morph Target.
}

A Node in the node hierarchy. It can have either a matrix or any combination of translation/rotation/scale (TRS) properties.

func (*Node) MarshalJSON

func (n *Node) MarshalJSON() ([]byte, error)

MarshalJSON marshal the node with the correct default values.

func (*Node) MatrixOrDefault

func (n *Node) MatrixOrDefault() [16]float32

MatrixOrDefault returns the node matrix if it represents a valid affine matrix, else return the default one.

func (*Node) RotationOrDefault

func (n *Node) RotationOrDefault() [4]float32

RotationOrDefault returns the node rotation if it represents a valid quaternion, else return the default one.

func (*Node) ScaleOrDefault

func (n *Node) ScaleOrDefault() [3]float32

ScaleOrDefault returns the node scale if it represents a valid scale factor, else return the default one.

func (*Node) TranslationOrDefault

func (n *Node) TranslationOrDefault() [3]float32

TranslationOrDefault returns the node translation.

func (*Node) UnmarshalJSON

func (n *Node) UnmarshalJSON(data []byte) error

UnmarshalJSON unmarshal the node with the correct default values.

type NormalTexture

type NormalTexture struct {
	Extensions Extensions  `json:"extensions,omitempty"`
	Extras     interface{} `json:"extras,omitempty"`
	Index      *uint32     `json:"index,omitempty"`
	TexCoord   uint32      `json:"texCoord,omitempty"` // The index of texture's TEXCOORD attribute used for texture coordinate mapping.
	Scale      *float32    `json:"scale,omitempty"`
}

A NormalTexture references to a normal texture.

func (*NormalTexture) MarshalJSON

func (n *NormalTexture) MarshalJSON() ([]byte, error)

MarshalJSON marshal the texture info with the correct default values.

func (*NormalTexture) ScaleOrDefault

func (n *NormalTexture) ScaleOrDefault() float32

ScaleOrDefault returns the scale if it is not nil, else return the default one.

func (*NormalTexture) UnmarshalJSON

func (n *NormalTexture) UnmarshalJSON(data []byte) error

UnmarshalJSON unmarshal the texture info with the correct default values.

type OcclusionTexture

type OcclusionTexture struct {
	Extensions Extensions  `json:"extensions,omitempty"`
	Extras     interface{} `json:"extras,omitempty"`
	Index      *uint32     `json:"index,omitempty"`
	TexCoord   uint32      `json:"texCoord,omitempty"` // The index of texture's TEXCOORD attribute used for texture coordinate mapping.
	Strength   *float32    `json:"strength,omitempty" validate:"omitempty,gte=0,lte=1"`
}

An OcclusionTexture references to an occlusion texture

func (*OcclusionTexture) MarshalJSON

func (o *OcclusionTexture) MarshalJSON() ([]byte, error)

MarshalJSON marshal the texture info with the correct default values.

func (*OcclusionTexture) StrengthOrDefault

func (o *OcclusionTexture) StrengthOrDefault() float32

StrengthOrDefault returns the strength if it is not nil, else return the default one.

func (*OcclusionTexture) UnmarshalJSON

func (o *OcclusionTexture) UnmarshalJSON(data []byte) error

UnmarshalJSON unmarshal the texture info with the correct default values.

type Orthographic

type Orthographic struct {
	Extensions Extensions  `json:"extensions,omitempty"`
	Extras     interface{} `json:"extras,omitempty"`
	Xmag       float32     `json:"xmag"`                               // The horizontal magnification of the view.
	Ymag       float32     `json:"ymag"`                               // The vertical magnification of the view.
	Zfar       float32     `json:"zfar" validate:"gt=0,gtfield=Znear"` // The distance to the far clipping plane.
	Znear      float32     `json:"znear" validate:"gte=0"`             // The distance to the near clipping plane.
}

Orthographic camera containing properties to create an orthographic projection matrix.

type PBRMetallicRoughness

type PBRMetallicRoughness struct {
	Extensions               Extensions   `json:"extensions,omitempty"`
	Extras                   interface{}  `json:"extras,omitempty"`
	BaseColorFactor          *[4]float32  `json:"baseColorFactor,omitempty" validate:"omitempty,dive,gte=0,lte=1"`
	BaseColorTexture         *TextureInfo `json:"baseColorTexture,omitempty"`
	MetallicFactor           *float32     `json:"metallicFactor,omitempty" validate:"omitempty,gte=0,lte=1"`
	RoughnessFactor          *float32     `json:"roughnessFactor,omitempty" validate:"omitempty,gte=0,lte=1"`
	MetallicRoughnessTexture *TextureInfo `json:"metallicRoughnessTexture,omitempty"`
}

PBRMetallicRoughness defines a set of parameter values that are used to define the metallic-roughness material model from Physically-Based Rendering (PBR) methodology.

func (*PBRMetallicRoughness) BaseColorFactorOrDefault

func (p *PBRMetallicRoughness) BaseColorFactorOrDefault() [4]float32

BaseColorFactorOrDefault returns the base color factor if it is not nil, else return the default one.

func (*PBRMetallicRoughness) MarshalJSON

func (p *PBRMetallicRoughness) MarshalJSON() ([]byte, error)

MarshalJSON marshal the pbr with the correct default values.

func (*PBRMetallicRoughness) MetallicFactorOrDefault

func (p *PBRMetallicRoughness) MetallicFactorOrDefault() float32

MetallicFactorOrDefault returns the metallic factor if it is not nil, else return the default one.

func (*PBRMetallicRoughness) RoughnessFactorOrDefault

func (p *PBRMetallicRoughness) RoughnessFactorOrDefault() float32

RoughnessFactorOrDefault returns the roughness factor if it is not nil, else return the default one.

func (*PBRMetallicRoughness) UnmarshalJSON

func (p *PBRMetallicRoughness) UnmarshalJSON(data []byte) error

UnmarshalJSON unmarshal the pbr with the correct default values.

type Perspective

type Perspective struct {
	Extensions  Extensions  `json:"extensions,omitempty"`
	Extras      interface{} `json:"extras,omitempty"`
	AspectRatio *float32    `json:"aspectRatio,omitempty"`
	Yfov        float32     `json:"yfov"`           // The vertical field of view in radians.
	Zfar        *float32    `json:"zfar,omitempty"` // The distance to the far clipping plane.
	Znear       float32     `json:"znear"`          // The distance to the near clipping plane.
}

Perspective camera containing properties to create a perspective projection matrix.

type Primitive

type Primitive struct {
	Extensions Extensions    `json:"extensions,omitempty"`
	Extras     interface{}   `json:"extras,omitempty"`
	Attributes Attribute     `json:"attributes"`
	Indices    *uint32       `json:"indices,omitempty"` // The index of the accessor that contains the indices.
	Material   *uint32       `json:"material,omitempty"`
	Mode       PrimitiveMode `json:"mode,omitempty" validate:"lte=6"`
	Targets    []Attribute   `json:"targets,omitempty" validate:"omitempty,dive,dive,keys,oneof=POSITION NORMAL TANGENT,endkeys"` // Only POSITION, NORMAL, and TANGENT supported.
}

Primitive defines the geometry to be rendered with the given material.

type PrimitiveMode

type PrimitiveMode uint8

PrimitiveMode defines the type of primitives to render. All valid values correspond to WebGL enums.

const (
	// PrimitiveTriangles corresponds to a Triangle primitive.
	PrimitiveTriangles PrimitiveMode = iota
	// PrimitivePoints corresponds to a Point primitive.
	PrimitivePoints
	// PrimitiveLines corresponds to a Line primitive.
	PrimitiveLines
	// PrimitiveLineLoop corresponds to a Line Loop primitive.
	PrimitiveLineLoop
	// PrimitiveLineStrip corresponds to a Line Strip primitive.
	PrimitiveLineStrip
	// PrimitiveTriangleStrip corresponds to a Triangle Strip primitive.
	PrimitiveTriangleStrip
	// PrimitiveTriangleFan corresponds to a Triangle Fan primitive.
	PrimitiveTriangleFan
)

func (*PrimitiveMode) MarshalJSON

func (p *PrimitiveMode) MarshalJSON() ([]byte, error)

MarshalJSON marshal the primitive mode with the correct default values.

func (*PrimitiveMode) UnmarshalJSON

func (p *PrimitiveMode) UnmarshalJSON(data []byte) error

UnmarshalJSON unmarshal the primitive mode with the correct default values.

type ReadHandler

type ReadHandler interface {
	ReadFullResource(uri string, data []byte) error
}

ReadHandler is the interface that wraps the ReadFullResource method.

ReadFullResource should behaves as io.ReadFull in terms of reading the external resource. The data already has the correct size so it can be used directly to store the read output.

type RelativeFileHandler

type RelativeFileHandler struct {
	Dir string
}

RelativeFileHandler implements a secure ReadHandler supporting relative paths. If Dir is empty the os.Getws will be used. It comes with directory traversal protection.

func (*RelativeFileHandler) ReadFullResource

func (h *RelativeFileHandler) ReadFullResource(uri string, data []byte) error

ReadFullResource reads all the resource data using io.ReadFull.

func (*RelativeFileHandler) WriteResource

func (h *RelativeFileHandler) WriteResource(uri string, data []byte) error

WriteResource writes the resource using io.WriteFile.

type Sampler

type Sampler struct {
	Extensions Extensions   `json:"extensions,omitempty"`
	Extras     interface{}  `json:"extras,omitempty"`
	Name       string       `json:"name,omitempty"`
	MagFilter  MagFilter    `json:"magFilter,omitempty" validate:"lte=1"`
	MinFilter  MinFilter    `json:"minFilter,omitempty" validate:"lte=5"`
	WrapS      WrappingMode `json:"wrapS,omitempty" validate:"lte=2"`
	WrapT      WrappingMode `json:"wrapT,omitempty" validate:"lte=2"`
}

Sampler of a texture for filtering and wrapping modes.

type Scene

type Scene struct {
	Extensions Extensions  `json:"extensions,omitempty"`
	Extras     interface{} `json:"extras,omitempty"`
	Name       string      `json:"name,omitempty"`
	Nodes      []uint32    `json:"nodes,omitempty" validate:"omitempty,unique"`
}

The Scene contains a list of root nodes.

type Skin

type Skin struct {
	Extensions          Extensions  `json:"extensions,omitempty"`
	Extras              interface{} `json:"extras,omitempty"`
	Name                string      `json:"name,omitempty"`
	InverseBindMatrices *uint32     `json:"inverseBindMatrices,omitempty"`      // The index of the accessor containing the floating-point 4x4 inverse-bind matrices.
	Skeleton            *uint32     `json:"skeleton,omitempty"`                 // The index of the node used as a skeleton root. When undefined, joints transforms resolve to scene root.
	Joints              []uint32    `json:"joints" validate:"omitempty,unique"` // Indices of skeleton nodes, used as joints in this skin.
}

Skin defines joints and matrices.

type Sparse

type Sparse struct {
	Extensions Extensions    `json:"extensions,omitempty"`
	Extras     interface{}   `json:"extras,omitempty"`
	Count      uint32        `json:"count" validate:"gte=1"` // Number of entries stored in the sparse array.
	Indices    SparseIndices `json:"indices"`                // Index array of size count that points to those accessor attributes that deviate from their initialization value.
	Values     SparseValues  `json:"values"`                 // Array of size count times number of components, storing the displaced accessor attributes pointed by indices.
}

Sparse storage of attributes that deviate from their initialization value.

type SparseIndices

type SparseIndices struct {
	Extensions    Extensions    `json:"extensions,omitempty"`
	Extras        interface{}   `json:"extras,omitempty"`
	BufferView    uint32        `json:"bufferView"`
	ByteOffset    uint32        `json:"byteOffset,omitempty"`
	ComponentType ComponentType `json:"componentType" validate:"oneof=2 4 5"`
}

SparseIndices defines the indices of those attributes that deviate from their initialization value.

type SparseValues

type SparseValues struct {
	Extensions Extensions  `json:"extensions,omitempty"`
	Extras     interface{} `json:"extras,omitempty"`
	BufferView uint32      `json:"bufferView"`
	ByteOffset uint32      `json:"byteOffset,omitempty"`
}

SparseValues stores the displaced accessor attributes pointed by accessor.sparse.indices.

type TRSProperty

type TRSProperty uint8

TRSProperty defines a local space transformation. TRSproperties are converted to matrices and postmultiplied in the T * R * S order to compose the transformation matrix.

const (
	// TRSTranslation corresponds to a translation transform.
	TRSTranslation TRSProperty = iota
	// TRSRotation corresponds to a rotation transform.
	TRSRotation
	// TRSScale corresponds to a scale transform.
	TRSScale
	// TRSWeights corresponds to a weights transform.
	TRSWeights
)

func (*TRSProperty) MarshalJSON

func (t *TRSProperty) MarshalJSON() ([]byte, error)

MarshalJSON marshal the TRSProperty with the correct default values.

func (*TRSProperty) UnmarshalJSON

func (t *TRSProperty) UnmarshalJSON(data []byte) error

UnmarshalJSON unmarshal the TRSProperty with the correct default values.

type Target

type Target uint16

The Target that the GPU buffer should be bound to.

type Texture

type Texture struct {
	Extensions Extensions  `json:"extensions,omitempty"`
	Extras     interface{} `json:"extras,omitempty"`
	Name       string      `json:"name,omitempty"`
	Sampler    *uint32     `json:"sampler,omitempty"`
	Source     *uint32     `json:"source,omitempty"`
}

A Texture and its sampler.

type TextureInfo

type TextureInfo struct {
	Extensions Extensions  `json:"extensions,omitempty"`
	Extras     interface{} `json:"extras,omitempty"`
	Index      uint32      `json:"index"`
	TexCoord   uint32      `json:"texCoord,omitempty"` // The index of texture's TEXCOORD attribute used for texture coordinate mapping.
}

TextureInfo references to a texture.

type WrappingMode

type WrappingMode uint16

WrappingMode is the wrapping mode of a texture.

const (
	// WrapRepeat corresponds to a repeat wrapping.
	WrapRepeat WrappingMode = iota
	// WrapClampToEdge corresponds to a clamp to edge wrapping.
	WrapClampToEdge
	// WrapMirroredRepeat corresponds to a mirrored repeat wrapping.
	WrapMirroredRepeat
)

func (*WrappingMode) MarshalJSON

func (w *WrappingMode) MarshalJSON() ([]byte, error)

MarshalJSON marshal the wrapping mode with the correct default values.

func (*WrappingMode) UnmarshalJSON

func (w *WrappingMode) UnmarshalJSON(data []byte) error

UnmarshalJSON unmarshal the wrapping mode with the correct default values.

type WriteHandler

type WriteHandler interface {
	WriteResource(uri string, data []byte) error
}

WriteHandler is the interface that wraps the Write method.

WriteResource should behaves as io.Write in terms of reading the writing resource.

Directories

Path Synopsis
Package binary implements simple translation between numbers and byte sequences.
Package binary implements simple translation between numbers and byte sequences.
ext
lightspuntual
Package lightspuntual defines three "punctual" light types: directional, point and spot.
Package lightspuntual defines three "punctual" light types: directional, point and spot.
Package modeler implements helper methods to write common glTF entities (indices, positions, colors, ...) into buffers.
Package modeler implements helper methods to write common glTF entities (indices, positions, colors, ...) into buffers.

Jump to

Keyboard shortcuts

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