@fps-games/editor 0.2.0-beta.4 → 0.2.1-beta.2

package/node_modules/@babylonjs/loaders/glTF/1.0/glTFLoaderInterfaces.d.ts

@@ -0,0 +1,412 @@
+import type { AssetContainer } from "@babylonjs/core/assetContainer.js";
+import type { Bone } from "@babylonjs/core/Bones/bone.js";
+import type { Skeleton } from "@babylonjs/core/Bones/skeleton.js";
+import type { Texture } from "@babylonjs/core/Materials/Textures/texture.js";
+import type { Node } from "@babylonjs/core/node.js";
+import type { Scene } from "@babylonjs/core/scene.js";
+import type { Nullable } from "@babylonjs/core/types.js";
+/**
+ * Enums
+ * @internal
+ */
+export declare enum EComponentType {
+    BYTE = 5120,
+    UNSIGNED_BYTE = 5121,
+    SHORT = 5122,
+    UNSIGNED_SHORT = 5123,
+    FLOAT = 5126
+}
+/** @internal */
+export declare enum EShaderType {
+    FRAGMENT = 35632,
+    VERTEX = 35633
+}
+/** @internal */
+export declare enum EParameterType {
+    BYTE = 5120,
+    UNSIGNED_BYTE = 5121,
+    SHORT = 5122,
+    UNSIGNED_SHORT = 5123,
+    INT = 5124,
+    UNSIGNED_INT = 5125,
+    FLOAT = 5126,
+    FLOAT_VEC2 = 35664,
+    FLOAT_VEC3 = 35665,
+    FLOAT_VEC4 = 35666,
+    INT_VEC2 = 35667,
+    INT_VEC3 = 35668,
+    INT_VEC4 = 35669,
+    BOOL = 35670,
+    BOOL_VEC2 = 35671,
+    BOOL_VEC3 = 35672,
+    BOOL_VEC4 = 35673,
+    FLOAT_MAT2 = 35674,
+    FLOAT_MAT3 = 35675,
+    FLOAT_MAT4 = 35676,
+    SAMPLER_2D = 35678
+}
+/** @internal */
+export declare enum ETextureWrapMode {
+    CLAMP_TO_EDGE = 33071,
+    MIRRORED_REPEAT = 33648,
+    REPEAT = 10497
+}
+/** @internal */
+export declare enum ETextureFilterType {
+    NEAREST = 9728,
+    LINEAR = 9728,
+    NEAREST_MIPMAP_NEAREST = 9984,
+    LINEAR_MIPMAP_NEAREST = 9985,
+    NEAREST_MIPMAP_LINEAR = 9986,
+    LINEAR_MIPMAP_LINEAR = 9987
+}
+/** @internal */
+export declare enum ETextureFormat {
+    ALPHA = 6406,
+    RGB = 6407,
+    RGBA = 6408,
+    LUMINANCE = 6409,
+    LUMINANCE_ALPHA = 6410
+}
+/** @internal */
+export declare enum ECullingType {
+    FRONT = 1028,
+    BACK = 1029,
+    FRONT_AND_BACK = 1032
+}
+/** @internal */
+export declare enum EBlendingFunction {
+    ZERO = 0,
+    ONE = 1,
+    SRC_COLOR = 768,
+    ONE_MINUS_SRC_COLOR = 769,
+    DST_COLOR = 774,
+    ONE_MINUS_DST_COLOR = 775,
+    SRC_ALPHA = 770,
+    ONE_MINUS_SRC_ALPHA = 771,
+    DST_ALPHA = 772,
+    ONE_MINUS_DST_ALPHA = 773,
+    CONSTANT_COLOR = 32769,
+    ONE_MINUS_CONSTANT_COLOR = 32770,
+    CONSTANT_ALPHA = 32771,
+    ONE_MINUS_CONSTANT_ALPHA = 32772,
+    SRC_ALPHA_SATURATE = 776
+}
+/** @internal */
+export interface IGLTFProperty {
+    extensions?: {
+        [key: string]: any;
+    };
+    extras?: object;
+}
+/** @internal */
+export interface IGLTFChildRootProperty extends IGLTFProperty {
+    name?: string;
+}
+/** @internal */
+export interface IGLTFAccessor extends IGLTFChildRootProperty {
+    bufferView: string;
+    byteOffset: number;
+    byteStride: number;
+    count: number;
+    type: string;
+    componentType: EComponentType;
+    max?: number[];
+    min?: number[];
+    name?: string;
+}
+/** @internal */
+export interface IGLTFBufferView extends IGLTFChildRootProperty {
+    buffer: string;
+    byteOffset: number;
+    byteLength: number;
+    byteStride: number;
+    target?: number;
+}
+/** @internal */
+export interface IGLTFBuffer extends IGLTFChildRootProperty {
+    uri: string;
+    byteLength?: number;
+    type?: string;
+}
+/** @internal */
+export interface IGLTFShader extends IGLTFChildRootProperty {
+    uri: string;
+    type: EShaderType;
+}
+/** @internal */
+export interface IGLTFProgram extends IGLTFChildRootProperty {
+    attributes: string[];
+    fragmentShader: string;
+    vertexShader: string;
+}
+/** @internal */
+export interface IGLTFTechniqueParameter {
+    type: number;
+    count?: number;
+    semantic?: string;
+    node?: string;
+    value?: number | boolean | string | Array<any>;
+    source?: string;
+    babylonValue?: any;
+}
+/** @internal */
+export interface IGLTFTechniqueCommonProfile {
+    lightingModel: string;
+    texcoordBindings: object;
+    parameters?: Array<any>;
+}
+/** @internal */
+export interface IGLTFTechniqueStatesFunctions {
+    blendColor?: number[];
+    blendEquationSeparate?: number[];
+    blendFuncSeparate?: number[];
+    colorMask: boolean[];
+    cullFace: number[];
+}
+/** @internal */
+export interface IGLTFTechniqueStates {
+    enable: number[];
+    functions: IGLTFTechniqueStatesFunctions;
+}
+/** @internal */
+export interface IGLTFTechnique extends IGLTFChildRootProperty {
+    parameters: {
+        [key: string]: IGLTFTechniqueParameter;
+    };
+    program: string;
+    attributes: {
+        [key: string]: string;
+    };
+    uniforms: {
+        [key: string]: string;
+    };
+    states: IGLTFTechniqueStates;
+}
+/** @internal */
+export interface IGLTFMaterial extends IGLTFChildRootProperty {
+    technique?: string;
+    values: string[];
+}
+/** @internal */
+export interface IGLTFMeshPrimitive extends IGLTFProperty {
+    attributes: {
+        [key: string]: string;
+    };
+    indices: string;
+    material: string;
+    mode?: number;
+}
+/** @internal */
+export interface IGLTFMesh extends IGLTFChildRootProperty {
+    primitives: IGLTFMeshPrimitive[];
+}
+/** @internal */
+export interface IGLTFImage extends IGLTFChildRootProperty {
+    uri: string;
+}
+/** @internal */
+export interface IGLTFSampler extends IGLTFChildRootProperty {
+    magFilter?: number;
+    minFilter?: number;
+    wrapS?: number;
+    wrapT?: number;
+}
+/** @internal */
+export interface IGLTFTexture extends IGLTFChildRootProperty {
+    sampler: string;
+    source: string;
+    format?: ETextureFormat;
+    internalFormat?: ETextureFormat;
+    target?: number;
+    type?: number;
+    babylonTexture?: Texture;
+}
+/** @internal */
+export interface IGLTFAmbienLight {
+    color?: number[];
+}
+/** @internal */
+export interface IGLTFDirectionalLight {
+    color?: number[];
+}
+/** @internal */
+export interface IGLTFPointLight {
+    color?: number[];
+    constantAttenuation?: number;
+    linearAttenuation?: number;
+    quadraticAttenuation?: number;
+}
+/** @internal */
+export interface IGLTFSpotLight {
+    color?: number[];
+    constantAttenuation?: number;
+    fallOfAngle?: number;
+    fallOffExponent?: number;
+    linearAttenuation?: number;
+    quadraticAttenuation?: number;
+}
+/** @internal */
+export interface IGLTFLight extends IGLTFChildRootProperty {
+    type: string;
+}
+/** @internal */
+export interface IGLTFCameraOrthographic {
+    xmag: number;
+    ymag: number;
+    zfar: number;
+    znear: number;
+}
+/** @internal */
+export interface IGLTFCameraPerspective {
+    aspectRatio: number;
+    yfov: number;
+    zfar: number;
+    znear: number;
+}
+/** @internal */
+export interface IGLTFCamera extends IGLTFChildRootProperty {
+    type: string;
+}
+/** @internal */
+export interface IGLTFAnimationChannelTarget {
+    id: string;
+    path: string;
+}
+/** @internal */
+export interface IGLTFAnimationChannel {
+    sampler: string;
+    target: IGLTFAnimationChannelTarget;
+}
+/** @internal */
+export interface IGLTFAnimationSampler {
+    input: string;
+    output: string;
+    interpolation?: string;
+}
+/** @internal */
+export interface IGLTFAnimation extends IGLTFChildRootProperty {
+    channels?: IGLTFAnimationChannel[];
+    parameters?: {
+        [key: string]: string;
+    };
+    samplers?: {
+        [key: string]: IGLTFAnimationSampler;
+    };
+}
+/** @internal */
+export interface IGLTFNodeInstanceSkin {
+    skeletons: string[];
+    skin: string;
+    meshes: string[];
+}
+/** @internal */
+export interface IGLTFSkins extends IGLTFChildRootProperty {
+    bindShapeMatrix: number[];
+    inverseBindMatrices: string;
+    jointNames: string[];
+    babylonSkeleton?: Skeleton;
+}
+/** @internal */
+export interface IGLTFNode extends IGLTFChildRootProperty {
+    camera?: string;
+    children: string[];
+    skin?: string;
+    jointName?: string;
+    light?: string;
+    matrix: number[];
+    mesh?: string;
+    meshes?: string[];
+    rotation?: number[];
+    scale?: number[];
+    translation?: number[];
+    babylonNode?: Node;
+}
+/** @internal */
+export interface IGLTFScene extends IGLTFChildRootProperty {
+    nodes: string[];
+}
+/** @internal */
+export interface IGLTFRuntime {
+    extensions: {
+        [key: string]: any;
+    };
+    accessors: {
+        [key: string]: IGLTFAccessor;
+    };
+    buffers: {
+        [key: string]: IGLTFBuffer;
+    };
+    bufferViews: {
+        [key: string]: IGLTFBufferView;
+    };
+    meshes: {
+        [key: string]: IGLTFMesh;
+    };
+    lights: {
+        [key: string]: IGLTFLight;
+    };
+    cameras: {
+        [key: string]: IGLTFCamera;
+    };
+    nodes: {
+        [key: string]: IGLTFNode;
+    };
+    images: {
+        [key: string]: IGLTFImage;
+    };
+    textures: {
+        [key: string]: IGLTFTexture;
+    };
+    shaders: {
+        [key: string]: IGLTFShader;
+    };
+    programs: {
+        [key: string]: IGLTFProgram;
+    };
+    samplers: {
+        [key: string]: IGLTFSampler;
+    };
+    techniques: {
+        [key: string]: IGLTFTechnique;
+    };
+    materials: {
+        [key: string]: IGLTFMaterial;
+    };
+    animations: {
+        [key: string]: IGLTFAnimation;
+    };
+    skins: {
+        [key: string]: IGLTFSkins;
+    };
+    currentScene?: object;
+    scenes: {
+        [key: string]: IGLTFScene;
+    };
+    extensionsUsed: string[];
+    extensionsRequired?: string[];
+    buffersCount: number;
+    shaderscount: number;
+    scene: Scene;
+    rootUrl: string;
+    loadedBufferCount: number;
+    loadedBufferViews: {
+        [name: string]: ArrayBufferView;
+    };
+    loadedShaderCount: number;
+    importOnlyMeshes: boolean;
+    importMeshesNames?: string[];
+    dummyNodes: Node[];
+    assetContainer: Nullable<AssetContainer>;
+}
+/** @internal */
+export interface INodeToRoot {
+    bone: Bone;
+    node: IGLTFNode;
+    id: string;
+}
+/** @internal */
+export interface IJointNode {
+    node: IGLTFNode;
+    id: string;
+}

