@needle-tools/engine 2.65.2-pre → 2.67.0-pre

package/src/engine-components/Component.ts

@@ -23,6 +23,9 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
 
     guid: string | undefined;
 
+    // Added to the threejs Object3D prototype
+    abstract destroy();
+
     // The actual implementation / prototype of threejs is modified in js-extensions/Object3D
     abstract get transform(): THREE.Object3D;
 
@@ -33,15 +36,21 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
     public static setActive(go: THREE.Object3D, active: boolean, processStart: boolean = true) {
         if (!go) return;
         setActive(go, active);
+
+        // TODO: do we still need this?:
         main.updateIsActive(go);
         if (active && processStart)
             main.processStart(Context.Current, go);
     }
 
+    /** If the object is active (same as go.visible) */
     public static isActiveSelf(go: THREE.Object3D): boolean {
         return isActiveSelf(go);
     }
 
+    /** If the object is active in the hierarchy (e.g. if any parent is invisible or not in the scene it will be false) 
+     * @param go object to check
+    */
     public static isActiveInHierarchy(go: THREE.Object3D): boolean {
         return isActiveInHierarchy(go);
     }
@@ -52,19 +61,35 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
 
     public static isUsingInstancing(instance: THREE.Object3D): boolean { return isUsingInstancing(instance); }
 
+    /** Run a callback for all components of the provided type on the provided object and its children (if recursive is true)
+     * @param instance object to run the method on
+     * @param cb callback to run on each component
+     * @param recursive if true, the method will be run on all children as well
+     */
     public static foreachComponent(instance: THREE.Object3D, cb: (comp: Component) => any, recursive: boolean = true): any {
         return foreachComponent(instance, cb as (comp: IComponent) => any, recursive);
     }
 
+    /** Creates a new instance of the provided object. The new instance will be created on all connected clients 
+     * @param instance object to instantiate
+     * @param opts options for the instantiation
+     */
     public static instantiateSynced(instance: GameObject | Object3D | null, opts: InstantiateOptions): GameObject | null {
         if (!instance) return null;
         return syncInstantiate(instance as any, opts) as GameObject | null;
     }
 
+    /** Creates a new instance of the provided object (like cloning it including all components and children) 
+     * @param instance object to instantiate
+     * @param opts options for the instantiation (e.g. with what parent, position, etc.)
+    */
     public static instantiate(instance: GameObject | Object3D | null, opts: InstantiateOptions | null = null): GameObject | null {
         return instantiate(instance, opts) as GameObject | null;
     }
 
+    /** Destroys a object on all connected clients (if you are in a networked session) 
+     * @param instance object to destroy
+    */
     public static destroySynced(instance: THREE.Object3D | Component, context?: Context, recursive: boolean = true) {
         if (!instance) return;
         const go = instance as GameObject;
@@ -72,6 +97,10 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
         syncDestroy(go as any, context.connection, recursive);
     }
 
+    /** Destroys a object
+     * @param instance object to destroy
+     * @param recursive if true, all children will be destroyed as well
+     */
     public static destroy(instance: THREE.Object3D | Component, recursive: boolean = true, isRoot: boolean = true) {
         return destroy(instance, recursive, isRoot);
     }
@@ -94,7 +123,7 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
         if (context) {
             GameObject.foreachComponent(instance, (comp: Component) => {
                 main.addScriptToArrays(comp, context!);
-                if(comp.__internalDidAwakeAndStart) return;
+                if (comp.__internalDidAwakeAndStart) return;
                 if (context!.new_script_start.includes(comp) === false) {
                     context!.new_script_start.push(comp as Behaviour);
                 }
@@ -118,24 +147,31 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
         }, true);
     }
 
+    /** Invokes a method on all components including children (if a method with that name exists) */
     public static invokeOnChildren(go: THREE.Object3D | null | undefined, functionName: string, ...args: any) {
         this.invoke(go, functionName, true, args);
     }
 
