@needle-tools/engine 4.5.0-alpha.7 → 4.5.0

package/lib/engine/engine_serialization_decorator.d.ts

@@ -1,23 +1,23 @@
-import { type Constructor } from "./engine_types.js";
-export declare type TypeResolver<T> = (data: any) => Constructor<T> | null;
-/** Please use {@link serializable} - this version has a typo and will be removed in future versions */
-export declare const serializeable: <T>(type?: Constructor<T> | TypeResolver<T> | (Constructor<any> | TypeResolver<T>)[] | null | undefined) => (_target: any, _propertyKey: string | {
-    name: string;
-}) => void;
-/**
- * The serializable attribute should be used to annotate all serialized fields / fields and members that should be serialized and exposed in an editor
- * @param type The type of the field. If not provided the type will be inferred from the constructor of the field. If the field is a primitive type (string, number, boolean) the type should be null.
- */
-export declare const serializable: <T>(type?: Constructor<T> | TypeResolver<T> | (Constructor<any> | TypeResolver<T>)[] | null | undefined) => (_target: any, _propertyKey: string | {
-    name: string;
-}) => void;
-/** @internal */
-export declare const ALL_PROPERTIES_MARKER = "__NEEDLE__ALL_PROPERTIES";
-/** @internal @deprecated current not used */
-export declare function allProperties(constructor: Function): void;
-/**
- * @internal
- */
-export declare const STRICT_MARKER = "__NEEDLE__STRICT";
-/** @deprecated  current not used */
-export declare function strict(constructor: Function): void;
+import { type Constructor } from "./engine_types.js";
+export declare type TypeResolver<T> = (data: any) => Constructor<T> | null;
+/** Please use {@link serializable} - this version has a typo and will be removed in future versions */
+export declare const serializeable: <T>(type?: Constructor<T> | TypeResolver<T> | (Constructor<any> | TypeResolver<T>)[] | null | undefined) => (_target: any, _propertyKey: string | {
+    name: string;
+}) => void;
+/**
+ * The serializable attribute should be used to annotate all serialized fields / fields and members that should be serialized and exposed in an editor
+ * @param type The type of the field. If not provided the type will be inferred from the constructor of the field. If the field is a primitive type (string, number, boolean) the type should be null.
+ */
+export declare const serializable: <T>(type?: Constructor<T> | TypeResolver<T> | (Constructor<any> | TypeResolver<T>)[] | null | undefined) => (_target: any, _propertyKey: string | {
+    name: string;
+}) => void;
+/** @internal */
+export declare const ALL_PROPERTIES_MARKER = "__NEEDLE__ALL_PROPERTIES";
+/** @internal @deprecated current not used */
+export declare function allProperties(constructor: Function): void;
+/**
+ * @internal
+ */
+export declare const STRICT_MARKER = "__NEEDLE__STRICT";
+/** @deprecated  current not used */
+export declare function strict(constructor: Function): void;

package/lib/engine/engine_serialization_decorator.js