package/node_modules/@babylonjs/loaders/glTF/1.0/glTFLoaderInterfaces.js

@@ -0,0 +1,95 @@
+/**
+ * Enums
+ * @internal
+ */
+export var EComponentType;
+(function (EComponentType) {
+    EComponentType[EComponentType["BYTE"] = 5120] = "BYTE";
+    EComponentType[EComponentType["UNSIGNED_BYTE"] = 5121] = "UNSIGNED_BYTE";
+    EComponentType[EComponentType["SHORT"] = 5122] = "SHORT";
+    EComponentType[EComponentType["UNSIGNED_SHORT"] = 5123] = "UNSIGNED_SHORT";
+    EComponentType[EComponentType["FLOAT"] = 5126] = "FLOAT";
+})(EComponentType || (EComponentType = {}));
+/** @internal */
+export var EShaderType;
+(function (EShaderType) {
+    EShaderType[EShaderType["FRAGMENT"] = 35632] = "FRAGMENT";
+    EShaderType[EShaderType["VERTEX"] = 35633] = "VERTEX";
+})(EShaderType || (EShaderType = {}));
+/** @internal */
+export var EParameterType;
+(function (EParameterType) {
+    EParameterType[EParameterType["BYTE"] = 5120] = "BYTE";
+    EParameterType[EParameterType["UNSIGNED_BYTE"] = 5121] = "UNSIGNED_BYTE";
+    EParameterType[EParameterType["SHORT"] = 5122] = "SHORT";
+    EParameterType[EParameterType["UNSIGNED_SHORT"] = 5123] = "UNSIGNED_SHORT";
+    EParameterType[EParameterType["INT"] = 5124] = "INT";
+    EParameterType[EParameterType["UNSIGNED_INT"] = 5125] = "UNSIGNED_INT";
+    EParameterType[EParameterType["FLOAT"] = 5126] = "FLOAT";
+    EParameterType[EParameterType["FLOAT_VEC2"] = 35664] = "FLOAT_VEC2";
+    EParameterType[EParameterType["FLOAT_VEC3"] = 35665] = "FLOAT_VEC3";
+    EParameterType[EParameterType["FLOAT_VEC4"] = 35666] = "FLOAT_VEC4";
+    EParameterType[EParameterType["INT_VEC2"] = 35667] = "INT_VEC2";
+    EParameterType[EParameterType["INT_VEC3"] = 35668] = "INT_VEC3";
+    EParameterType[EParameterType["INT_VEC4"] = 35669] = "INT_VEC4";
+    EParameterType[EParameterType["BOOL"] = 35670] = "BOOL";
+    EParameterType[EParameterType["BOOL_VEC2"] = 35671] = "BOOL_VEC2";
+    EParameterType[EParameterType["BOOL_VEC3"] = 35672] = "BOOL_VEC3";
+    EParameterType[EParameterType["BOOL_VEC4"] = 35673] = "BOOL_VEC4";
+    EParameterType[EParameterType["FLOAT_MAT2"] = 35674] = "FLOAT_MAT2";
+    EParameterType[EParameterType["FLOAT_MAT3"] = 35675] = "FLOAT_MAT3";
+    EParameterType[EParameterType["FLOAT_MAT4"] = 35676] = "FLOAT_MAT4";
+    EParameterType[EParameterType["SAMPLER_2D"] = 35678] = "SAMPLER_2D";
+})(EParameterType || (EParameterType = {}));
+/** @internal */
+export var ETextureWrapMode;
+(function (ETextureWrapMode) {
+    ETextureWrapMode[ETextureWrapMode["CLAMP_TO_EDGE"] = 33071] = "CLAMP_TO_EDGE";
+    ETextureWrapMode[ETextureWrapMode["MIRRORED_REPEAT"] = 33648] = "MIRRORED_REPEAT";
+    ETextureWrapMode[ETextureWrapMode["REPEAT"] = 10497] = "REPEAT";
+})(ETextureWrapMode || (ETextureWrapMode = {}));
+/** @internal */
+export var ETextureFilterType;
+(function (ETextureFilterType) {
+    ETextureFilterType[ETextureFilterType["NEAREST"] = 9728] = "NEAREST";
+    ETextureFilterType[ETextureFilterType["LINEAR"] = 9728] = "LINEAR";
+    ETextureFilterType[ETextureFilterType["NEAREST_MIPMAP_NEAREST"] = 9984] = "NEAREST_MIPMAP_NEAREST";
+    ETextureFilterType[ETextureFilterType["LINEAR_MIPMAP_NEAREST"] = 9985] = "LINEAR_MIPMAP_NEAREST";
+    ETextureFilterType[ETextureFilterType["NEAREST_MIPMAP_LINEAR"] = 9986] = "NEAREST_MIPMAP_LINEAR";
+    ETextureFilterType[ETextureFilterType["LINEAR_MIPMAP_LINEAR"] = 9987] = "LINEAR_MIPMAP_LINEAR";
+})(ETextureFilterType || (ETextureFilterType = {}));
+/** @internal */
+export var ETextureFormat;
+(function (ETextureFormat) {
+    ETextureFormat[ETextureFormat["ALPHA"] = 6406] = "ALPHA";
+    ETextureFormat[ETextureFormat["RGB"] = 6407] = "RGB";
+    ETextureFormat[ETextureFormat["RGBA"] = 6408] = "RGBA";
+    ETextureFormat[ETextureFormat["LUMINANCE"] = 6409] = "LUMINANCE";
+    ETextureFormat[ETextureFormat["LUMINANCE_ALPHA"] = 6410] = "LUMINANCE_ALPHA";
+})(ETextureFormat || (ETextureFormat = {}));
+/** @internal */
+export var ECullingType;
+(function (ECullingType) {
+    ECullingType[ECullingType["FRONT"] = 1028] = "FRONT";
+    ECullingType[ECullingType["BACK"] = 1029] = "BACK";
+    ECullingType[ECullingType["FRONT_AND_BACK"] = 1032] = "FRONT_AND_BACK";
+})(ECullingType || (ECullingType = {}));
+/** @internal */
+export var EBlendingFunction;
+(function (EBlendingFunction) {
+    EBlendingFunction[EBlendingFunction["ZERO"] = 0] = "ZERO";
+    EBlendingFunction[EBlendingFunction["ONE"] = 1] = "ONE";
+    EBlendingFunction[EBlendingFunction["SRC_COLOR"] = 768] = "SRC_COLOR";
+    EBlendingFunction[EBlendingFunction["ONE_MINUS_SRC_COLOR"] = 769] = "ONE_MINUS_SRC_COLOR";
+    EBlendingFunction[EBlendingFunction["DST_COLOR"] = 774] = "DST_COLOR";
+    EBlendingFunction[EBlendingFunction["ONE_MINUS_DST_COLOR"] = 775] = "ONE_MINUS_DST_COLOR";
+    EBlendingFunction[EBlendingFunction["SRC_ALPHA"] = 770] = "SRC_ALPHA";
+    EBlendingFunction[EBlendingFunction["ONE_MINUS_SRC_ALPHA"] = 771] = "ONE_MINUS_SRC_ALPHA";
+    EBlendingFunction[EBlendingFunction["DST_ALPHA"] = 772] = "DST_ALPHA";
+    EBlendingFunction[EBlendingFunction["ONE_MINUS_DST_ALPHA"] = 773] = "ONE_MINUS_DST_ALPHA";
+    EBlendingFunction[EBlendingFunction["CONSTANT_COLOR"] = 32769] = "CONSTANT_COLOR";
+    EBlendingFunction[EBlendingFunction["ONE_MINUS_CONSTANT_COLOR"] = 32770] = "ONE_MINUS_CONSTANT_COLOR";
+    EBlendingFunction[EBlendingFunction["CONSTANT_ALPHA"] = 32771] = "CONSTANT_ALPHA";
+    EBlendingFunction[EBlendingFunction["ONE_MINUS_CONSTANT_ALPHA"] = 32772] = "ONE_MINUS_CONSTANT_ALPHA";
+    EBlendingFunction[EBlendingFunction["SRC_ALPHA_SATURATE"] = 776] = "SRC_ALPHA_SATURATE";
+})(EBlendingFunction || (EBlendingFunction = {}));

