vim-webgl-component
Version:
A demonstration app built on top of the vim-webgl-viewer
176 lines (175 loc) • 6.76 kB
TypeScript
/**
* @module vim-ts
*/
import { BFast } from '../bfast';
export declare type MeshSection = 'opaque' | 'transparent' | 'all';
/**
* See https://github.com/vimaec/vim#vim-geometry-attributes
*/
export declare class VimAttributes {
static positions: string;
static indices: string;
static instanceMeshes: string;
static instanceTransforms: string;
static instanceNodes: string;
static instanceFlags: string;
static meshSubmeshes: string;
static submeshIndexOffsets: string;
static submeshMaterials: string;
static materialColors: string;
static all: string[];
}
/**
* G3D is a simple, efficient, generic binary format for storing and transmitting geometry.
* The G3D format is designed to be used either as a serialization format or as an in-memory data structure.
* A G3d with specific attributes according to the VIM format specification.
* See https://github.com/vimaec/vim#vim-geometry-attributes for the vim specification.
* See https://github.com/vimaec/g3d for the g3d specification.
*/
export declare class G3d {
positions: Float32Array;
indices: Uint32Array;
instanceMeshes: Int32Array;
instanceTransforms: Float32Array;
instanceFlags: Uint16Array;
meshSubmeshes: Int32Array;
submeshIndexOffset: Int32Array;
submeshMaterial: Int32Array;
materialColors: Float32Array;
instanceNodes: Int32Array;
meshVertexOffsets: Int32Array;
meshInstances: Array<Array<number>>;
meshOpaqueCount: Int32Array;
submeshVertexStart: Int32Array;
submeshVertexEnd: Int32Array;
static MATRIX_SIZE: number;
static COLOR_SIZE: number;
static POSITION_SIZE: number;
/**
* Opaque white
*/
DEFAULT_COLOR: Float32Array;
constructor(instanceMeshes: Int32Array, instanceFlags: Uint16Array | undefined, instanceTransforms: Float32Array, instanceNodes: Int32Array | undefined, meshSubmeshes: Int32Array, submeshIndexOffsets: Int32Array, submeshMaterials: Int32Array, indices: Int32Array | Uint32Array, positions: Float32Array, materialColors: Float32Array);
private computeSubmeshVertexRange;
static createFromPath(path: string): Promise<G3d>;
static createFromBfast(bfast: BFast): Promise<G3d>;
/**
* Computes the index of the first vertex of each mesh
*/
private computeMeshVertexOffsets;
/**
* Computes all instances pointing to each mesh.
*/
private computeMeshInstances;
/**
* Reorders submeshIndexOffset, submeshMaterials and indices
* such that for each mesh, submeshes are sorted according to material alpha.
* This enables efficient splitting of arrays into opaque and transparent continuous ranges.
*/
private sortSubmeshes;
/**
* Stores result of getSubmeshIndexEnd for each submesh in an array
*/
private computeSubmeshEnd;
/**
* Stores result of getMeshIndexStart for each mesh in an array
*/
private computeMeshIndexOffsets;
/**
* Reorder submesh arrays and returns size of largest reordered mesh
*/
private reorderSubmeshes;
/**
* Sorts the range from start to end in every array provided in arrays in increasing criterion order.
* Using a simple bubble sort, there is a limited number of submeshes per mesh.
*/
private Sort;
/**
* Reorders the index buffer to match the new order of the submesh arrays.
*/
private reorderIndices;
/**
* Rebase indices to be relative to its own mesh instead of to the whole g3d
*/
private rebaseIndices;
private unbaseIndices;
/**
* Computes an array where true if any of the materials used by a mesh has transparency.
*/
private computeMeshOpaqueCount;
/**Given VIM instance indices returns the corresponding G3d indices */
remapInstances(instances: number[]): number[];
getVertexCount: () => number;
getIndexCount: () => number;
getMeshCount: () => number;
getMeshInstanceCount(mesh: number): number;
getMeshIndexStart(mesh: number, section?: MeshSection): number;
getMeshIndexEnd(mesh: number, section?: MeshSection): number;
getMeshIndexCount(mesh: number, section?: MeshSection): number;
getMeshVertexStart(mesh: number): number;
getMeshVertexEnd(mesh: number): number;
getMeshVertexCount(mesh: number): number;
getMeshSubmeshStart(mesh: number, section?: MeshSection): number;
getMeshSubmeshEnd(mesh: number, section?: MeshSection): number;
getMeshSubmeshCount(mesh: number, section?: MeshSection): number;
getMeshHasTransparency(mesh: number): boolean;
getSubmeshIndexStart(submesh: number): number;
getSubmeshIndexEnd(submesh: number): number;
getSubmeshIndexCount(submesh: number): number;
getSubmeshVertexStart(submesh: number): number;
getSubmeshVertexEnd(submesh: number): number;
getSubmeshVertexCount(submesh: number): number;
/**
* Returns color of given submesh as a 4-number array (RGBA)
* @param submesh g3d submesh index
*/
getSubmeshColor(submesh: number): Float32Array;
/**
* Returns color of given submesh as a 4-number array (RGBA)
* @param submesh g3d submesh index
*/
getSubmeshAlpha(submesh: number): number;
/**
* Returns true if submesh is transparent.
* @param submesh g3d submesh index
*/
getSubmeshIsTransparent(submesh: number): boolean;
/**
* Returns the total number of mesh in the g3d
*/
getSubmeshCount(): number;
getInstanceCount: () => number;
/**
* Returns true if instance has given flag enabled.
* @param instance instance to check.
* @param flag to check against.
*/
getInstanceHasFlag(instance: number, flag: number): boolean;
/**
* Returns mesh index of given instance
* @param instance g3d instance index
*/
getInstanceMesh(instance: number): number;
/**
* Returns an 16 number array representation of the matrix for given instance
* @param instance g3d instance index
*/
getInstanceMatrix(instance: number): Float32Array;
getMaterialCount: () => number;
/**
* Returns color of given material as a 4-number array (RGBA)
* @param material g3d material index
*/
getMaterialColor(material: number): Float32Array;
/**
* Returns the alpha component of given material
* @param material
*/
getMaterialAlpha(material: number): number;
/**
* Concatenates two g3ds into a new g3d.
* @deprecated
*/
append(other: G3d): G3d;
validate(): void;
}