@@ -1,67 +1,67 @@
-/** Please use {@link serializable} - this version has a typo and will be removed in future versions */
-export const serializeable = function (type) {
-    return serializable(type);
-};
-/**
- * The serializable attribute should be used to annotate all serialized fields / fields and members that should be serialized and exposed in an editor
- * @param type The type of the field. If not provided the type will be inferred from the constructor of the field. If the field is a primitive type (string, number, boolean) the type should be null.
- */
-export const serializable = function (type) {
-    if (type === undefined)
-        type = null;
-    // for primitive types the serialization handles it without the constructor and just assigns the value
-    // if the user still passes in a primitive type constructor we can just throw it away :)
-    if (!Array.isArray(type)) {
-        type = setNullForPrimitiveTypes(type);
-    }
-    else {
-        for (let i = 0; i < type.length; i++) {
-            const entry = type[i];
-            type[i] = setNullForPrimitiveTypes(entry);
-        }
-    }
-    return function (_target, _propertyKey) {
-        if (!_target) {
-            console.error("Found @serializable decorator without a target");
-            return;
-        }
-        // The _propertyKey parameter is a string in TS4 with experimentalDecorators
-        // but a ClassFieldDecoratorContext in TS5 without.
-        // Seems when a different TS version is used in VSCode for editor checking, we get errors here
-        // if we don't also check for any. See https://github.com/needle-tools/needle-engine-support/issues/179
-        if (typeof _propertyKey !== 'string') {
-            _propertyKey = _propertyKey.name;
-        }
-        // this is important so objects with inheritance dont override their serialized type 
-        // info if e.g. multiple classes inheriting from the same type implement a member with the same name
-        // and both use @serializable() with different types 
-        if (!Object.getOwnPropertyDescriptor(_target, '$serializedTypes'))
-            _target["$serializedTypes"] = {};
-        const types = _target["$serializedTypes"] = _target["$serializedTypes"] || {};
-        types[_propertyKey] = type;
-    };
-};
-function setNullForPrimitiveTypes(type) {
-    switch (type?.prototype?.constructor?.name) {
-        case "Number":
-        case "String":
-        case "Boolean":
-            return null;
-    }
-    return type;
-}
-/** @internal */
-export const ALL_PROPERTIES_MARKER = "__NEEDLE__ALL_PROPERTIES";
-/** @internal @deprecated current not used */
-export function allProperties(constructor) {
-    constructor[ALL_PROPERTIES_MARKER] = true;
-}
-/**
- * @internal
- */
-export const STRICT_MARKER = "__NEEDLE__STRICT";
-/** @deprecated  current not used */
-export function strict(constructor) {
-    constructor[STRICT_MARKER] = true;
-}
+/** Please use {@link serializable} - this version has a typo and will be removed in future versions */
+export const serializeable = function (type) {
+    return serializable(type);
+};
+/**
+ * The serializable attribute should be used to annotate all serialized fields / fields and members that should be serialized and exposed in an editor
+ * @param type The type of the field. If not provided the type will be inferred from the constructor of the field. If the field is a primitive type (string, number, boolean) the type should be null.
+ */
+export const serializable = function (type) {
+    if (type === undefined)
+        type = null;
+    // for primitive types the serialization handles it without the constructor and just assigns the value
+    // if the user still passes in a primitive type constructor we can just throw it away :)
+    if (!Array.isArray(type)) {
+        type = setNullForPrimitiveTypes(type);
+    }
+    else {
+        for (let i = 0; i < type.length; i++) {
+            const entry = type[i];
+            type[i] = setNullForPrimitiveTypes(entry);
+        }
+    }
+    return function (_target, _propertyKey) {
+        if (!_target) {
+            console.error("Found @serializable decorator without a target");
+            return;
+        }
+        // The _propertyKey parameter is a string in TS4 with experimentalDecorators
+        // but a ClassFieldDecoratorContext in TS5 without.
+        // Seems when a different TS version is used in VSCode for editor checking, we get errors here
+        // if we don't also check for any. See https://github.com/needle-tools/needle-engine-support/issues/179
+        if (typeof _propertyKey !== 'string') {
+            _propertyKey = _propertyKey.name;
+        }
+        // this is important so objects with inheritance dont override their serialized type 
+        // info if e.g. multiple classes inheriting from the same type implement a member with the same name
+        // and both use @serializable() with different types 
+        if (!Object.getOwnPropertyDescriptor(_target, '$serializedTypes'))
+            _target["$serializedTypes"] = {};
+        const types = _target["$serializedTypes"] = _target["$serializedTypes"] || {};
+        types[_propertyKey] = type;
+    };
+};
+function setNullForPrimitiveTypes(type) {
+    switch (type?.prototype?.constructor?.name) {
+        case "Number":
+        case "String":
+        case "Boolean":
+            return null;
+    }
+    return type;
+}
+/** @internal */
+export const ALL_PROPERTIES_MARKER = "__NEEDLE__ALL_PROPERTIES";
+/** @internal @deprecated current not used */
+export function allProperties(constructor) {
+    constructor[ALL_PROPERTIES_MARKER] = true;
+}
+/**
+ * @internal
+ */
+export const STRICT_MARKER = "__NEEDLE__STRICT";
+/** @deprecated  current not used */
+export function strict(constructor) {
+    constructor[STRICT_MARKER] = true;
+}
 //# sourceMappingURL=engine_serialization_decorator.js.map

package/lib/engine/engine_setup.d.ts

@@ -1 +1 @@
-export * from "./engine_context.js";
+export * from "./engine_context.js";

package/lib/engine/engine_setup.js

@@ -1,3 +1,3 @@
-// TODO: change all usings to the new path:
-export * from "./engine_context.js";
+// TODO: change all usings to the new path:
+export * from "./engine_context.js";
 //# sourceMappingURL=engine_setup.js.map