package/node_modules/@babylonjs/loaders/glTF/1.0/glTFLoaderUtils.d.ts

@@ -0,0 +1,71 @@
+import type { IGLTFTechniqueParameter, IGLTFAccessor, IGLTFRuntime, IGLTFBufferView } from "./glTFLoaderInterfaces.js";
+import { EComponentType } from "./glTFLoaderInterfaces.js";
+import { Effect } from "@babylonjs/core/Materials/effect.js";
+import { ShaderMaterial } from "@babylonjs/core/Materials/shaderMaterial.js";
+import type { Node } from "@babylonjs/core/node.js";
+import type { Scene } from "@babylonjs/core/scene.js";
+/**
+ * Utils functions for GLTF
+ * @internal
+ * @deprecated
+ */
+export declare class GLTFUtils {
+    /**
+     * Sets the given "parameter" matrix
+     * @param scene the Scene object
+     * @param source the source node where to pick the matrix
+     * @param parameter the GLTF technique parameter
+     * @param uniformName the name of the shader's uniform
+     * @param shaderMaterial the shader material
+     */
+    static SetMatrix(scene: Scene, source: Node, parameter: IGLTFTechniqueParameter, uniformName: string, shaderMaterial: ShaderMaterial | Effect): void;
+    /**
+     * Sets the given "parameter" matrix
+     * @param shaderMaterial the shader material
+     * @param uniform the name of the shader's uniform
+     * @param value the value of the uniform
+     * @param type the uniform's type (EParameterType FLOAT, VEC2, VEC3 or VEC4)
+     * @returns true if set, else false
+     */
+    static SetUniform(shaderMaterial: ShaderMaterial | Effect, uniform: string, value: any, type: number): boolean;
+    /**
+     * Returns the wrap mode of the texture
+     * @param mode the mode value
+     * @returns the wrap mode (TEXTURE_WRAP_ADDRESSMODE, MIRROR_ADDRESSMODE or CLAMP_ADDRESSMODE)
+     */
+    static GetWrapMode(mode: number): number;
+    /**
+     * Returns the byte stride giving an accessor
+     * @param accessor the GLTF accessor objet
+     * @returns the byte stride
+     */
+    static GetByteStrideFromType(accessor: IGLTFAccessor): number;
+    /**
+     * Returns the texture filter mode giving a mode value
+     * @param mode the filter mode value
+     * @returns the filter mode (TODO - needs to be a type?)
+     */
+    static GetTextureFilterMode(mode: number): number;
+    static GetBufferFromBufferView(gltfRuntime: IGLTFRuntime, bufferView: IGLTFBufferView, byteOffset: number, byteLength: number, componentType: EComponentType): ArrayBufferView;
+    /**
+     * Returns a buffer from its accessor
+     * @param gltfRuntime the GLTF runtime
+     * @param accessor the GLTF accessor
+     * @returns an array buffer view
+     */
+    static GetBufferFromAccessor(gltfRuntime: IGLTFRuntime, accessor: IGLTFAccessor): any;
+    /**
+     * Decodes a buffer view into a string
+     * @param view the buffer view
+     * @returns a string
+     */
+    static DecodeBufferToText(view: ArrayBufferView): string;
+    /**
+     * Returns the default material of gltf. Related to
+     * https://github.com/KhronosGroup/glTF/tree/master/specification/1.0#appendix-a-default-material
+     * @param scene the Babylon.js scene
+     * @returns the default Babylon material
+     */
+    static GetDefaultMaterial(scene: Scene): ShaderMaterial;
+    private static _DefaultMaterial;
+}