+    /** Invokes a method on all components that have a method matching the provided name
+     * @param go object to invoke the method on all components
+     * @param functionName name of the method to invoke
+     */
     public static invoke(go: THREE.Object3D | null | undefined, functionName: string, children: boolean = false, ...args: any) {
         if (!go) return;
-
-        // console.log(go);
         this.foreachComponent(go, c => {
             const fn = c[functionName];
             if (fn && typeof fn === "function") {
-                const bound = fn.bind(c);
-                // console.log(c, bound)
-                bound(...args)
+                fn?.call(c, ...args)
             }
         }, children);
     }
 
+    /**
+     * Adds a new component to the provided object
+     * @param go object to add the component to
+     * @param type type of the component to add
+     * @param callAwake if true, the component will be added and awake will be called immediately
+     */
     public static addNewComponent<T>(go: GameObject | THREE.Object3D, type: ConstructorConcrete<T>, callAwake: boolean = true): T {
         const instance = new type();
         //@ts-ignore
@@ -143,13 +179,31 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
         return instance
     }
 
+    /**
+     * Moves a component to a new object  
+     * BEWARE: this does MOVE a component. If you want to add a new component use `addNewComponent`  
+     * @param go component to move the component to
+     * @param instance component to move to the GO
+     */
     public static addComponent(go: GameObject, instance: Component): void {
+        return this.moveComponent(go, instance);
+    }
+
+    /**
+     * Moves a component to a new object  
+     * @param go component to move the component to
+     * @param instance component to move to the GO
+     */
+    public static moveComponent(go: GameObject, instance: Component): void {
         if (instance.gameObject == null) {
             throw new Error("Did you mean to create a new component? Use addNewComponent");
         }
         moveComponentInstance(go, instance as any);
     }
 
+    /** Removes a component from its object
+     * @param instance component to remove
+     */
     public static removeComponent(instance: Component): Component {
         removeComponent(instance.gameObject, instance as any);
         return instance;
@@ -159,6 +213,7 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
         return getOrAddComponent<any>(go, typeName);
     }
 