package/lib/engine/engine_shaders.d.ts

@@ -1,53 +1,53 @@
-import { Color, DataTexture, Matrix4, Vector4 } from "three";
-import { RGBAColor } from "./js-extensions/index.js";
-import * as SHADERDATA from "./shaders/shaderData.js";
-export declare const whiteDefaultTexture: DataTexture;
-/**
- * Creates a new texture with a single color
- * @param col Color to use
- * @param size Size of the texture
- * @returns A texture with the specified color
- */
-export declare function createFlatTexture(col: RGBAColor | Color, size?: number): DataTexture;
-/**
- * Creates a new texture with three colors
- * @param col0 First color
- * @param col1 Second color
- * @param col2 Third color
- * @param width Width of the texture
- * @param height Height of the texture
- * @returns A texture with the specified colors
- */
-export declare function createTrilightTexture<T extends Color>(col0: T, col1: T, col2: T, width?: number, height?: number): DataTexture;
-/** @internal */
-export declare enum Stage {
-    Vertex = 0,
-    Fragment = 1
-}
-/** @internal */
-export declare class UnityShaderStage {
-    stage: Stage;
-    code: string;
-    constructor(stage: Stage, code: string);
-}
-declare class ShaderLib {
-    loaded: Map<string, UnityShaderStage>;
-    loadShader(url: string): Promise<SHADERDATA.ShaderData>;
-    load(stage: Stage, url: string): Promise<UnityShaderStage>;
-}
-/** @internal */
-export declare const lib: ShaderLib;
-/** @internal */
-export declare function ToUnityMatrixArray(mat: Matrix4, buffer?: Array<Vector4>): Array<Vector4>;
-/** @internal */
-export declare function SetUnitySphericalHarmonics(obj: object, array?: number[]): void;
-/** @internal */
-export declare class ShaderBundle {
-    readonly vertexShader: string;
-    readonly fragmentShader: string;
-    readonly technique: SHADERDATA.Technique;
-    constructor(vertexShader: string, fragmentShader: string, technique: SHADERDATA.Technique);
-}
-/** @internal */
-export declare function FindShaderTechniques(shaderData: SHADERDATA.ShaderData, id: number): Promise<ShaderBundle | null>;
-export {};
+import { Color, DataTexture, Matrix4, Vector4 } from "three";
+import { RGBAColor } from "./js-extensions/index.js";
+import * as SHADERDATA from "./shaders/shaderData.js";
+export declare const whiteDefaultTexture: DataTexture;
+/**
+ * Creates a new texture with a single color
+ * @param col Color to use
+ * @param size Size of the texture
+ * @returns A texture with the specified color
+ */
+export declare function createFlatTexture(col: RGBAColor | Color, size?: number): DataTexture;
+/**
+ * Creates a new texture with three colors
+ * @param col0 First color
+ * @param col1 Second color
+ * @param col2 Third color
+ * @param width Width of the texture
+ * @param height Height of the texture
+ * @returns A texture with the specified colors
+ */
+export declare function createTrilightTexture<T extends Color>(col0: T, col1: T, col2: T, width?: number, height?: number): DataTexture;
+/** @internal */
+export declare enum Stage {
+    Vertex = 0,
+    Fragment = 1
+}
+/** @internal */
+export declare class UnityShaderStage {
+    stage: Stage;
+    code: string;
+    constructor(stage: Stage, code: string);
+}
+declare class ShaderLib {
+    loaded: Map<string, UnityShaderStage>;
+    loadShader(url: string): Promise<SHADERDATA.ShaderData>;
+    load(stage: Stage, url: string): Promise<UnityShaderStage>;
+}
+/** @internal */
+export declare const lib: ShaderLib;
+/** @internal */
+export declare function ToUnityMatrixArray(mat: Matrix4, buffer?: Array<Vector4>): Array<Vector4>;
+/** @internal */
+export declare function SetUnitySphericalHarmonics(obj: object, array?: number[]): void;
+/** @internal */
+export declare class ShaderBundle {
+    readonly vertexShader: string;
+    readonly fragmentShader: string;
+    readonly technique: SHADERDATA.Technique;
+    constructor(vertexShader: string, fragmentShader: string, technique: SHADERDATA.Technique);
+}
+/** @internal */
+export declare function FindShaderTechniques(shaderData: SHADERDATA.ShaderData, id: number): Promise<ShaderBundle | null>;
+export {};