Glen Whitney
b5478254af
Enabling type checking involves a full rearrangement of the build process, as well as supplying types for some of the dependencies. Now that (hopefully) all of the methods are typed, can call (for example) browser.setBrowserOption to manage the viewer navigation. Resolves #14. Resolves #17. Reviewed-on: #18 Co-authored-by: Glen Whitney <glen@studioinfinity.org> Co-committed-by: Glen Whitney <glen@studioinfinity.org>
2036 lines
63 KiB
TypeScript
2036 lines
63 KiB
TypeScript
declare module 'https://create3000.github.io/code/x_ite/latest/x_ite.mjs' {
|
||
const x3d: X3D;
|
||
export default x3d;
|
||
export interface X3D {
|
||
(callback?: () => void, fallback?: (error: Error) => void): Promise<void>;
|
||
createBrowser(): HTMLElement;
|
||
getBrowser(via?: string | HTMLElement): X3DBrowser;
|
||
noConflict(): X3D;
|
||
X3DConstants: X3DConstant;
|
||
SFBool(arg: unknown): boolean;
|
||
// NB. in all of the following `typeof Class` is an expression that
|
||
// extracts the type of the constructor for Class.
|
||
SFColor: typeof SFColor;
|
||
SFColorRGBA: typeof SFColorRGBA;
|
||
// Doubles and floats not different in JavaScript:
|
||
SFDouble: typeof SFDouble;
|
||
SFFloat: typeof SFDouble;
|
||
|
||
SFImage: typeof SFImage;
|
||
SFInt32: typeof SFInt32;
|
||
|
||
// Doubles and floats same:
|
||
SFMatrix3d: typeof SFMatrix3;
|
||
SFMatrix3f: typeof SFMatrix3;
|
||
SFMatrix4d: typeof SFMatrix4;
|
||
SFMatrix4f: typeof SFMatrix4;
|
||
|
||
// SFNode: typeof SFNode; // no working constructors, just one that throws
|
||
SFRotation: typeof SFRotation;
|
||
SFString: typeof SFString;
|
||
SFTime: typeof SFTime;
|
||
|
||
// Doubles and floats same:
|
||
SFVec2d: typeof SFVec2;
|
||
SFVec2f: typeof SFVec2;
|
||
SFVec3d: typeof SFVec3;
|
||
SFVec3f: typeof SFVec3;
|
||
SFVec4d: typeof SFVec4;
|
||
SFVec4f: typeof SFVec4;
|
||
|
||
// All the array types:
|
||
MFBool: typeof X3DArrayField<boolean>;
|
||
MFColor: typeof X3DArrayField<SFColor>;
|
||
MFColorRGBA: typeof X3DArrayField<SFColorRGBA>;
|
||
MFDouble: typeof X3DArrayField<number>; // or should it be SFDouble?
|
||
MFFloat: typeof X3DArrayField<number>; // ditto?
|
||
MFImage: typeof X3DArrayField<SFImage>;
|
||
MFMatrix3d: typeof X3DArrayField<SFMatrix3>;
|
||
MFMatrix3f: typeof X3DArrayField<SFMatrix3>;
|
||
MFMatrix4d: typeof X3DArrayField<SFMatrix4>;
|
||
MFMatrix4f: typeof X3DArrayField<SFMatrix4>;
|
||
MFInt32: typeof X3DArrayField<number>; // or SFInt32?
|
||
MFNode: typeof X3DArrayField<SFNode>;
|
||
MFRotation: typeof X3DArrayField<SFRotation>;
|
||
MFString: typeof X3DArrayField<string>; // or SFSTring?
|
||
MFTime: typeof X3DArrayField<SFTime>;
|
||
MFVec2d: typeof X3DArrayField<SFVec2>;
|
||
MFVec2f: typeof X3DArrayField<SFVec2>;
|
||
MFVec3d: typeof X3DArrayField<SFVec3>;
|
||
MFVec3f: typeof X3DArrayField<SFVec3>;
|
||
MFVec4d: typeof X3DArrayField<SFVec4>;
|
||
MFVec4f: typeof X3DArrayField<SFVec4>;
|
||
}
|
||
|
||
type JSONValue =
|
||
| string
|
||
| number
|
||
| boolean
|
||
| null
|
||
| JSONValue[]
|
||
| {[key: string]: JSONValue}
|
||
|
||
interface JSONObject {
|
||
[k: string]: JSONValue
|
||
}
|
||
|
||
type BrowserProperty = 'ABSTRACT_NODES'
|
||
| 'CONCRETE_NODES'
|
||
| 'EXTERNAL_INTERACTIONS'
|
||
| 'PROTOTYPE_CREATE'
|
||
| 'DOM_IMPORT'
|
||
| 'XML_ENCODING'
|
||
| 'CLASSIC_VRML_ENCODING'
|
||
| 'BINARY_ENCOIDING';
|
||
|
||
type QualityLevels = 'LOW' | 'MEDIUM' | 'HIGH';
|
||
type BrowserOption = {
|
||
Antialiased: boolean,
|
||
Dashboard: boolean,
|
||
Rubberband: boolean,
|
||
EnableInlineViewpoints: boolean,
|
||
MotionBlur: boolean,
|
||
PrimitiveQuality: QualityLevels,
|
||
QualityWhenMoving: QualityLevels | 'SAME',
|
||
Shading: 'POINT' | 'WIREFRAME' | 'FLAT'
|
||
| 'GOURAUD' | 'PHONG',
|
||
SplashScreen: boolean,
|
||
TextureQuality: QualityLevels,
|
||
AutoUpdate: boolean,
|
||
Cache: boolean,
|
||
ContentScale: number,
|
||
ContextMenu: boolean,
|
||
Debug: boolean,
|
||
Gravity: number,
|
||
LogarithmicDepthBuffer: boolean,
|
||
Multisampling: number,
|
||
Notifications: boolean,
|
||
OrderIndependentTransparency: boolean,
|
||
StraightenHorizon: boolean,
|
||
Timings: boolean
|
||
}
|
||
export type RenderingProperty = {
|
||
Shading: BrowserOption['Shading'],
|
||
MaxTextureSize: number,
|
||
TextureUnits: number,
|
||
MaxLights: number,
|
||
Antialiased: boolean,
|
||
ColorDepth: number,
|
||
TextureMemory: number,
|
||
ContentScale: number,
|
||
MaxSamples: number,
|
||
Multisampling: number,
|
||
LogarithmicDepthBuffer: boolean
|
||
}
|
||
|
||
type BrowserCallback = (
|
||
event: number) => void; // event is a Browser Event Constant
|
||
|
||
export interface X3DBrowser {
|
||
name: string;
|
||
version: string;
|
||
providerURL: string;
|
||
currentSpeed: number;
|
||
currentFrameRate: number;
|
||
description: string;
|
||
readonly supportedComponents: ComponentInfoArray;
|
||
readonly supportedProfiles: ProfileInfoArray;
|
||
baseURL: string;
|
||
currentScene: X3DScene;
|
||
|
||
replaceWorld(scene: X3DScene): Promise<void>;
|
||
createX3DFromString(x3dSyntax: string): Promise<X3DScene>;
|
||
createX3DFromURL(url: X3DArrayField<string>): Promise<X3DScene>;
|
||
createX3DFromURL(url: X3DArrayField<string>,
|
||
node: SFNode, fieldName: string): void;
|
||
loadURL(url: X3DArrayField<string>,
|
||
parameter?: X3DArrayField<string>): Promise<void>;
|
||
importDocument(dom: HTMLElement | string): Promise<X3DScene>;
|
||
importJS(json: string | JSONObject): Promise<X3DScene>;
|
||
getBrowserProperty(prop: BrowserProperty): boolean;
|
||
getBrowserOption<T extends keyof BrowserOption>(op: T): BrowserOption[T];
|
||
setBrowserOption<T extends keyof BrowserOption>(
|
||
op: T, value: BrowserOption[T]): void;
|
||
getRenderingProperty<T extends keyof RenderingProperty>(
|
||
prop: T): RenderingProperty[T];
|
||
addBrowserCallback(key: unknown, cb?: BrowserCallback): void;
|
||
addBrowserCallback(
|
||
key: unknown, event: number, // A Browser Event Constant
|
||
cb?: BrowserCallback): void;
|
||
removeBrowserCallback(key: unknown, event?: number): void;
|
||
viewAll(layer?: SFNode, transitionTime?: number): void;
|
||
nextViewpoint(layer?: SFNode): void;
|
||
previousViewpoint(layer?: SFNode): void;
|
||
firstViewpoint(layer?: SFNode): void;
|
||
lastViewpoint(layer?: SFNode): void;
|
||
changeViewpoint(name: string): void;
|
||
changeViewpoint(layer: SFNode, name: string): void;
|
||
print(thing: unknown): void;
|
||
printLn(thing: unknown): void;
|
||
// VRML methods
|
||
getName(): string;
|
||
getVersion(): string;
|
||
getCurrentSpeed(): number;
|
||
getCurrentFrameRate(): number;
|
||
getWorldURL(): string;
|
||
replaceWorld(nodes: X3DArrayField<SFNode>): string;
|
||
createVrmlFromString(vrmlSyntax: string): X3DArrayField<SFNode>;
|
||
createVrmlFromURL(url: X3DArrayField<string>,
|
||
node: SFNode, fieldName: string): void;
|
||
addRoute(sourceNode: SFNode, sourceField: string,
|
||
destinationNode: SFNode, destinationField: string): void;
|
||
deleteRoute(sourceNode: SFNode, sourceField: string,
|
||
destinationNode: SFNode, destinationField: string): void;
|
||
loadURL(url: X3DArrayField<string>,
|
||
parameter?: X3DArrayField<string>): void;
|
||
setDescription(description: string): void;
|
||
}
|
||
|
||
type MinimalArray<T> = {[index: number]: T, length: number}
|
||
|
||
type ComponentInfoArray = MinimalArray<ComponentInfo>;
|
||
interface ComponentInfo {
|
||
readonly name: string;
|
||
readonly level?: number;
|
||
readonly title: string;
|
||
readonly providerURL: string;
|
||
}
|
||
|
||
type ProfileInfoArray = MinimalArray<ProfileInfo>;
|
||
interface ProfileInfo extends ComponentInfo {
|
||
readonly components: ComponentInfoArray
|
||
}
|
||
|
||
export interface X3DScene {
|
||
readonly specificationVersion: string;
|
||
readonly encoding: 'ASCII' | 'VRML' | 'XML' | 'BINARY'
|
||
| 'SCRIPTED' | 'BIFS' | 'NONE';
|
||
readonly profile: ProfileInfo;
|
||
readonly components: ComponentInfoArray;
|
||
readonly units: UnitInfoArray;
|
||
readonly worldURL: string;
|
||
readonly baseURL: string;
|
||
rootNodes: X3DArrayField<SFNode>;
|
||
readonly protos: ProtoDeclarationArray;
|
||
readonly externprotos: ExternProtoDeclarationArray;
|
||
readonly routes: RouteArray;
|
||
|
||
// ExecutionContext methods. I didn't split these out because I
|
||
// didn't see a place in the interface where it mattered, but
|
||
// perhaps there should be a base class with just these...
|
||
createNode<T extends keyof SpecializeNodeType>(
|
||
spec: T): SpecializeNodeType[T];
|
||
createProto(protoName: string): SFNode;
|
||
getNamedNode(name: string): SFNode;
|
||
updateNamedNode(name: string, node: SFNode): void;
|
||
removeNamedNode(name: string): void;
|
||
getImportedNode(importedName: string): SFNode;
|
||
updateImportedNode(
|
||
inlineNode: SFNode, exportedName: string, importedName: string): void;
|
||
removeImportedNode(importedName: string): void;
|
||
addRoute(sourceNode: SFNode, sourceField: string,
|
||
destinationNode: SFNode, destinationField: string): X3DRoute;
|
||
deleteRoute(route: X3DRoute): void;
|
||
|
||
// X3DScene methods:
|
||
getMetaData(name: string): string[];
|
||
setMetaData(name: string, value: string | string[]): void;
|
||
addMetaData(name: string, value: string): void;
|
||
removeMetaData(name: string): void;
|
||
addRootNode(node: SFNode): void;
|
||
removeRootNode(node: SFNode): void;
|
||
getExportedNode(exportedName: string): SFNode;
|
||
updateExportedNode(exportedName: string, node: SFNode): void;
|
||
removeExportedNode(exportedName: string): void;
|
||
toVRMLString(options?: VRMLOptions): string;
|
||
toXMLString(options?: VRMLOptions): string;
|
||
toJSONString(options?: VRMLOptions): string;
|
||
}
|
||
|
||
type UnitInfoArray = MinimalArray<UnitInfo>;
|
||
interface UnitInfo {
|
||
readonly category: string;
|
||
readonly name: string;
|
||
readonly conversionFactor: number;
|
||
}
|
||
|
||
type ProtoDeclarationArray = MinimalArray<X3DProtoDeclaration>;
|
||
export interface X3DProtoDeclaration {
|
||
readonly name: string;
|
||
readonly fields: FieldDefinitionArray;
|
||
isExternProto: false;
|
||
newInstance(): SFNode;
|
||
toVRMLString(options?: VRMLOptions): string;
|
||
toXMLString(options?: VRMLOptions): string;
|
||
toJSONString(options?: VRMLOptions): string;
|
||
}
|
||
|
||
type ExternProtoDeclarationArray = MinimalArray<X3DExternProtoDeclaration>;
|
||
export interface X3DExternProtoDeclaration {
|
||
readonly name: string;
|
||
readonly fields: FieldDefinitionArray;
|
||
readonly urls: X3DArrayField<string>;
|
||
isExternProto: false;
|
||
readonly loadState: number; // A Load State Constant from X3DConstant
|
||
newInstance(): SFNode;
|
||
loadNow(): Promise<void>;
|
||
toVRMLString(options?: VRMLOptions): string;
|
||
toXMLString(options?: VRMLOptions): string;
|
||
toJSONString(options?: VRMLOptions): string;
|
||
}
|
||
|
||
type RouteArray = MinimalArray<X3DRoute>;
|
||
export interface X3DRoute {
|
||
sourceNode: SFNode;
|
||
sourceField: string;
|
||
destinationNode: SFNode;
|
||
destinationField: string;
|
||
}
|
||
|
||
type FieldCallback = (value: unknown) => void
|
||
|
||
class X3DField {
|
||
equals(other: X3DField): boolean;
|
||
assign(other: X3DField): void;
|
||
setValue(value: unknown): void;
|
||
getValue(): unknown;
|
||
getType(): number; // one of the Field Type Constants from X3DConstant
|
||
getAccessType(): number; // one of the Access Type Constants
|
||
isInitializable(): boolean;
|
||
isInput(): boolean;
|
||
isOutput(): boolean;
|
||
isReadable(): boolean;
|
||
isWritable(): boolean;
|
||
getUnit(): string;
|
||
hasReferences(): boolean;
|
||
isReference(accessType: number): boolean;
|
||
addReferencesCallback(key: unknown, callback: FieldCallback): void;
|
||
removeReferencesCallback(key: unknown): void;
|
||
getReferencesCallbacks(): Map<unknown, FieldCallback>;
|
||
addFieldInterest(other: X3DField): void;
|
||
removeFieldInterest(other: X3DField): void;
|
||
getFieldInterest(): Set<X3DField>
|
||
addFieldCallback(key: unknown, callback: FieldCallback): void;
|
||
removeFieldCallback(key: unknown): void;
|
||
getFieldCallbacks(): Map<unknown, FieldCallback>;
|
||
addInputRoute(route: unknown): void; // what's the proper type for route?
|
||
removeInputRoute(route: unknown): void;
|
||
getInputRoutes(): Set<unknown>;
|
||
addOutputRoute(route: unknown): void; // ditto
|
||
removeOutputRoute(route: unknown): void;
|
||
getOutputRoutes(): Set<unknown>;
|
||
addRouteCallback(key: unknown, callback: FieldCallback): void;
|
||
removeRouteCallback(key: unknown): void;
|
||
getRouteCallbacks(): Map<unknown, FieldCallback>;
|
||
dispose(): void;
|
||
}
|
||
|
||
export class SFColor extends X3DField {
|
||
constructor(r?: number, g?: number, b?: number);
|
||
r: number;
|
||
g: number;
|
||
b: number;
|
||
copy(): SFColor;
|
||
isDefaultValue(): boolean;
|
||
set(r: number, g: number, b: number): SFColor;
|
||
getHSV(result: number[]): number[];
|
||
setHSV(h: number, s: number, v: number): void;
|
||
lerp(destination: SFColor, t: number): SFColor;
|
||
static typeName: 'SFColor';
|
||
}
|
||
|
||
export class SFColorRGBA extends X3DField {
|
||
constructor(r?: number, g?: number, b?: number, a?: number);
|
||
r: number;
|
||
g: number;
|
||
b: number;
|
||
a: number;
|
||
copy(): SFColorRGBA;
|
||
isDefaultValue(): boolean;
|
||
set(r: number, g: number, b: number): SFColorRGBA;
|
||
getHSVA(result: number[]): number[];
|
||
setHSVA(h: number, s: number, v: number): void;
|
||
lerp(destination: SFColor, t: number): SFColorRGBA;
|
||
static typeName: 'SFColor';
|
||
}
|
||
|
||
export class SFDouble extends X3DField {
|
||
constructor(arg?: unknown);
|
||
copy(): SFDouble;
|
||
isDefaultValue(): boolean;
|
||
set(arg: unknown): void;
|
||
valueOf(): number;
|
||
}
|
||
|
||
export class SFImage extends X3DField {
|
||
constructor(width?: number, height?: number,
|
||
num_components?: number, array?: number[]);
|
||
x: number;
|
||
y: number;
|
||
width: number;
|
||
height: number;
|
||
comp: number;
|
||
array: number[];
|
||
copy(): SFImage;
|
||
isDefaultValue(): boolean;
|
||
set(other: SFImage): void;
|
||
}
|
||
|
||
export class SFInt32 extends X3DField {
|
||
constructor(val?: number);
|
||
copy(): SFInt32;
|
||
set(val?: number): void;
|
||
valueOf(): number;
|
||
}
|
||
|
||
export class SFMatrix3 extends X3DField {
|
||
constructor();
|
||
constructor(r1: SFVec3, r2: SFVec3, r3: SFVec3);
|
||
constructor(a: number, b: number, c: number,
|
||
d: number, e: number, f: number,
|
||
g: number, h: number, i: number);
|
||
copy(): SFMatrix3;
|
||
isDefaultValue(): boolean;
|
||
set(other: SFMatrix3): void;
|
||
setTransform(translation: SFVec2, rotation: number, scaleFactor: SFVec2,
|
||
scaleOrientation: number, center: SFVec2): void;
|
||
getTransform(translation: SFVec2, rotation: SFDouble, scaleFactor: SFVec2,
|
||
scaleOrientation: SFDouble, center: SFVec2): void;
|
||
determinant(): number;
|
||
inverse(): SFMatrix3;
|
||
transpose(): SFMatrix3;
|
||
multLeft(A: SFMatrix3): SFMatrix3;
|
||
multRight(B: SFMatrix3): SFMatrix3;
|
||
multVecMatrix(row: SFVec2): SFVec2;
|
||
multVecMatrix(row: SFVec3): SFVec3;
|
||
multMatrixVec(col: SFVec2): SFVec2;
|
||
multMatrixVec(col: SFVec3): SFVec3;
|
||
multDirMatrix(row: SFVec2): SFVec2;
|
||
multMatrixDir(col: SFVec2): SFVec2;
|
||
}
|
||
|
||
export class SFMatrix4 extends X3DField {
|
||
constructor();
|
||
constructor(r1: SFVec4, r2: SFVec4, r3: SFVec4, r4: SFVec4);
|
||
constructor(a: number, b: number, c: number, d: number,
|
||
e: number, f: number, g: number, h: number,
|
||
i: number, j: number, k: number, l: number,
|
||
m: number, n: number, o: number, p: number);
|
||
copy(): SFMatrix4;
|
||
isDefaultValue(): boolean;
|
||
set(other: SFMatrix4): void;
|
||
setTransform(translation: SFVec3, rotation: SFRotation,
|
||
scaleFactor: SFVec3, scaleOrientation: SFRotation,
|
||
center: SFVec3): void;
|
||
getTransform(translation: SFVec3, rotation: SFRotation,
|
||
scaleFactor: SFVec3, scaleOrientation: SFRotation,
|
||
center: SFVec3): void;
|
||
determinant(): number;
|
||
inverse(): SFMatrix4;
|
||
transpose(): SFMatrix4;
|
||
multLeft(A: SFMatrix4): SFMatrix4;
|
||
multRight(B: SFMatrix4): SFMatrix4;
|
||
multVecMatrix(row: SFVec4): SFVec4;
|
||
multVecMatrix(row: SFVec3): SFVec3;
|
||
multMatrixVec(col: SFVec4): SFVec4;
|
||
multMatrixVec(col: SFVec3): SFVec3;
|
||
multDirMatrix(row: SFVec3): SFVec3;
|
||
multMatrixDir(col: SFVec3): SFVec3;
|
||
}
|
||
|
||
export interface SFNode extends X3DField {
|
||
// constructor(vrmlSyntax: string); // throws error, anyway
|
||
|
||
// Each subclass of SFNode for the different node types
|
||
// has various properties, that will be defined for
|
||
// each one below. But as far as I can see, they all have metadata
|
||
// properties:
|
||
metadata: SFNode;
|
||
|
||
copy(instance?: unknown): SFNode; // not sure what argument does...
|
||
isDefaultValue(): boolean;
|
||
set(other: SFNode): void;
|
||
dispose(): void;
|
||
// stupid WET TypeScript won't just overload the base class method:
|
||
addFieldCallback(key: unknown, callback: FieldCallback): void;
|
||
addFieldCallback(name: string, key: unknown,
|
||
callback: (value: unknown) => void): void;
|
||
getFieldDefinitions(): FieldDefinitionArray;
|
||
getField(name: string): X3DField;
|
||
getNodeName(): string;
|
||
getNodeDisplayName(): string;
|
||
getNodeType(): number[]; // Array of Node Type constants from X3DConstant
|
||
getNodeTypeName(): string;
|
||
getNodeUserData(key: unknown): unknown;
|
||
removeFieldCallback(key: unknown): void;
|
||
removeFieldCallback(name: string, key: unknown): void;
|
||
removeNodeUserData(key: unknown): void;
|
||
setNodeUserData(key: unknown, data: unknown): unknown;
|
||
toVRMLString(options?: VRMLOptions): string;
|
||
toXMLString(options?: VRMLOptions): string;
|
||
toJSONString(options?: VRMLOptions): string;
|
||
valueOf(): unknown; // what is proper type? May depend on what kind...
|
||
}
|
||
|
||
interface SFNodeAcousticProperties extends SFNode {
|
||
description: string;
|
||
enabled: boolean;
|
||
absorption: number;
|
||
refraction: number;
|
||
diffuse: number;
|
||
specular: number;
|
||
}
|
||
|
||
interface SFNodeAnalyser extends SFNode {
|
||
description: string;
|
||
enabled: boolean;
|
||
gain: number;
|
||
fftSize: number;
|
||
minDecibels: number;
|
||
maxDecibels: number;
|
||
smoothingTimeConstant: number;
|
||
tailTime: SFTime;
|
||
}
|
||
|
||
interface Positioner extends SFNode {
|
||
visible: boolean;
|
||
bboxDisplay: boolean;
|
||
bboxSize: SFVec3;
|
||
bboxCenter: SFVec3;
|
||
}
|
||
|
||
interface GroupingFields {
|
||
addChildren: X3DArrayField<SFNode>;
|
||
removeChildren: X3DArrayField<SFNode>;
|
||
children: X3DArrayField<SFNode>;
|
||
}
|
||
|
||
interface X3DGroupingNode extends Positioner, GroupingFields { }
|
||
|
||
interface URLFields {
|
||
description: string;
|
||
load: boolean;
|
||
url: X3DArrayField<string>;
|
||
autoRefresh: SFTime;
|
||
autoRefreshTimeLimit: SFTime;
|
||
}
|
||
|
||
interface SFNodeAnchor extends X3DGroupingNode {
|
||
parameter: X3DArrayField<string>;
|
||
}
|
||
|
||
interface SFNodeAppearance extends SFNode {
|
||
acousticProperties: SFNodeAcousticProperties;
|
||
alphaMode: 'AUTO' | 'OPAQUE' | 'MASK' | 'BLEND';
|
||
alphaCutoff: number;
|
||
pointProperties: SFNodePointProperties;
|
||
lineProperties: SFNodeLineProperties;
|
||
fillProperties: SFNodeFillProperties;
|
||
material: SFNodeMaterial;
|
||
backMaterial: SFNodeMaterial;
|
||
texture: SFNode;
|
||
textureTransform: SFNodeTextureTransform;
|
||
shaders: X3DArrayField<SFNode>;
|
||
blendMode: SFNodeBlendMode;
|
||
}
|
||
|
||
interface X3DTimeDependentNode extends SFNode {
|
||
startTime: SFTime;
|
||
resumeTime: SFTime;
|
||
pauseTime: SFTime;
|
||
stopTime: SFTime;
|
||
isPaused: boolean;
|
||
isActive: boolean;
|
||
elapsedTime: SFTime;
|
||
}
|
||
|
||
interface SFNodeAudioClip extends X3DTimeDependentNode, URLFields {
|
||
enabled: boolean;
|
||
gain: number;
|
||
pitch: number;
|
||
loop: boolean;
|
||
duration_changed: SFTime;
|
||
}
|
||
|
||
interface ChannelFields extends SFNode {
|
||
description: string;
|
||
enabled: boolean;
|
||
gain: number;
|
||
channelCount: number;
|
||
channelCountMode: 'MAX' | 'CLAMPED-MAX' | 'EXPLICIT';
|
||
channelInterpretation: 'SPEAKERS' | 'DISCRETE';
|
||
}
|
||
|
||
interface X3DSoundDestinationNode extends ChannelFields {
|
||
mediaDeviceId: string;
|
||
isActive: boolean;
|
||
children: X3DArrayField<SFNode>;
|
||
}
|
||
|
||
interface SFNodeAudioDestination extends X3DSoundDestinationNode {
|
||
maxChannelCount: number;
|
||
}
|
||
|
||
interface X3DBindableNode extends SFNode {
|
||
set_bind: boolean;
|
||
isBound: boolean;
|
||
bindTime: SFTime;
|
||
}
|
||
|
||
interface X3DBackgroundNode extends X3DBindableNode {
|
||
skyAngle: X3DArrayField<number>;
|
||
skyColor: X3DArrayField<SFColor>;
|
||
groundAngle: X3DArrayField<number>;
|
||
groundColor: X3DArrayField<SFColor>;
|
||
transparency: number;
|
||
}
|
||
|
||
interface SFNodeBackground extends X3DBackgroundNode {
|
||
frontUrl: X3DArrayField<string>;
|
||
backUrl: X3DArrayField<string>;
|
||
leftUrl: X3DArrayField<string>;
|
||
rightUrl: X3DArrayField<string>;
|
||
topUrl: X3DArrayField<string>;
|
||
bottomUrl: X3DArrayField<string>;
|
||
}
|
||
|
||
interface SFNodeBillboard extends X3DGroupingNode {
|
||
axisOfRotation: SFVec3;
|
||
}
|
||
|
||
interface SFNodeBiquadFilter extends X3DTimeDependentNode, ChannelFields {
|
||
frequency: number;
|
||
detune: number;
|
||
type: 'LOWPASS' | 'HIGHPASS' | 'BANDPASS'
|
||
| 'LOWSHELF' | 'HIGHSHELF' | 'PEAKING' | 'NOTCH' | 'ALLPASS';
|
||
qualityFactor: number;
|
||
tailTime: SFTime;
|
||
children: X3DArrayField<SFNode>;
|
||
}
|
||
|
||
type BlendFactor = 'ZERO' | 'ONE'
|
||
| 'SRC_COLOR' | 'ONE_MINUS_SRC_COLOR'
|
||
| 'DST_COLOR' | 'ONE_MINUS_DST_COLOR'
|
||
| 'SRC_ALPHA' | 'ONE_MINUS_SRC_ALPHA'
|
||
| 'DST_ALPHA' | 'ONE_MINUS_DST_ALPHA'
|
||
| 'CONSTANT_COLOR' | 'ONE_MINUS_CONSTANT_COLOR'
|
||
| 'CONSTANT_ALPHA' | 'ONE_MINUS_CONSTANT_ALPHA'
|
||
|
||
type BlendEquation = 'FUNC_ADD' | 'FUNC_SUBTRACT' | 'FUNC_REVERSE_SUBTRACT'
|
||
|
||
interface SFNodeBlendMode extends SFNode {
|
||
blendColor: SFColorRGBA;
|
||
sourceColorFactor: BlendFactor;
|
||
sourceAlphaFactor: BlendFactor;
|
||
destinationColorFactor: BlendFactor;
|
||
destinationAlphaFactor: BlendFactor;
|
||
colorEquation: BlendEquation;
|
||
alphaEquation: BlendEquation;
|
||
}
|
||
|
||
interface SFNodeBox extends SFNode {
|
||
size: SFVec3;
|
||
solid: boolean;
|
||
}
|
||
|
||
interface SFNodeBufferAudioSource
|
||
extends X3DTimeDependentNode, ChannelFields, URLFields {
|
||
detune: number;
|
||
buffer: X3DArrayField<number>;
|
||
bufferDuration: SFTime;
|
||
bufferLength: number;
|
||
numberOfChannels: number;
|
||
sampleRate: number;
|
||
playbackRate: number;
|
||
loopStart: SFTime;
|
||
loopEnd: SFTime;
|
||
loop: boolean;
|
||
}
|
||
|
||
interface SFNodeChannelMerger extends ChannelFields {
|
||
children: X3DArrayField<SFNode>;
|
||
}
|
||
|
||
interface SFNodeChannelSelector extends ChannelFields {
|
||
channelSelection: number;
|
||
children: X3DArrayField<SFNode>;
|
||
}
|
||
|
||
interface SFNodeChannelSplitter extends ChannelFields {
|
||
children: X3DArrayField<SFNode>;
|
||
outputs: X3DArrayField<SFNode>;
|
||
}
|
||
|
||
interface SFNodeClipPlane extends SFNode {
|
||
enabled: boolean;
|
||
plane: SFVec4;
|
||
}
|
||
|
||
interface SFNodeCollision extends X3DGroupingNode {
|
||
enabled: boolean;
|
||
isActive: boolean;
|
||
collideTime: SFTime;
|
||
proxy: SFNode;
|
||
}
|
||
|
||
interface SFNodeColor extends SFNode {
|
||
color: X3DArrayField<SFColor>;
|
||
}
|
||
|
||
interface SFNodeColorRGBA extends SFNode {
|
||
color: X3DArrayField<SFColorRGBA>;
|
||
}
|
||
|
||
interface X3DChaserNode<T> extends SFNode {
|
||
set_value: T;
|
||
set_destination: T;
|
||
initialValue: T;
|
||
initialDestination: T;
|
||
duration: SFTime;
|
||
isActive: boolean;
|
||
value_changed: T;
|
||
}
|
||
|
||
interface X3DDamperNode<T> extends SFNode {
|
||
set_value: T;
|
||
set_destination: T;
|
||
initialValue: T;
|
||
initialDestination: T;
|
||
order: number;
|
||
tau: SFTime;
|
||
tolerance: number;
|
||
isActive: boolean;
|
||
value_changed: T;
|
||
}
|
||
|
||
interface X3DInterpolatorNode<T,V> extends SFNode {
|
||
set_fraction: number;
|
||
key: X3DArrayField<number>;
|
||
keyValue: X3DArrayField<T>;
|
||
value_changed: V;
|
||
}
|
||
|
||
interface X3DShaderNode extends SFNode {
|
||
activate: boolean;
|
||
isSelected: boolean;
|
||
isValid: boolean;
|
||
language: string;
|
||
}
|
||
|
||
interface SFNodeComposedShader extends X3DShaderNode {
|
||
parts: X3DArrayField<SFNodeShaderPart>;
|
||
}
|
||
|
||
interface SFNodeCone extends SFNode {
|
||
side: boolean;
|
||
bottom: boolean;
|
||
height: number;
|
||
bottomRadius: number;
|
||
solid: boolean;
|
||
}
|
||
|
||
interface SFNodeConvolver extends X3DTimeDependentNode, ChannelFields {
|
||
buffer: X3DArrayField<number>;
|
||
normalize: boolean;
|
||
tailTime: SFTime;
|
||
children: X3DArrayField<SFNode>;
|
||
}
|
||
|
||
interface SFNodeCoordinate extends SFNode {
|
||
point: X3DArrayField<SFVec3>;
|
||
}
|
||
|
||
interface SFNodeCylinder extends SFNode {
|
||
top: boolean;
|
||
side: boolean;
|
||
bottom: boolean;
|
||
height: number;
|
||
radius: number;
|
||
solid: boolean;
|
||
}
|
||
|
||
interface X3DPointingDeviceSensorNode extends SFNode {
|
||
description: string;
|
||
enabled: boolean;
|
||
isOver: boolean;
|
||
isActive: boolean;
|
||
}
|
||
|
||
interface X3DDragSensorNode extends X3DPointingDeviceSensorNode {
|
||
offset: number;
|
||
autoOffset: boolean;
|
||
trackPoint_changed: SFVec3;
|
||
}
|
||
|
||
interface SFNodeCylinderSensor extends X3DDragSensorNode {
|
||
axisRotation: SFRotation,
|
||
diskAngle: number;
|
||
minAngle: number;
|
||
maxAngle: number;
|
||
rotation_changed: SFRotation;
|
||
}
|
||
|
||
interface SFNodeDelay extends X3DTimeDependentNode, ChannelFields {
|
||
delayTime: SFTime;
|
||
maxDelayTime: SFTime;
|
||
tailTime: SFTime;
|
||
children: X3DArrayField<SFNode>;
|
||
}
|
||
|
||
interface X3DLightNode extends SFNode {
|
||
global: boolean;
|
||
on: boolean;
|
||
color: SFColor;
|
||
intensity: number;
|
||
ambientIntensity: number;
|
||
shadows: boolean;
|
||
shadowColor: SFColor;
|
||
shadowIntensity: number;
|
||
shadowBias: number;
|
||
shadowMapSize: number;
|
||
}
|
||
|
||
interface SFNodeDirectionalLight extends X3DLightNode {
|
||
direction: SFVec3;
|
||
}
|
||
|
||
interface SFNodeDynamicsCompressor
|
||
extends X3DTimeDependentNode, ChannelFields {
|
||
attack: number;
|
||
knee: number;
|
||
ratio: number;
|
||
reduction: number;
|
||
release: SFTime;
|
||
threshold: number;
|
||
tailTime: SFTime;
|
||
children: X3DArrayField<SFNode>;
|
||
}
|
||
|
||
interface SFNodeEaseInEaseOut extends SFNode {
|
||
set_fraction: number;
|
||
key: X3DArrayField<number>;
|
||
easeInEaseOut: X3DArrayField<SFVec2>;
|
||
modifiedFraction_changed: number;
|
||
}
|
||
|
||
interface GeometrySubnodes {
|
||
attrib: X3DArrayField<SFNodeFloatVertexAttribute>;
|
||
fogCoord: SFNodeFogCoordinate;
|
||
color: SFNodeColor | SFNodeColorRGBA;
|
||
normal: SFNodeNormal;
|
||
}
|
||
|
||
interface SFNodeElevationGrid extends SFNode, GeometrySubnodes {
|
||
set_height: X3DArrayField<number>;
|
||
xDimension: number;
|
||
zDimension: number;
|
||
xSpacing: number;
|
||
zSpacing: number;
|
||
solid: boolean;
|
||
ccw: boolean;
|
||
creaseAngle: number;
|
||
colorPerVertex: boolean;
|
||
normalPerVertex: boolean;
|
||
texCoord: SFNode;
|
||
height: X3DArrayField<number>;
|
||
}
|
||
|
||
interface SFNodeEnvironmentLight extends X3DLightNode {
|
||
rotation: SFRotation;
|
||
diffuseCoefficients: X3DArrayField<number>;
|
||
diffuse: SFNode;
|
||
diffuseTexture: SFNode;
|
||
specularTexture: SFNode;
|
||
}
|
||
|
||
interface SFNodeExtrusion extends SFNode {
|
||
set_crossSection: X3DArrayField<SFVec2>;
|
||
set_orientation: X3DArrayField<SFRotation>;
|
||
set_scale: X3DArrayField<SFVec2>;
|
||
set_spine: X3DArrayField<SFVec3>;
|
||
beginCap: boolean;
|
||
endCap: boolean;
|
||
solid: boolean;
|
||
ccw: boolean;
|
||
convex: boolean;
|
||
creaseAngle: number;
|
||
crossSection: X3DArrayField<SFVec2>;
|
||
orientation: X3DArrayField<SFRotation>;
|
||
scale: X3DArrayField<SFVec2>;
|
||
spine: X3DArrayField<SFVec3>;
|
||
}
|
||
|
||
interface SFNodeFillProperties extends SFNode {
|
||
filled: boolean;
|
||
hatched: boolean;
|
||
hatchStyle: number;
|
||
hatchColor: SFColor;
|
||
}
|
||
|
||
interface SFNodeFloatVertexAttribute extends SFNode {
|
||
name: string;
|
||
numComponents: number;
|
||
value: X3DArrayField<number>;
|
||
}
|
||
|
||
interface FogCommon extends SFNode {
|
||
fogType: 'LINEAR' | 'EXPONENTIAL';
|
||
color: SFColor;
|
||
visibilityRange: number;
|
||
}
|
||
|
||
interface SFNodeFog extends X3DBindableNode, FogCommon { }
|
||
|
||
interface SFNodeFogCoordinate extends SFNode {
|
||
depth: X3DArrayField<number>;
|
||
}
|
||
|
||
interface SFNodeFontStyle extends SFNode {
|
||
language: string;
|
||
family: X3DArrayField<string>;
|
||
style: 'PLAIN' | 'BOLD' | 'ITALIC' | 'BOLDITALIC' | '';
|
||
size: number;
|
||
spacing: number;
|
||
horizontal: boolean;
|
||
leftToRight: boolean;
|
||
topToBottom: boolean;
|
||
justify: X3DArrayField<'BEGIN' | 'END' | 'FIRST' | 'MIDDLE' | ''>;
|
||
}
|
||
|
||
interface SFNodeGain extends X3DTimeDependentNode, ChannelFields {
|
||
tailTime: SFTime;
|
||
children: X3DArrayField<SFNode>;
|
||
}
|
||
|
||
interface Texture2DFields {
|
||
repeatS: boolean;
|
||
repeatT: boolean;
|
||
textureProperties: SFNodeTextureProperties;
|
||
}
|
||
|
||
interface SFNodeImageTexture extends SFNode, URLFields, Texture2DFields { }
|
||
|
||
interface IndexedColorCoord {
|
||
set_colorIndex: X3DArrayField<number>;
|
||
set_coordIndex: X3DArrayField<number>;
|
||
colorIndex: X3DArrayField<number>;
|
||
coordIndex: X3DArrayField<number>;
|
||
color: SFNodeColor | SFNodeColorRGBA;
|
||
coord: SFNodeCoordinate;
|
||
}
|
||
|
||
interface SFNodeIndexedFaceSet extends SFNodeIndexedLineSet {
|
||
set_texCoordIndex: X3DArrayField<number>;
|
||
set_normalIndex: X3DArrayField<number>;
|
||
solid: boolean;
|
||
ccw: boolean;
|
||
convex: boolean;
|
||
creaseAngle: number;
|
||
normalPerVertex: boolean;
|
||
texCoordIndex: X3DArrayField<number>;
|
||
normalIndex: X3DArrayField<number>;
|
||
texCoord: SFNode;
|
||
}
|
||
|
||
interface SFNodeIndexedLineSet
|
||
extends SFNode, GeometrySubnodes, IndexedColorCoord {
|
||
colorPerVertex: boolean;
|
||
}
|
||
|
||
interface SFNodeTriangleSet extends SFNode, GeometrySubnodes {
|
||
solid: boolean;
|
||
ccw: boolean;
|
||
colorPerVertex: boolean;
|
||
normalPerVertex: boolean;
|
||
texCoord: SFNode;
|
||
coord: SFNodeCoordinate;
|
||
}
|
||
|
||
interface IndexedTriangles extends SFNodeTriangleSet {
|
||
set_index: X3DArrayField<number>;
|
||
index: X3DArrayField<number>;
|
||
}
|
||
|
||
interface SFNodeInline extends Positioner, URLFields {
|
||
global: boolean;
|
||
}
|
||
|
||
interface SFNodeLOD extends X3DGroupingNode {
|
||
forceTransitions: boolean;
|
||
center: SFVec3;
|
||
range: X3DArrayField<number>;
|
||
level_changed: number;
|
||
}
|
||
|
||
interface SFNodeLayer extends SFNode, GroupingFields {
|
||
pickable: boolean;
|
||
objectType: X3DArrayField<string>;
|
||
visible: boolean;
|
||
viewport: SFNodeViewport;
|
||
}
|
||
|
||
interface SFNodeLayerSet extends SFNode {
|
||
activeLayer: number;
|
||
order: X3DArrayField<number>;
|
||
layers: X3DArrayField<SFNodeLayer>;
|
||
}
|
||
|
||
interface SFNodeLineProperties extends SFNode {
|
||
applied: boolean;
|
||
linetype: number;
|
||
linewidthScaleFactor: number;
|
||
}
|
||
|
||
interface SFNodeLineSet extends SFNode, GeometrySubnodes {
|
||
vertexCount: X3DArrayField<number>;
|
||
coord: SFNodeCoordinate;
|
||
}
|
||
|
||
interface SFNodeListenerPointSource extends X3DTimeDependentNode {
|
||
description: string;
|
||
enabled: boolean;
|
||
orientation: SFRotation;
|
||
gain: number;
|
||
dopplerEnabled: boolean;
|
||
interauralDistance: number;
|
||
trackCurrentView: boolean;
|
||
}
|
||
|
||
interface SFNodeLoadSensor extends SFNode {
|
||
enabled: boolean;
|
||
timeOut: SFTime;
|
||
isActive: boolean;
|
||
isLoaded: boolean;
|
||
progress: number;
|
||
loadTime: SFTime;
|
||
children: X3DArrayField<SFNode>;
|
||
}
|
||
|
||
interface SFNodeLocalFog extends FogCommon {
|
||
enabled: boolean;
|
||
}
|
||
|
||
interface SFNodeUnlitMaterial extends SFNode {
|
||
emissiveColor: SFColor;
|
||
emissiveTextureMapping: string;
|
||
emissiveTexture: SFNode;
|
||
normalScale: number;
|
||
normalTextureMapping: string;
|
||
normalTexture: SFNode;
|
||
transparency: number;
|
||
}
|
||
|
||
interface MaterialCommon extends SFNodeUnlitMaterial {
|
||
occlusionStrength: number;
|
||
occlusionTextureMapping: string;
|
||
occlusionTexture: SFNode;
|
||
}
|
||
|
||
interface SFNodeMaterial extends MaterialCommon {
|
||
ambientIntensity: number;
|
||
ambientTextureMapping: string;
|
||
ambientTexture: SFNode;
|
||
diffuseColor: SFColor;
|
||
diffuseTextureMapping: string;
|
||
diffuseTexture: SFNode;
|
||
specularColor: SFColor;
|
||
specularTextureMapping: string;
|
||
specularTexture: SFNode;
|
||
shininess: number;
|
||
shininessTextureMapping: string;
|
||
shininessTexture: SFNode;
|
||
}
|
||
|
||
interface SFNodeMatrix3VertexAttribute extends SFNode {
|
||
name: string;
|
||
value: X3DArrayField<SFMatrix3>;
|
||
}
|
||
|
||
interface SFNodeMatrix4VertexAttribute extends SFNode {
|
||
name: string;
|
||
value: X3DArrayField<SFMatrix4>;
|
||
}
|
||
|
||
interface X3DMetadataNode extends SFNode {
|
||
name: string;
|
||
reference: string;
|
||
}
|
||
|
||
interface MetadataInstance<T> extends X3DMetadataNode {
|
||
value: X3DArrayField<T>;
|
||
}
|
||
|
||
interface SFNodeMicrophoneSource extends X3DTimeDependentNode {
|
||
description: string;
|
||
enabled: boolean;
|
||
gain: number;
|
||
mediaDeviceId: string;
|
||
}
|
||
|
||
interface SFNodeMovieTexture extends SFNodeAudioClip, Texture2DFields {
|
||
speed: number;
|
||
}
|
||
|
||
interface SFNodeMultiTexture extends SFNode {
|
||
description: string;
|
||
color: SFColor;
|
||
alpha: number;
|
||
mode: X3DArrayField<string>;
|
||
source: X3DArrayField<string>;
|
||
function: X3DArrayField<string>;
|
||
texture: X3DArrayField<SFNode>;
|
||
}
|
||
|
||
interface SFNodeMultiTextureCoordinate extends SFNode {
|
||
texCoord: X3DArrayField<SFNodeTextureCoordinate>;
|
||
}
|
||
|
||
interface SFNodeMultiTextureTransform extends SFNode {
|
||
textureTransform: X3DArrayField<SFNodeTextureTransform>;
|
||
}
|
||
|
||
interface SFNodeNavigationInfo extends X3DBindableNode {
|
||
type: X3DArrayField<
|
||
'EXAMINE' | 'WALK' | 'FLY' | 'PLANE' | 'PLANE_create3000.github.io'
|
||
| 'PLANE_create3000.de' | 'LOOKAT' | 'EXPLORE' | 'ANY' | 'NONE'>;
|
||
avatarSize: X3DArrayField<number>;
|
||
speed: number;
|
||
headlight: boolean;
|
||
visibilityLimit: number;
|
||
transitionType: X3DArrayField<'TELEPORT' | 'LINEAR' | 'ANIMATE'>;
|
||
transitionTime: SFTime;
|
||
transitionComplete: boolean;
|
||
}
|
||
|
||
interface SFNodeNormal extends SFNode {
|
||
vector: X3DArrayField<SFVec3>;
|
||
}
|
||
|
||
interface X3DViewpointNode extends X3DBindableNode {
|
||
description: string;
|
||
position: SFVec3;
|
||
orientation: SFRotation;
|
||
centerOfRotation: SFVec3;
|
||
fieldOfView: number;
|
||
nearDistance: number;
|
||
farDistance: number;
|
||
viewAll: boolean;
|
||
jump: boolean;
|
||
retainUserOffsets: boolean;
|
||
navigationInfo: SFNodeNavigationInfo;
|
||
}
|
||
|
||
interface SFNodeOscillatorSource extends X3DTimeDependentNode {
|
||
description: string;
|
||
enabled: boolean;
|
||
gain: number;
|
||
frequency: number;
|
||
detune: number;
|
||
periodicWave: SFNodePeriodicWave;
|
||
}
|
||
|
||
interface SFNodePackagedShader extends X3DShaderNode, URLFields { }
|
||
|
||
interface SFNodePeriodicWave extends SFNode {
|
||
description: string;
|
||
enabled: boolean;
|
||
type: 'SINE' | 'SQUARE' | 'SAWTOOTH' | 'TRIANGLE' | 'CUSTOM'
|
||
optionsReal: X3DArrayField<number>;
|
||
optionsImag: X3DArrayField<number>;
|
||
}
|
||
|
||
interface SFNodePhysicalMaterial extends MaterialCommon {
|
||
baseColor: SFColor;
|
||
baseTextureMapping: String;
|
||
baseTexture: SFNode;
|
||
metallic: number;
|
||
roughness: number;
|
||
metallicRoughnessTextureMapping: string;
|
||
metallicRoughnessTexture: SFNode;
|
||
}
|
||
|
||
interface SFNodePixelTexture extends SFNode, Texture2DFields {
|
||
description: string;
|
||
image: SFImage;
|
||
}
|
||
|
||
interface SFNodePlaneSensor extends X3DDragSensorNode {
|
||
axisRotation: SFRotation;
|
||
minPosition: SFVec2;
|
||
maxPosition: SFVec2;
|
||
translation_changed: SFVec3;
|
||
}
|
||
|
||
interface SFNodePointLight extends X3DLightNode {
|
||
attenuation: SFVec3;
|
||
location: SFVec3;
|
||
radius: number;
|
||
}
|
||
|
||
interface SFNodePointProperties extends SFNode {
|
||
pointSizeScaleFactor: number;
|
||
pointSizeMinValue: number;
|
||
pointSizeMaxValue: number;
|
||
attenuation: SFVec3;
|
||
}
|
||
|
||
interface SFNodePointSet extends SFNode, GeometrySubnodes {
|
||
coord: SFNodeCoordinate;
|
||
}
|
||
|
||
interface SFNodeProgramShader extends X3DShaderNode {
|
||
programs: X3DArrayField<SFNodeShaderProgram>
|
||
}
|
||
|
||
interface X3DEnvironmentalSensorNode extends SFNode {
|
||
enabled: boolean;
|
||
size: SFVec3;
|
||
center: SFVec3;
|
||
enterTime: SFTime;
|
||
exitTime: SFTime;
|
||
isActive: boolean;
|
||
}
|
||
|
||
interface SFNodeProximitySensor extends X3DEnvironmentalSensorNode {
|
||
position_changed: SFVec3;
|
||
orientation_changed: SFRotation;
|
||
centerOfRotation_changed: SFVec3;
|
||
}
|
||
|
||
interface SFNodeScript extends SFNode, URLFields {
|
||
directOutput: boolean;
|
||
mustEvaluate: boolean;
|
||
}
|
||
|
||
interface SFNodeShaderPart extends SFNode, URLFields {
|
||
type: 'VERTEX' | 'FRAGMENT';
|
||
}
|
||
|
||
type SFNodeShaderProgram = SFNodeShaderPart; // Why are there two node types?
|
||
|
||
interface SFNodeShape extends Positioner {
|
||
castShadow: boolean;
|
||
appearance: SFNodeAppearance;
|
||
geometry: SFNode;
|
||
}
|
||
|
||
interface SoundCommon extends SFNode {
|
||
description: string;
|
||
enabled: boolean;
|
||
spatialize: boolean;
|
||
location: SFVec3;
|
||
direction: SFVec3;
|
||
intensity: number;
|
||
priority: number;
|
||
children: X3DArrayField<SFNode>;
|
||
}
|
||
|
||
interface SFNodeSound extends SFNode {
|
||
minBack: number;
|
||
minFront: number;
|
||
maxBack: number;
|
||
maxFront: number;
|
||
source: SFNode;
|
||
}
|
||
|
||
interface SFNodeSpatialSound extends SFNode {
|
||
coneInnerAngle: number;
|
||
coneOuterAngle: number;
|
||
coneOuterGain: number;
|
||
distanceModel: 'LINEAR' | 'INVERSE' | 'EXPONENTIAL';
|
||
dopplerEnabled: boolean;
|
||
enableHRTF: boolean;
|
||
gain: number;
|
||
maxDistance: number;
|
||
referenceDistance: number;
|
||
rolloffFactor: number;
|
||
}
|
||
|
||
interface SFNodeSphere extends SFNode {
|
||
radius: number;
|
||
solid: boolean;
|
||
}
|
||
|
||
interface SFNodeSphereSensor extends X3DPointingDeviceSensorNode {
|
||
rotation_changed: SFRotation;
|
||
}
|
||
|
||
interface SplineInterpolator<U> extends X3DInterpolatorNode<U,U> {
|
||
closed: boolean;
|
||
keyVelocity: X3DArrayField<U>;
|
||
normalizeVelocity: boolean;
|
||
}
|
||
|
||
interface SFNodeSpotLight extends SFNodePointLight {
|
||
direction: SFVec3;
|
||
beamWidth: number;
|
||
cutOffAngle: number;
|
||
}
|
||
|
||
interface SFNodeSquadOrientationInterpolator
|
||
extends X3DInterpolatorNode<SFRotation, SFRotation> {
|
||
closed: boolean;
|
||
}
|
||
|
||
interface SFNodeStaticGroup extends Positioner {
|
||
children: X3DArrayField<SFNode>;
|
||
}
|
||
|
||
interface SFNodeStreamAudioDestination extends X3DSoundDestinationNode {
|
||
streamIdentifier: X3DArrayField<string>;
|
||
}
|
||
|
||
interface SFNodeStreamAudioSource extends X3DTimeDependentNode {
|
||
description: string;
|
||
enabled: boolean;
|
||
gain: number;
|
||
streamIdentifier: X3DArrayField<string>;
|
||
}
|
||
|
||
interface SFNodeSwitch extends X3DGroupingNode {
|
||
whichChoice: number;
|
||
}
|
||
|
||
interface SFNodeText extends SFNode {
|
||
string: X3DArrayField<string>;
|
||
length: X3DArrayField<number>;
|
||
maxExtent: number;
|
||
solid: boolean;
|
||
origin: SFVec3;
|
||
textBounds: SFVec2;
|
||
lineBounds: X3DArrayField<SFVec2>;
|
||
fontStyle: SFNodeFontStyle;
|
||
}
|
||
|
||
interface SFNodeTextureBackground extends X3DBackgroundNode {
|
||
frontTexture: SFNode;
|
||
backTexture: SFNode;
|
||
leftTexture: SFNode;
|
||
rightTexture: SFNode;
|
||
topTexture: SFNode;
|
||
bottomTexture: SFNode;
|
||
}
|
||
|
||
interface SFNodeTextureCoordinate extends SFNode {
|
||
mapping: string;
|
||
point: X3DArrayField<SFVec2>;
|
||
}
|
||
|
||
interface SFNodeTextureCoordinateGenerator extends SFNode {
|
||
mapping: string;
|
||
mode: 'SPHERE' | 'SPHERE-LOCAL' | 'SPHERE-REFLECT' | 'SPHERE-REFLECT-LOCAL'
|
||
| 'COORD' | 'COORD-EYE' | 'NOISE' | 'NOISE-EYE' | 'CAMERASPACENORMAL'
|
||
| 'CAMERASPACEPOSITION' | 'CAMERASPACEREFLECTIONVECTOR' ;
|
||
parameter: X3DArrayField<number>;
|
||
}
|
||
|
||
interface SFNodeTextureProperties extends SFNode {
|
||
borderColor: SFColorRGBA;
|
||
borderWidth: number;
|
||
anisotropicDegree: number;
|
||
generateMipMaps: boolean;
|
||
minificationFilter: string;
|
||
magnificationFilter: string;
|
||
boundaryModeS: string;
|
||
boundaryModeT: string;
|
||
boundaryModeR: string;
|
||
textureCompression: string;
|
||
texturePriority: number;
|
||
}
|
||
|
||
interface SFNodeTextureTransform extends SFNode {
|
||
mapping: string;
|
||
translation: SFVec2;
|
||
rotation: number;
|
||
scale: SFVec2;
|
||
center: SFVec2;
|
||
}
|
||
|
||
interface SFNodeTimeSensor extends X3DTimeDependentNode {
|
||
description: string;
|
||
enabled: boolean;
|
||
cycleInterval: SFTime;
|
||
loop: boolean;
|
||
cycleTime: SFTime;
|
||
fraction_changed: number;
|
||
time: SFTime;
|
||
}
|
||
|
||
interface SFNodeTouchSensor extends X3DPointingDeviceSensorNode {
|
||
hitTexCoord_changed: SFVec2;
|
||
hitNormal_changed: SFVec3;
|
||
hitPoint_changed: SFVec3;
|
||
touchTime: SFTime;
|
||
}
|
||
|
||
interface SFNodeTransform extends X3DGroupingNode {
|
||
translation: SFVec3;
|
||
rotation: SFRotation;
|
||
scale: SFVec3;
|
||
scaleOrientation: SFRotation;
|
||
center: SFVec3;
|
||
}
|
||
|
||
interface SFNodeTransformSensor extends X3DEnvironmentalSensorNode {
|
||
position_changed: SFVec3;
|
||
orientation_changed: SFRotation;
|
||
targetObject: SFNode;
|
||
}
|
||
|
||
interface SFNodeTriangleFanSet extends SFNodeTriangleSet {
|
||
fanCount: X3DArrayField<number>;
|
||
}
|
||
|
||
interface SFNodeTriangleStripSet extends SFNodeTriangleSet {
|
||
stripCount: X3DArrayField<number>;
|
||
}
|
||
|
||
interface SFNodeTwoSidedMaterial extends SFNode {
|
||
ambientIntensity: number;
|
||
backAmbientIntensity: number;
|
||
backDiffuseColor: SFColor;
|
||
backEmissiveColor: SFColor;
|
||
backShininess: number;
|
||
backSpecularColor: SFColor;
|
||
backTransparency: number;
|
||
diffuseColor: SFColor;
|
||
emissiveColor: SFColor;
|
||
shininess: number;
|
||
separateBackColor: boolean;
|
||
specularColor: SFColor;
|
||
transparency: number;
|
||
}
|
||
|
||
interface SFNodeViewpointGroup extends SFNode {
|
||
description: string;
|
||
displayed: boolean;
|
||
retainUserOffsets: boolean;
|
||
size: SFVec3;
|
||
center: SFVec3;
|
||
children: X3DArrayField<SFNode>;
|
||
}
|
||
|
||
interface SFNodeViewport extends X3DGroupingNode {
|
||
clipBoundary: X3DArrayField<number>;
|
||
}
|
||
|
||
interface SFNodeWaveShaper extends X3DTimeDependentNode, ChannelFields {
|
||
curve: X3DArrayField<number>;
|
||
oversample: 'NONE' | '2x' | '4x';
|
||
tailTime: SFTime;
|
||
children: X3DArrayField<SFNode>;
|
||
}
|
||
|
||
interface SFNodeWorldInfo extends SFNode {
|
||
title: string;
|
||
info: X3DArrayField<string>;
|
||
}
|
||
|
||
export type SpecializeNodeType = {
|
||
AcousticProperties: SFNodeAcousticProperties,
|
||
Analyser: SFNodeAnalyser,
|
||
Anchor: SFNodeAnchor,
|
||
Appearance: SFNodeAppearance,
|
||
AudioClip: SFNodeAudioClip,
|
||
AudioDestination: SFNodeAudioDestination,
|
||
Background: SFNodeBackground,
|
||
Billboard: SFNodeBillboard,
|
||
BiquadFilter: SFNodeBiquadFilter,
|
||
BlendMode: SFNodeBlendMode,
|
||
Box: SFNodeBox,
|
||
BufferAudioSource: SFNodeBufferAudioSource,
|
||
ChannelMerger: SFNodeChannelMerger,
|
||
ChannelSelector: SFNodeChannelSelector,
|
||
ChannelSplitter: SFNodeChannelSplitter,
|
||
ClipPlane: SFNodeClipPlane,
|
||
Collision: SFNodeCollision,
|
||
Color: SFNodeColor,
|
||
ColorRGBA: SFNodeColorRGBA,
|
||
ColorChaser: X3DChaserNode<SFColor>,
|
||
ColorDamper: X3DDamperNode<SFColor>,
|
||
ColorInterpolator: X3DInterpolatorNode<SFColor, SFColor>,
|
||
ComposedShader: SFNodeComposedShader,
|
||
Cone: SFNodeCone,
|
||
Convolver: SFNodeConvolver,
|
||
Coordinate: SFNodeCoordinate,
|
||
CoordinateChaser: X3DChaserNode<X3DArrayField<SFVec3>>,
|
||
CoordinateDamper: X3DDamperNode<X3DArrayField<SFVec3>>,
|
||
CoordinateInterpolator: X3DInterpolatorNode<SFVec3, X3DArrayField<SFVec3>>,
|
||
CoordinateInterpolator2D:
|
||
X3DInterpolatorNode<SFVec2, X3DArrayField<SFVec2>>,
|
||
Cylinder: SFNodeCylinder,
|
||
CylinderSensor: SFNodeCylinderSensor,
|
||
Delay: SFNodeDelay,
|
||
DirectionalLight: SFNodeDirectionalLight,
|
||
DynamicsCompressor: SFNodeDynamicsCompressor,
|
||
EaseInEaseOut: SFNodeEaseInEaseOut,
|
||
ElevationGrid: SFNodeElevationGrid,
|
||
EnvironmentLight: SFNodeEnvironmentLight,
|
||
Extrusion: SFNodeExtrusion,
|
||
FillProperties: SFNodeFillProperties,
|
||
FloatVertexAttribute: SFNodeFloatVertexAttribute,
|
||
Fog: SFNodeFog,
|
||
FogCoordinate: SFNodeFogCoordinate,
|
||
FontStyle: SFNodeFontStyle,
|
||
Gain: SFNodeGain,
|
||
Group: X3DGroupingNode,
|
||
ImageTexture: SFNodeImageTexture,
|
||
IndexedFaceSet: SFNodeIndexedFaceSet,
|
||
IndexedLineSet: SFNodeIndexedLineSet,
|
||
IndexedTriangleFanSet: IndexedTriangles,
|
||
IndexedTriangleSet: IndexedTriangles,
|
||
IndexedTriangleStripSet: IndexedTriangles,
|
||
Inline: SFNodeInline,
|
||
LOD: SFNodeLOD,
|
||
Layer: SFNodeLayer,
|
||
LayerSet: SFNodeLayerSet,
|
||
LineProperties: SFNodeLineProperties,
|
||
LineSet: SFNodeLineSet,
|
||
ListenerPointSource: SFNodeListenerPointSource,
|
||
LoadSensor: SFNodeLoadSensor,
|
||
LocalFog: SFNodeLocalFog,
|
||
Material: SFNodeMaterial,
|
||
Matrix3VertexAttribute: SFNodeMatrix3VertexAttribute,
|
||
Matrix4VertexAttribute: SFNodeMatrix4VertexAttribute,
|
||
MetadataBoolean: MetadataInstance<boolean>,
|
||
MetadataDouble: MetadataInstance<number>,
|
||
MetadataFloat: MetadataInstance<number>,
|
||
MetadataInteger: MetadataInstance<number>,
|
||
MetadataSet: MetadataInstance<X3DMetadataNode>,
|
||
MetadataString: MetadataInstance<string>,
|
||
MicrophoneSource: SFNodeMicrophoneSource,
|
||
MovieTexture: SFNodeMovieTexture,
|
||
MultiTexture: SFNodeMultiTexture,
|
||
MultiTextureCoordinate: SFNodeMultiTextureCoordinate,
|
||
MultiTextureTransform: SFNodeMultiTextureTransform,
|
||
NavigationInfo: SFNodeNavigationInfo,
|
||
Normal: SFNodeNormal,
|
||
NormalInterpolator: X3DInterpolatorNode<SFVec3, X3DArrayField<SFVec3>>,
|
||
OrientationChaser: X3DChaserNode<SFRotation>,
|
||
OrientationDamper: X3DDamperNode<SFRotation>,
|
||
OrientationInterpolator: X3DInterpolatorNode<SFRotation, SFRotation>,
|
||
OrthoViewpoint: X3DViewpointNode,
|
||
OscillatorSource: SFNodeOscillatorSource,
|
||
PackagedShader: SFNodePackagedShader,
|
||
PeriodicWave: SFNodePeriodicWave,
|
||
PhysicalMaterial: SFNodePhysicalMaterial,
|
||
PixelTexture: SFNodePixelTexture,
|
||
PlaneSensor: SFNodePlaneSensor,
|
||
PointLight: SFNodePointLight,
|
||
PointProperties: SFNodePointProperties,
|
||
PointSet: SFNodePointSet,
|
||
PositionChaser: X3DChaserNode<SFVec3>,
|
||
PositionChaser2D: X3DChaserNode<SFVec2>,
|
||
PositionDamper: X3DDamperNode<SFVec3>,
|
||
PositionDamper2D: X3DDamperNode<SFVec2>,
|
||
PositionInterpolator: X3DInterpolatorNode<SFVec3, SFVec3>,
|
||
PositionInterpolator2D: X3DInterpolatorNode<SFVec2, SFVec2>,
|
||
ProgramShader: SFNodeProgramShader,
|
||
ProximitySensor: SFNodeProximitySensor,
|
||
ScalarChaser: X3DChaserNode<number>,
|
||
ScalarDamper: X3DDamperNode<number>,
|
||
ScalarInterpolator: X3DInterpolatorNode<number, number>,
|
||
Script: SFNodeScript,
|
||
ShaderPart: SFNodeShaderPart,
|
||
ShaderProgram: SFNodeShaderProgram,
|
||
Shape: SFNodeShape,
|
||
Sound: SFNodeSound,
|
||
SpatialSound: SFNodeSpatialSound,
|
||
Sphere: SFNodeSphere,
|
||
SphereSensor: SFNodeSphereSensor,
|
||
SplinePositionInterpolator: SplineInterpolator<SFVec3>,
|
||
SplinePositionInterpolator2D: SplineInterpolator<SFVec2>,
|
||
SplineScalarInterpolator: SplineInterpolator<number>,
|
||
SpotLight: SFNodePointLight,
|
||
SquadOrientationInterpolator: SFNodeSquadOrientationInterpolator,
|
||
StaticGroup: SFNodeStaticGroup,
|
||
StreamAudioDestination: SFNodeStreamAudioDestination,
|
||
StreamAudioSource: SFNodeStreamAudioSource,
|
||
Switch: SFNodeSwitch,
|
||
TexCoordChaser2D: X3DChaserNode<X3DArrayField<SFVec2>>,
|
||
TexCoordDamper2D: X3DDamperNode<X3DArrayField<SFVec2>>,
|
||
Text: SFNodeText,
|
||
TextureBackground: SFNodeTextureBackground,
|
||
TextureCoordinate: SFNodeTextureCoordinate,
|
||
TextureCoordinateGenerator: SFNodeTextureCoordinateGenerator,
|
||
TextureProperties: SFNodeTextureProperties,
|
||
TextureTransform: SFNodeTextureTransform,
|
||
TimeSensor: SFNodeTimeSensor,
|
||
TouchSensor: SFNodeTouchSensor,
|
||
Transform: SFNodeTransform,
|
||
TransformSensor: SFNodeTransformSensor,
|
||
TriangleFanSet: SFNodeTriangleFanSet,
|
||
TriangleSet: SFNodeTriangleSet,
|
||
TriangleStripSet: SFNodeTriangleStripSet,
|
||
TwoSidedMaterial: SFNodeTwoSidedMaterial,
|
||
UnlitMaterial: SFNodeUnlitMaterial,
|
||
Viewpoint: X3DViewpointNode,
|
||
ViewpointGroup: SFNodeViewpointGroup,
|
||
Viewport: SFNodeViewport,
|
||
VisibilitySensor: X3DEnvironmentalSensorNode,
|
||
WaveShaper: SFNodeWaveShaper,
|
||
WorldInfo: SFNodeWorldInfo,
|
||
[name: string]: SFNode // catchall
|
||
}
|
||
|
||
type FieldDefinitionArray = Map<unknown, X3DFieldDefinition>;
|
||
export type X3DFieldDefinition = {
|
||
accessType: number, // that's a guess
|
||
dataType: string,
|
||
name: string,
|
||
value: unknown // I don't think we can do better without parsing the
|
||
// possible values for dataType...
|
||
}
|
||
type VRMLOptions = {
|
||
style?: string,
|
||
indent?: string,
|
||
precision?: number,
|
||
doublePrecision?: number,
|
||
html?: boolean,
|
||
closingTags?: boolean
|
||
}
|
||
|
||
export class SFRotation extends X3DField {
|
||
constructor();
|
||
constructor(x: number, y: number, z: number, angle: number);
|
||
constructor(axis: SFVec3, angle: number);
|
||
constructor(from: SFVec3, to: SFVec3);
|
||
constructor(matrix: SFMatrix3);
|
||
x: number;
|
||
y: number;
|
||
z: number;
|
||
angle: number;
|
||
|
||
copy(): SFRotation;
|
||
isDefaultValue(): boolean;
|
||
set(other: SFRotation): void;
|
||
|
||
getAxis(): SFVec3;
|
||
getMatrix(): SFMatrix3;
|
||
inverse(): SFRotation;
|
||
multiply(other: SFRotation): SFRotation;
|
||
multVec(subject: SFVec3): SFVec3;
|
||
setAxis(axis: SFVec3): void;
|
||
setMatrix(matrix: SFMatrix3): void;
|
||
slerp(destination: SFRotation, t: number): SFRotation;
|
||
}
|
||
|
||
export class SFString extends X3DField {
|
||
constructor(arg?: unknown);
|
||
copy(): SFString;
|
||
isDefaultValue(): boolean;
|
||
set(arg: unknown): void;
|
||
valueOf(): string;
|
||
length: number;
|
||
}
|
||
|
||
export class SFTime extends X3DField {
|
||
constructor(arg?: unknown);
|
||
copy(): SFTime;
|
||
isDefaultValue(): boolean;
|
||
set(arg: unknown): void;
|
||
valueOf(): number; // I think that's the right type...
|
||
}
|
||
|
||
export class SFVec2 extends X3DField {
|
||
constructor(x?: number, y?: number);
|
||
x: number;
|
||
y: number;
|
||
|
||
copy(): SFVec2;
|
||
isDefaultValue(): boolean;
|
||
set(other: SFVec2): void;
|
||
|
||
abs(): SFVec2;
|
||
add(other: SFVec2): SFVec2;
|
||
distance(other: SFVec2): number;
|
||
divide(denominator: number): SFVec2;
|
||
divVec(other: SFVec2): SFVec2;
|
||
dot(other: SFVec2): number;
|
||
inverse(): SFVec2;
|
||
length(): number;
|
||
lerp(destination: SFVec2, t: number): SFVec2;
|
||
min(other: SFVec2): SFVec2;
|
||
max(other: SFVec2): SFVec2;
|
||
multiply(factor: number): SFVec2;
|
||
multVec(other: SFVec2): SFVec2;
|
||
negate(): SFVec2;
|
||
normalize(): SFVec2;
|
||
subtract(other: SFVec2): SFVec2;
|
||
}
|
||
|
||
export class SFVec3 extends X3DField {
|
||
constructor(x?: number, y?: number, z?: number);
|
||
x: number;
|
||
y: number;
|
||
z: number;
|
||
|
||
copy(): SFVec3;
|
||
isDefaultValue(): boolean;
|
||
set(other: SFVec3): void;
|
||
|
||
abs(): SFVec3;
|
||
add(other: SFVec3): SFVec3;
|
||
cross(other: SFVec3): SFVec3;
|
||
distance(other: SFVec3): number;
|
||
divide(denominator: number): SFVec3;
|
||
divVec(other: SFVec3): SFVec3;
|
||
dot(other: SFVec3): number;
|
||
inverse(): SFVec3;
|
||
length(): number;
|
||
lerp(destination: SFVec3, t: number): SFVec3;
|
||
min(other: SFVec3): SFVec3;
|
||
max(other: SFVec3): SFVec3;
|
||
multiply(factor: number): SFVec3;
|
||
multVec(other: SFVec3): SFVec3;
|
||
negate(): SFVec3;
|
||
normalize(): SFVec3;
|
||
subtract(other: SFVec3): SFVec3;
|
||
}
|
||
|
||
export class SFVec4 extends X3DField {
|
||
constructor(x?: number, y?: number, z?: number, w?: number);
|
||
x: number;
|
||
y: number;
|
||
z: number;
|
||
w: number;
|
||
|
||
copy(): SFVec4;
|
||
isDefaultValue(): boolean;
|
||
set(other: SFVec4): void;
|
||
|
||
abs(): SFVec4;
|
||
add(other: SFVec4): SFVec4;
|
||
distance(other: SFVec4): number;
|
||
divide(denominator: number): SFVec4;
|
||
divVec(other: SFVec4): SFVec4;
|
||
dot(other: SFVec4): number;
|
||
inverse(): SFVec4;
|
||
length(): number;
|
||
lerp(destination: SFVec4, t: number): SFVec4;
|
||
min(other: SFVec4): SFVec4;
|
||
max(other: SFVec4): SFVec4;
|
||
multiply(factor: number): SFVec4;
|
||
multVec(other: SFVec4): SFVec4;
|
||
negate(): SFVec4;
|
||
normalize(): SFVec4;
|
||
subtract(other: SFVec4): SFVec4;
|
||
}
|
||
|
||
type ArrayTest<T> = (elt: T, ix: boolean, arr: X3DArrayField<T>) => boolean
|
||
type ArrayAction<T> = (elt: T, ix: boolean, arr: X3DArrayField<T>) => void
|
||
type ArrayReducer<T,U> =
|
||
(acc: U, elt: T, ix: number, arr: X3DArrayField<T>) => U
|
||
export class X3DArrayField<T> extends X3DField {
|
||
constructor(...elts: T[]);
|
||
[index: number]: T;
|
||
length: number;
|
||
at(index: number): T;
|
||
entries(): IterableIterator<[number, T]>;
|
||
every(predicate: ArrayTest<T>): boolean;
|
||
fill(val: T, start?: number, end?: number): X3DArrayField<T>;
|
||
filter(predicate: ArrayTest<T>): X3DArrayField<T>;
|
||
find(test: ArrayTest<T>): T | undefined;
|
||
findIndex(test: ArrayTest<T>): number;
|
||
findLast(test: ArrayTest<T>): T | undefined;
|
||
findLastIndex(test: ArrayTest<T>): number;
|
||
forEach(action: ArrayAction<T>): void;
|
||
includes(needle: T): boolean;
|
||
indexOf(needle: T): number;
|
||
join(separator?: string): string;
|
||
keys(): number[];
|
||
lastIndexOf(needle: T): number;
|
||
map<U>(f: (elt: T, ix: number, arr: X3DArrayField<T>) => U): U[];
|
||
pop(): T;
|
||
push(...elts: T[]): number;
|
||
reduce<U>(f: ArrayReducer<T,U>, initial?: U): U;
|
||
reduceRight<U>(f: ArrayReducer<T,U>, initial?: U): U;
|
||
reverse(): X3DArrayField<T>;
|
||
shift(): T;
|
||
slice(start?: number, end?: number): X3DArrayField<T>;
|
||
some(predicate: ArrayTest<T>): boolean;
|
||
sort(comparator?: (a: T, b: T) => number): X3DArrayField<T>;
|
||
splice(start: number, deleteCount: number,
|
||
...rest: T[]) : X3DArrayField<T>;
|
||
toReversed(): X3DArrayField<T>;
|
||
toSorted(comparator?: (a: T, b: T) => number): X3DArrayField<T>;
|
||
toSpliced(start: number, deleteCount: number,
|
||
...rest: T[]) : X3DArrayField<T>;
|
||
unshift(...elts: T[]): number;
|
||
values(): IterableIterator<T>;
|
||
with(index: number, value: T): X3DArrayField<T>;
|
||
}
|
||
|
||
// would be better to make these enums...
|
||
export interface X3DConstant {
|
||
// Browser Event Constants
|
||
CONNECTION_ERROR: 0;
|
||
BROWSER_EVENT: 1;
|
||
INITIALIZED_EVENT: 2;
|
||
SHUTDOWN_EVENT: 3;
|
||
INITIALIZED_ERROR: 4;
|
||
// Load State Constants
|
||
NOT_STARTED_STATE: 0;
|
||
IN_PROGRESS_STATE: 1;
|
||
COMPLETE_STATE: 2;
|
||
FAILED_STATE: 3;
|
||
// Access Type Constants
|
||
initializeOnly: 1;
|
||
inputOnly: 2;
|
||
outputOnly: 4;
|
||
inputOutput: 7;
|
||
// Field Type Constants
|
||
SFBool: 0;
|
||
SFColor: 1;
|
||
SFColorRGBA: 2;
|
||
SFDouble: 3;
|
||
SFFloat: 4;
|
||
SFImage: 5;
|
||
SFInt32: 6;
|
||
SFMatrix3d: 7;
|
||
SFMatrix3f: 8;
|
||
SFMatrix4d: 9;
|
||
SFMatrix4f: 10;
|
||
SFNode: 11;
|
||
SFRotation: 12;
|
||
SFString: 13;
|
||
SFTime: 14;
|
||
SFVec2d: 15;
|
||
SFVec2f: 16;
|
||
SFVec3d: 17;
|
||
SFVec3f: 18;
|
||
SFVec4d: 19;
|
||
SFVec4f: 20;
|
||
MFBool: 22;
|
||
MFColor: 23;
|
||
MFColorRGBA: 24;
|
||
MFDouble: 25;
|
||
MFFloat: 26;
|
||
MFImage: 27;
|
||
MFInt32: 28;
|
||
MFMatrix3d: 29;
|
||
MFMatrix3f: 30;
|
||
MFMatrix4d: 31;
|
||
MFMatrix4f: 32;
|
||
MFNode: 33;
|
||
MFRotation: 34;
|
||
MFString: 35;
|
||
MFTime: 36;
|
||
MFVec2d: 37;
|
||
MFVec2f: 38;
|
||
MFVec3d: 39;
|
||
MFVec3f: 40;
|
||
MFVec4d: 41;
|
||
MFVec4f: 42;
|
||
// Concrete Node Types
|
||
AcousticProperties: 140;
|
||
Analyser: 155;
|
||
Anchor: 96;
|
||
Appearance: 141;
|
||
AudioClip: 156;
|
||
AudioDestination: 157;
|
||
Background: 21;
|
||
Billboard: 88;
|
||
BiquadFilter: 158;
|
||
Box: 49;
|
||
BufferAudioSource: 159;
|
||
ChannelMerger: 160;
|
||
ChannelSelector: 161;
|
||
ChannelSplitter: 162;
|
||
ClipPlane: 108;
|
||
Collision: 89;
|
||
Color: 109;
|
||
ColorChaser: 32;
|
||
ColorDamper: 33;
|
||
ColorInterpolator: 64;
|
||
ColorRGBA: 110;
|
||
ComposedShader: 129;
|
||
Cone: 50;
|
||
Convolver: 163;
|
||
Coordinate: 111;
|
||
CoordinateChaser: 34;
|
||
CoordinateDamper: 35;
|
||
CoordinateInterpolator: 65;
|
||
CoordinateInterpolator2D: 66;
|
||
Cylinder: 51;
|
||
CylinderSensor: 101;
|
||
Delay: 164;
|
||
DirectionalLight: 83;
|
||
DynamicsCompressor: 165;
|
||
EaseInEaseOut: 67;
|
||
ElevationGrid: 52;
|
||
EnvironmentLight: 84;
|
||
Extrusion: 53;
|
||
FillProperties: 142;
|
||
FloatVertexAttribute: 130;
|
||
Fog: 22;
|
||
FogCoordinate: 23;
|
||
FontStyle: 203;
|
||
Gain: 166;
|
||
Group: 56;
|
||
ImageTexture: 181;
|
||
IndexedFaceSet: 54;
|
||
IndexedLineSet: 112;
|
||
IndexedTriangleFanSet: 113;
|
||
IndexedTriangleSet: 114;
|
||
IndexedTriangleStripSet: 115;
|
||
Inline: 97;
|
||
LOD: 90;
|
||
Layer: 78;
|
||
LayerSet: 79;
|
||
LineProperties: 143;
|
||
LineSet: 116;
|
||
ListenerPointSource: 167;
|
||
LoadSensor: 98;
|
||
LocalFog: 24;
|
||
Material: 144;
|
||
Matrix3VertexAttribute: 131;
|
||
Matrix4VertexAttribute: 132;
|
||
MetadataBoolean: 7;
|
||
MetadataDouble: 8;
|
||
MetadataFloat: 9;
|
||
MetadataInteger: 10;
|
||
MetadataSet: 11;
|
||
MetadataString: 12;
|
||
MicrophoneSource: 168;
|
||
MovieTexture: 182;
|
||
MultiTexture: 183;
|
||
MultiTextureCoordinate: 184;
|
||
MultiTextureTransform: 185;
|
||
NavigationInfo: 91;
|
||
Normal: 117;
|
||
NormalInterpolator: 68;
|
||
OrientationChaser: 36;
|
||
OrientationDamper: 37;
|
||
OrientationInterpolator: 69;
|
||
OrthoViewpoint: 92;
|
||
OscillatorSource: 169;
|
||
PackagedShader: 133;
|
||
PeriodicWave: 170;
|
||
PhysicalMaterial: 145;
|
||
PixelTexture: 186;
|
||
PlaneSensor: 102;
|
||
PointLight: 85;
|
||
PointProperties: 146;
|
||
PointSet: 118;
|
||
PositionChaser: 38;
|
||
PositionChaser2D: 39;
|
||
PositionDamper: 40;
|
||
PositionDamper2D: 41;
|
||
PositionInterpolator: 70;
|
||
PositionInterpolator2D: 71;
|
||
ProgramShader: 134;
|
||
ProximitySensor: 28;
|
||
ScalarChaser: 42;
|
||
ScalarDamper: 43;
|
||
ScalarInterpolator: 72;
|
||
Script: 201;
|
||
ShaderPart: 135;
|
||
ShaderProgram: 136;
|
||
Shape: 147;
|
||
Sound: 171;
|
||
SpatialSound: 172;
|
||
Sphere: 55;
|
||
SphereSensor: 103;
|
||
SplinePositionInterpolator: 73;
|
||
SplinePositionInterpolator2D: 74;
|
||
SplineScalarInterpolator: 75;
|
||
SpotLight: 86;
|
||
SquadOrientationInterpolator: 76;
|
||
StaticGroup: 57;
|
||
StreamAudioDestination: 173;
|
||
StreamAudioSource: 174;
|
||
Switch: 58;
|
||
TexCoordChaser2D: 44;
|
||
TexCoordDamper2D: 45;
|
||
Text: 204;
|
||
TextureBackground: 25;
|
||
TextureCoordinate: 187;
|
||
TextureCoordinateGenerator: 188;
|
||
TextureProperties: 189;
|
||
TextureTransform: 190;
|
||
TimeSensor: 198;
|
||
TouchSensor: 104;
|
||
Transform: 59;
|
||
TransformSensor: 29;
|
||
TriangleFanSet: 119;
|
||
TriangleSet: 120;
|
||
TriangleStripSet: 121;
|
||
TwoSidedMaterial: 148;
|
||
UnlitMaterial: 149;
|
||
Viewpoint: 93;
|
||
ViewpointGroup: 94;
|
||
Viewport: 80;
|
||
VisibilitySensor: 30;
|
||
VrmlMatrix: 21;
|
||
WaveShaper: 175;
|
||
WorldInfo: 13;
|
||
// Abstract Node Types
|
||
X3DAppearanceChildNode: 150;
|
||
X3DAppearanceNode: 151;
|
||
X3DBackgroundNode: 26;
|
||
X3DBaseNode: 0;
|
||
X3DBindableNode: 14;
|
||
X3DBoundedObject: 60;
|
||
X3DBrowser: 200;
|
||
X3DChaserNode: 46;
|
||
X3DChildNode: 15;
|
||
X3DColorNode: 122;
|
||
X3DComposedGeometryNode: 123;
|
||
X3DCoordinateNode: 124;
|
||
X3DDamperNode: 47;
|
||
X3DDragSensorNode: 105;
|
||
X3DEnvironmentalSensorNode: 31;
|
||
X3DExecutionContext: 5;
|
||
X3DExternProtoDeclaration: 4;
|
||
X3DFogObject: 27;
|
||
X3DFollowerNode: 48;
|
||
X3DFontStyleNode: 205;
|
||
X3DGeometricPropertyNode: 125;
|
||
X3DGeometryNode: 126;
|
||
X3DGroupingNode: 61;
|
||
X3DInfoNode: 16;
|
||
X3DInterpolatorNode: 77;
|
||
X3DLayerNode: 81;
|
||
X3DLightNode: 87;
|
||
X3DLineGeometryNode: 127;
|
||
X3DMaterialNode: 152;
|
||
X3DMetadataObject: 17;
|
||
X3DNetworkSensorNode: 99;
|
||
X3DNode: 18;
|
||
X3DNormalNode: 128;
|
||
X3DOneSidedMaterialNode: 153;
|
||
X3DPointingDeviceSensorNode: 106;
|
||
X3DProgrammableShaderObject: 137;
|
||
X3DProtoDeclaration: 2;
|
||
X3DProtoDeclarationNode: 1;
|
||
X3DPrototypeInstance: 19;
|
||
X3DScene: 6;
|
||
X3DScriptNode: 202;
|
||
X3DSensorNode: 20;
|
||
X3DShaderNode: 138;
|
||
X3DShapeNode: 154;
|
||
X3DSingleTextureCoordinateNode: 191;
|
||
X3DSingleTextureNode: 192;
|
||
X3DSingleTextureTransformNode: 193;
|
||
X3DSoundChannelNode: 176;
|
||
X3DSoundDestinationNode: 177;
|
||
X3DSoundNode: 178;
|
||
X3DSoundProcessingNode: 179;
|
||
X3DSoundSourceNode: 180;
|
||
X3DTexture2DNode: 194;
|
||
X3DTextureCoordinateNode: 195;
|
||
X3DTextureNode: 196;
|
||
X3DTextureTransformNode: 197;
|
||
X3DTimeDependentNode: 199;
|
||
X3DTouchSensorNode: 107;
|
||
X3DTransformMatrix3DNode: 62;
|
||
X3DTransformNode: 63;
|
||
X3DUrlObject: 100;
|
||
X3DVertexAttributeNode: 139;
|
||
X3DViewpointNode: 95;
|
||
X3DViewportNode: 82;
|
||
X3DWorld: 3;
|
||
}
|
||
}
|