+    /** Gets a component on the provided object */
     public static getComponent<T>(go: GameObject | THREE.Object3D | null, typeName: Constructor<T> | null): T | null {
         if (go === null) return null;
         // if names are minified we could also use the type store and work with strings everywhere
@@ -339,7 +394,7 @@ class Component implements IComponent, EventTarget {
     onCollisionEnter?(col: Collision);
     onCollisionExit?(col: Collision);
     onCollisionStay?(col: Collision);
-    
+
     onTriggerEnter?(col: ICollider);
     onTriggerStay?(col: ICollider);
     onTriggerExit?(col: ICollider);
@@ -361,34 +416,33 @@ class Component implements IComponent, EventTarget {
         this.__internalDestroy();
     }
 
-    
-    
+
+
     /** @internal */
     protected __didAwake: boolean = false;
-    
+
     /** @internal */
     private __didStart: boolean = false;
-    
+
     /** @internal */
     protected __didEnable: boolean = false;
-    
+
     /** @internal */
     protected __isEnabled: boolean | undefined = undefined;
-    
+
     /** @internal */
     private __destroyed: boolean = false;
-    
+
     /** @internal */
     get __internalDidAwakeAndStart() { return this.__didAwake && this.__didStart; }
 
-    
+
     /** @internal */
     constructor() {
-        // super();
         this.__internalNewInstanceCreated();
     }
 
-    
+
     /** @internal */
     __internalNewInstanceCreated() {
         this.__didAwake = false;
@@ -396,21 +450,17 @@ class Component implements IComponent, EventTarget {
         this.__didEnable = false;
         this.__isEnabled = undefined;
         this.__destroyed = false;
-        // this.__internalResetsCachedPhysicsData();
     }
 
-    
+
     /** @internal */
     __internalAwake() {
         if (this.__didAwake) return;
-        // console.log("__internalAwake");
         this.__didAwake = true;
-        // this.gameObject.test();
-
         this.awake();
     }
 
-    
+
     /** @internal */
     __internalStart() {
         if (this.__didStart) return;
@@ -418,14 +468,13 @@ class Component implements IComponent, EventTarget {
         if (this.start) this.start();
     }
 
-    
+
     /** @internal */
     __internalEnable(): boolean {
         if (this.__didEnable) return false;
         // console.trace("INTERNAL ENABLE");
         this.__didEnable = true;
         this.onEnable();
-        // if we do this after processing the callback
         this.__isEnabled = true;
         return true;
     }
@@ -434,10 +483,7 @@ class Component implements IComponent, EventTarget {
     __internalDisable() {
         if (!this.__didEnable) return;
         this.__didEnable = false;
-        // this._collisionExitRoutine = undefined;
         this.onDisable();
-        // this._collisions?.clear();
-        // if we do this after processing the callback
         this.__isEnabled = false;
     }
 
@@ -446,11 +492,9 @@ class Component implements IComponent, EventTarget {
         if (this.__destroyed) return;
         this.__destroyed = true;
         this.destroy?.call(this);
-        // console.log("destroy", this);
         destroyComponentInstance(this as any);
     }
 
-    // isActiveAndEnabled: boolean = false;
 
     get enabled(): boolean {
         return this.__isEnabled ?? true; // if it has no enabled field it is always enabled

package/src/engine-components/Networking.ts

@@ -1,17 +1,25 @@
+import { serializable } from "../engine/engine_serialization";
 import { INetworkingWebsocketUrlProvider } from "../engine/engine_networking";
 import { isLocalNetwork } from "../engine/engine_networking_utils";
 import { getParam } from "../engine/engine_utils";
 import { Behaviour } from "./Component";
 
+const debug = getParam("debugnet");
+
 export class Networking extends Behaviour implements INetworkingWebsocketUrlProvider {
 
+    @serializable()
     url: string | null = null;
+    @serializable()
     urlParameterName: string | null = null;
 
     // used when local host is detected
+    @serializable()
     localhost: string | null = null;
 
-    awake(){
+    awake() {
+        if (debug)
+            console.log(this);
         this.context.connection.registerProvider(this);
     }
 

package/src/engine-components/OrbitControls.ts

@@ -11,6 +11,7 @@ import { OrbitControls as ThreeOrbitControls } from "three/examples/jsm/controls
 import { EventSystem, EventSystemEvents } from "./ui/EventSystem";
 import { ICameraController } from "../engine/engine_types";
 import { setCameraController } from "../engine/engine_camera";
+import { SyncedTransform } from "./SyncedTransform";
 
 const freeCam = getParam("freecam");
 
@@ -70,7 +71,8 @@ export class OrbitControls extends Behaviour implements ICameraController {
 
     private _eventSystem?: EventSystem;
     private _afterHandleInputFn?: any;
-    private _camera : Camera | null = null;
+    private _camera: Camera | null = null;
+    private _syncedTransform?: SyncedTransform;
 
     targetElement: HTMLElement | null = null;
 
@@ -133,6 +135,7 @@ export class OrbitControls extends Behaviour implements ICameraController {
             this._controls.autoRotate = this.autoRotate;
             this._controls.autoRotateSpeed = this.autoRotateSpeed;
             this._controls.enableZoom = this.enableZoom;
+            this._controls.addEventListener("start", this.onControlsChangeStarted.bind(this));
             if (cam?.type === "PerspectiveCamera") {
                 if (freeCam) {
                     // dont set limits
@@ -158,7 +161,7 @@ export class OrbitControls extends Behaviour implements ICameraController {
                 this._controls.listenToKeyEvents(window.document.body);
             }
         }
-
+        this._syncedTransform = GameObject.getComponent(this.gameObject, SyncedTransform) ?? undefined;
     }
 
     onDisable() {
@@ -172,6 +175,12 @@ export class OrbitControls extends Behaviour implements ICameraController {
         }
     }
 
+    private onControlsChangeStarted() {
+        if(this._syncedTransform) {
+            this._syncedTransform.requestOwnership();
+        }
+    }
+
     private _shouldDisable: boolean = false;
     private afterHandleInput() {
         if (this._controls && this._eventSystem) {

package/src/engine-components/ParticleSystem.ts

@@ -17,7 +17,8 @@ import { Mathf } from "../engine/engine_math";
 import { Context } from "../engine/engine_setup";
 import { ParticleSubEmitter } from "./ParticleSystemSubEmitter";
 import { NEEDLE_progressive } from "../engine/extensions/NEEDLE_progressive";
-import { Gizmos, isDevEnvironment } from "../engine/api";
+import { Gizmos } from "../engine/engine_gizmos";
+import { isDevEnvironment } from "../engine/debug";
 
 const debug = getParam("debugparticles");
 const suppressProgressiveLoading = getParam("noprogressive");
@@ -330,7 +331,7 @@ class SizeBehaviour extends ParticleSystemBaseBehaviour {
     }
 }
 
-const $particleLife = Symbol("particleLife");
+export const $particleLife = Symbol("particleLife");
 const $trailLifetime = Symbol("trailLifetime");
 const $trailStartLength = Symbol("trailStartLength");
 
@@ -340,7 +341,6 @@ class TrailBehaviour extends ParticleSystemBaseBehaviour {
     initialize(particle: Particle) {
         if (particle instanceof TrailParticle) {
             particle[$particleLife] = particle.life;
-            particle[$trailLifetime] = particle.life;
             if (this.system.trails.enabled && this.system.trails.dieWithParticles === false) {
                 particle[$trailLifetime] = this.system.trails.lifetime.evaluate(Math.random(), Math.random());
                 particle.life += particle[$trailLifetime];
@@ -418,7 +418,7 @@ class VelocityBehaviour extends ParticleSystemBaseBehaviour {
         if (gravityFactor !== 0) {
             // gravityFactor *= -1;
             temp3.copy(this._gravityDirection).multiplyScalar(gravityFactor);
-            if(debug) Gizmos.DrawDirection(particle.position, temp3, 0x0000ff, 0, false, 10);
+            if (debug) Gizmos.DrawDirection(particle.position, temp3, 0x0000ff, 0, false, 10);
             baseVelocity.add(temp3);
         }
         particle.velocity.copy(baseVelocity);
@@ -747,6 +747,7 @@ export class ParticleSystem extends Behaviour implements IParticleSystem {
     private _time: number = 0;
     private _isPlaying: boolean = true;
     private _isUsedAsSubsystem: boolean = false;
+    private _didPreWarm: boolean = false;
 
     /** called from deserialization */
     private set bursts(arr: ParticleBurst[]) {
@@ -779,7 +780,8 @@ export class ParticleSystem extends Behaviour implements IParticleSystem {
     }
     private _subEmitterSystems?: SubEmitterSystem[];
 
-    onAfterDeserialize(_){
+    onAfterDeserialize(_) {
+        // doing this here to get a chance to resolve the subemitter guid
         if (this._subEmitterSystems && Array.isArray(this._subEmitterSystems)) {
             for (const sub of this._subEmitterSystems) {
                 sub._deserialize(this.context, this.gameObject);
@@ -788,7 +790,6 @@ export class ParticleSystem extends Behaviour implements IParticleSystem {
     }
 
     awake(): void {
-
         this._renderer = this.gameObject.getComponent(ParticleSystemRenderer) as ParticleSystemRenderer;
 
         this._container = new Object3D();
@@ -837,16 +838,49 @@ export class ParticleSystem extends Behaviour implements IParticleSystem {
     onEnable() {
         if (this.inheritVelocity)
             this.inheritVelocity.system = this;
+        if (this._batchSystem)
+            this._batchSystem.visible = true;
         this.play();
     }
 
     onDisable() {
+        if (this._batchSystem)
+            this._batchSystem.visible = false;
     }
 
     onBeforeRender() {
+        if (this._didPreWarm === false && this.main?.prewarm === true) {
+            this._didPreWarm = true;
+            this.preWarm();
+        }
         this.onUpdate();
-        const dt = this.deltaTime;
+        this.onSimulate(this.deltaTime);
+    }
+
+    private preWarm() {
+        if (!this.emission?.enabled) return;
+        const emission = this.emission.rateOverTime.getMax();
+        if (emission <= 0) return;
+        const dt = 1 / 60;
+        const duration = this.main.duration;
+        const lifetime = this.main.startLifetime.getMax();
+        const maxDurationToPrewarm = 1000;
+        const timeToSimulate = Math.min(duration, lifetime, maxDurationToPrewarm);
+        const framesToSimulate = Math.ceil(timeToSimulate / dt);
+        const startTime = Date.now();
+        if (debug)
+            console.log(`Particles ${this.name} - Prewarm for ${framesToSimulate} frames (${timeToSimulate} sec). Duration: ${duration}, Lifetime: ${lifetime}`);
+        for (let i = 0; i < framesToSimulate; i++) {
+            if (this.currentParticles >= this.maxParticles) break;
+            if (Date.now() - startTime > 2) {
+                console.warn(`Particles ${this.name} - Prewarm took too long. Aborting.`);
+            }
+            this.onUpdate();
+            this.onSimulate(dt);
+        }
+    }
 
+    private onSimulate(dt: number) {
         if (this._batchSystem) {
             // Updating layers on batches
             // TODO: figure out a better way to do this
@@ -942,10 +976,20 @@ export class SubEmitterSystem {
     properties?: number;
     type?: SubEmitterType;
 
-    _deserialize(context: Context, _gameObject: GameObject) {
+    _deserialize(_context: Context, gameObject: GameObject) {
         const ps = this.particleSystem;
-        if (ps && !(ps instanceof ParticleSystem) && typeof ps["guid"] === "string") {
-            this.particleSystem = GameObject.findByGuid(ps["guid"], context.scene) as ParticleSystem;
+        if (ps instanceof ParticleSystem) return;
+
+        let guid = "";
+
+        if (ps && typeof ps["guid"] === "string") {
+            guid = ps["guid"];
+            // subemitter MUST be a child of the particle system
+            this.particleSystem = GameObject.findByGuid(guid, gameObject) as ParticleSystem;
+        }
+
+        if (debug && !(this.particleSystem instanceof ParticleSystem)) {
+            console.warn("Could not find particle system for sub emitter", guid, gameObject, this);
         }
     }
 }

package/src/engine-components/ParticleSystemModules.ts

@@ -199,6 +199,33 @@ export class MinMaxCurve {
         }
         return 0;
     }
+
+    getMax(): number {
+        switch (this.mode) {
+            case ParticleSystemCurveMode.Constant:
+                return this.constant;
+            case ParticleSystemCurveMode.Curve:
+                return this.getMaxFromCurve(this.curve!) * this.curveMultiplier!;
+            case ParticleSystemCurveMode.TwoCurves:
+                return Math.max(this.getMaxFromCurve(this.curveMin), this.getMaxFromCurve(this.curveMax)) * this.curveMultiplier!;
+            case ParticleSystemCurveMode.TwoConstants:
+                return Math.max(this.constantMin, this.constantMax);
+            default:
+                return 0;
+        }
+    }
+
+    private getMaxFromCurve(curve?: AnimationCurve) {
+        if (!curve) return 0;
+        let maxNumber = Number.MIN_VALUE;
+        for (let i = 0; i < curve!.keys.length; i++) {
+            const key = curve!.keys[i];
+            if (key.value > maxNumber) {
+                maxNumber = key.value;
+            }
+        }
+        return maxNumber;
+    }
 }
 
 export class MinMaxGradient {
@@ -571,7 +598,7 @@ export class ShapeModule implements EmitterShape {
         if (this.enabled) {
             switch (this.shapeType) {
                 case ParticleSystemShapeType.Box:
-                    if(debug) Gizmos.DrawBox(this.position, this.scale, 0xdddddd, 1);
+                    if (debug) Gizmos.DrawBox(this.position, this.scale, 0xdddddd, 1);
                     this._vector.x = Math.random() * this.scale.x - this.scale.x / 2;
                     this._vector.y = Math.random() * this.scale.y - this.scale.y / 2;
                     this._vector.z = Math.random() * this.scale.z - this.scale.z / 2;

package/src/engine-components/ParticleSystemSubEmitter.ts

@@ -2,7 +2,7 @@ import { Behavior, Particle, EmissionState, ParticleSystem, ParticleEmitter } fr
 import { Vector3, Quaternion, Matrix4 } from "three";
 import { IParticleSystem } from "./ParticleSystemModules";
 import { CircularBuffer } from "../engine/engine_utils";
-import { SubEmitterType } from "./ParticleSystem";
+import { $particleLife, SubEmitterType } from "./ParticleSystem";
 
 const VECTOR_ONE = new Vector3(1, 1, 1);
 const VECTOR_Z = new Vector3(0, 0, 1);
@@ -73,13 +73,15 @@ export class ParticleSubEmitter implements Behavior {
         if (!this.subParticleSystem || !particle.emissionState)
             return;
 
-        if(this.emitterProbability && Math.random() > this.emitterProbability)
+        if (this.emitterProbability && Math.random() > this.emitterProbability)
             return;
 
         const delta = this.system.deltaTime;
 
         if (this.emitterType === SubEmitterType.Death) {
-            const willDie = particle.age + delta * 1.2 >= particle.life;
+            let lifeTime = particle.life;
+            if (particle[$particleLife] !== undefined) lifeTime = particle[$particleLife];
+            const willDie = particle.age + delta * 1.2 >= lifeTime;
             if (!willDie) return;
             // Just emit all for now, we should probably add a way to get the amount from the subsystem emission module
             const maxAmount = this.subSystem.main.maxParticles - this.subSystem.currentParticles;

package/src/engine-components/ReflectionProbe.ts

@@ -1,5 +1,5 @@
 import { Behaviour } from "./Component";
-import { Box3, Color, EquirectangularReflectionMapping, LineBasicMaterial, Material, MeshStandardMaterial, Object3D, sRGBEncoding, Texture, Vector3, WebGLCubeRenderTarget, WebGLRenderTarget } from "three";
+import { Box3, Color, EquirectangularReflectionMapping, LinearEncoding, LineBasicMaterial, Material, MeshStandardMaterial, Object3D, SrcAlphaFactor, sRGBEncoding, Texture, Vector3, WebGLCubeRenderTarget, WebGLRenderTarget } from "three";
 import { serializable } from "../engine/engine_serialization";
 import { Context } from "../engine/engine_setup";
 import { getWorldPosition, getWorldScale } from "../engine/engine_three_utils";
@@ -47,7 +47,16 @@ export class ReflectionProbe extends Behaviour {
 
     private _texture!: Texture;
     set texture(tex: Texture) {
+        if (tex && !(tex instanceof Texture)) {
+            console.error("ReflectionProbe.texture must be a Texture", tex);
+            return;
+        }
         this._texture = tex;
+        if (tex) {
+            tex.mapping = EquirectangularReflectionMapping;
+            tex.encoding = sRGBEncoding;
+            tex.needsUpdate = true;
+        }
     }
     get texture(): Texture {
         return this._texture;
@@ -81,8 +90,6 @@ export class ReflectionProbe extends Behaviour {
         if (this.texture) {
             this.texture.mapping = EquirectangularReflectionMapping;
             this.texture.encoding = sRGBEncoding;
-            // this.texture.rotation = Math.PI;
-            // this.texture.flipY = true;
             this.texture.needsUpdate = true;
         }
     }
@@ -106,6 +113,7 @@ export class ReflectionProbe extends Behaviour {
 
     onSet(_rend: IRenderer) {
         if (disable) return;
+        if (!this.enabled) return;
         if (_rend.sharedMaterials?.length <= 0) return;
         if (!this.texture) return;
 
@@ -129,8 +137,10 @@ export class ReflectionProbe extends Behaviour {
             let cached = rendererCache[i];
 
             // make sure we have the currently assigned material cached (and an up to date clone of that)
-            if (!cached || cached.material !== material || cached.material.version !== material.version) {
+            if (!cached || cached.material !== material || cached.copy.version !== material.version) {
+                if(debug) console.log("Cloning material", material.name, material.version);
                 const clone = material.clone();
+                clone.version = material.version;
 
                 if (cached) {
                     cached.copy = clone;
@@ -147,9 +157,6 @@ export class ReflectionProbe extends Behaviour {
                 clone[$reflectionProbeKey] = this;
                 clone[$originalMaterial] = material;
 
-                // make sure the reflection probe is assigned
-                clone["envMap"] = this.texture;
-
                 if (debug)
                     console.log("Set reflection", _rend.name, _rend.guid);
             }
@@ -157,6 +164,9 @@ export class ReflectionProbe extends Behaviour {
             /** this is the material that we copied and that has the reflection probe */
             const copy = cached?.copy;
 
+            // make sure the reflection probe is assigned
+            copy["envMap"] = this.texture;
+
             _rend.sharedMaterials[i] = copy;
         }
     }