Merge dev/0.6 branch

packages/core/src/2d/sprite/Sprite.ts

@@ -108,8 +108,13 @@ export class Sprite extends RefObject {
   }
 
   set pivot(value: Vector2) {
-    this._pivot.setValue(MathUtil.clamp(value.x, 0, 1), MathUtil.clamp(value.y, 0, 1));
-    this._setDirtyFlagTrue(DirtyFlag.positions);
+    const pivot = this._pivot;
+    const x = MathUtil.clamp(value.x, 0, 1);
+    const y = MathUtil.clamp(value.y, 0, 1);
+    if (pivot === value || pivot.x !== x || pivot.y !== y) {
+      pivot.setValue(x, y);
+      this._setDirtyFlagTrue(DirtyFlag.positions);
+    }
   }
 
   /**
@@ -141,6 +146,26 @@ export class Sprite extends RefObject {
     }
   }
 
+  /**
+   * Clone.
+   * @returns Cloned sprite
+   */
+  clone(): Sprite {
+    const cloneSprite = new Sprite(
+      this._engine,
+      this._texture,
+      this._region,
+      this._pivot,
+      this._pixelsPerUnit,
+      this.name
+    );
+    cloneSprite._assetID = this._assetID;
+    cloneSprite._atlasRotated = this._atlasRotated;
+    this._atlasRegion.cloneTo(cloneSprite._atlasRegion);
+    this._atlasRegionOffset.cloneTo(cloneSprite._atlasRegionOffset);
+    return cloneSprite;
+  }
+
   /**
    * Constructor a Sprite.
    * @param engine - Engine to which the sprite belongs

packages/core/src/Camera.ts

@@ -1,4 +1,5 @@
 import { BoundingFrustum, MathUtil, Matrix, Ray, Vector2, Vector3, Vector4 } from "@oasis-engine/math";
+import { Logger } from "./base";
 import { deepClone, ignoreClone } from "./clone/CloneManager";
 import { Component } from "./Component";
 import { dependencies } from "./ComponentsDependencies";
@@ -414,8 +415,9 @@ export class Camera extends Component {
   /**
    * Manually call the rendering of the camera.
    * @param cubeFace - Cube rendering surface collection
+   * @param mipLevel - Set mip level the data want to write, only take effect in webgl2.0
    */
-  render(cubeFace?: TextureCubeFace): void {
+  render(cubeFace?: TextureCubeFace, mipLevel: number = 0): void {
     // compute cull frustum.
     const context = this.engine._renderContext;
     context._setContext(this);
@@ -429,12 +431,16 @@ export class Camera extends Component {
 
     // union scene and camera macro.
     ShaderMacroCollection.unionCollection(
-      this.scene.shaderData._macroCollection,
+      this.scene._globalShaderMacro,
       this.shaderData._macroCollection,
       this._globalShaderMacro
     );
 
-    this._renderPipeline.render(context, cubeFace);
+    if (mipLevel > 0 && !this.engine._hardwareRenderer.isWebGL2) {
+      mipLevel = 0;
+      Logger.error("mipLevel only take effect in WebGL2.0");
+    }
+    this._renderPipeline.render(context, cubeFace, mipLevel);
     this._engine._renderCount++;
   }
 

packages/core/src/ComponentsManager.ts

@@ -6,6 +6,7 @@ import { Script } from "./Script";
 import { ShaderMacroCollection } from "./shader/ShaderMacroCollection";
 import { RenderContext } from "./RenderPipeline/RenderContext";
 import { Vector3 } from "@oasis-engine/math";
+import { Collider } from "./physics/Collider";
 
 /**
  * The manager of the components.
@@ -30,6 +31,9 @@ export class ComponentsManager {
   // Delay dispose active/inActive Pool
   private _componentsContainerPool: Component[][] = [];
 
+  // Physics
+  private _colliders: DisorderedArray<Collider> = new DisorderedArray();
+
   addRenderer(renderer: Renderer) {
     renderer._rendererIndex = this._renderers.length;
     this._renderers.add(renderer);
@@ -52,6 +56,17 @@ export class ComponentsManager {
     script._onStartIndex = -1;
   }
 
+  addCollider(collider: Collider) {
+    collider._index = this._colliders.length;
+    this._colliders.add(collider);
+  }
+
+  removeCollider(collider: Collider): void {
+    const replaced = this._colliders.deleteByIndex(collider._index);
+    replaced && (replaced._index = collider._index);
+    collider._index = -1;
+  }
+
   addOnUpdateScript(script: Script) {
     script._onUpdateIndex = this._onUpdateScripts.length;
     this._onUpdateScripts.add(script);
@@ -224,6 +239,20 @@ export class ComponentsManager {
     }
   }
 
+  callColliderOnUpdate() {
+    const elements = this._colliders._elements;
+    for (let i = this._colliders.length - 1; i >= 0; --i) {
+      elements[i]._onUpdate();
+    }
+  }
+
+  callColliderOnLateUpdate() {
+    const elements = this._colliders._elements;
+    for (let i = this._colliders.length - 1; i >= 0; --i) {
+      elements[i]._onLateUpdate();
+    }
+  }
+
   getActiveChangedTempList(): Component[] {
     return this._componentsContainerPool.length ? this._componentsContainerPool.pop() : [];
   }

packages/core/src/Engine.ts

@@ -1,12 +1,18 @@
+import { IPhysics } from "@oasis-engine/design";
+import { ColorSpace } from ".";
 import { ResourceManager } from "./asset/ResourceManager";
 import { Event, EventDispatcher, Logger, Time } from "./base";
 import { Canvas } from "./Canvas";
 import { ComponentsManager } from "./ComponentsManager";
 import { EngineFeature } from "./EngineFeature";
+import { EngineSettings } from "./EngineSettings";
 import { Entity } from "./Entity";
 import { FeatureManager } from "./FeatureManager";
+import { InputManager } from "./input/InputManager";
 import { RenderQueueType } from "./material/enums/RenderQueueType";
 import { Material } from "./material/Material";
+import { ModelMesh, PrimitiveMesh } from "./mesh";
+import { PhysicsManager } from "./physics";
 import { IHardwareRenderer } from "./renderingHardwareInterface/IHardwareRenderer";
 import { ClassPool } from "./RenderPipeline/ClassPool";
 import { RenderContext } from "./RenderPipeline/RenderContext";
@@ -16,18 +22,18 @@ import { SpriteMaskElement } from "./RenderPipeline/SpriteMaskElement";
 import { SpriteMaskManager } from "./RenderPipeline/SpriteMaskManager";
 import { Scene } from "./Scene";
 import { SceneManager } from "./SceneManager";
+import { CompareFunction } from "./shader";
 import { BlendFactor } from "./shader/enums/BlendFactor";
 import { BlendOperation } from "./shader/enums/BlendOperation";
 import { ColorWriteMask } from "./shader/enums/ColorWriteMask";
 import { CullMode } from "./shader/enums/CullMode";
 import { Shader } from "./shader/Shader";
+import { ShaderMacro } from "./shader/ShaderMacro";
+import { ShaderMacroCollection } from "./shader/ShaderMacroCollection";
 import { ShaderPool } from "./shader/ShaderPool";
 import { ShaderProgramPool } from "./shader/ShaderProgramPool";
 import { RenderState } from "./shader/state/RenderState";
 import { Texture2D, TextureCubeFace, TextureCubeMap, TextureFormat } from "./texture";
-import { PhysicsManager } from "./PhysicsManager";
-import { ModelMesh, PrimitiveMesh } from "./mesh";
-import { CompareFunction } from "./shader";
 
 /** TODO: delete */
 const engineFeatureManager = new FeatureManager<EngineFeature>();
@@ -37,8 +43,11 @@ ShaderPool.init();
  * Engine.
  */
 export class Engine extends EventDispatcher {
+  /** @internal */
+  static _gammaMacro: ShaderMacro = Shader.getMacroByName("OASIS_COLORSPACE_GAMMA");
+
   /** Physics manager of Engine. */
-  readonly physicsManager: PhysicsManager = new PhysicsManager(this);
+  readonly physicsManager: PhysicsManager;
 
   _componentsManager: ComponentsManager = new ComponentsManager();
   _hardwareRenderer: IHardwareRenderer;
@@ -64,8 +73,14 @@ export class Engine extends EventDispatcher {
   _shaderProgramPools: ShaderProgramPool[] = [];
   /** @internal */
   _spriteMaskManager: SpriteMaskManager;
+  /** @internal */
+  _inputManager: InputManager;
+  /** @internal */
+  _macroCollection: ShaderMacroCollection = new ShaderMacroCollection();
 
   protected _canvas: Canvas;
+
+  private _settings: EngineSettings = {};
   private _resourceManager: ResourceManager = new ResourceManager(this);
   private _sceneManager: SceneManager = new SceneManager(this);
   private _vSyncCount: number = 1;
@@ -90,6 +105,13 @@ export class Engine extends EventDispatcher {
     }
   };
 
+  /**
+   * Settings of Engine.
+   */
+  get settings(): Readonly<EngineSettings> {
+    return this._settings;
+  }
+
   /**
    * The canvas to use for rendering.
    */
@@ -157,11 +179,16 @@ export class Engine extends EventDispatcher {
    * Create engine.
    * @param canvas - The canvas to use for rendering
    * @param hardwareRenderer - Graphics API renderer
+   * @param physics - native physics Engine
    */
-  constructor(canvas: Canvas, hardwareRenderer: IHardwareRenderer) {
+  constructor(canvas: Canvas, hardwareRenderer: IHardwareRenderer, physics?: IPhysics, settings?: EngineSettings) {
     super(null);
     this._hardwareRenderer = hardwareRenderer;
     this._hardwareRenderer.init(canvas);
+    if (physics) {
+      PhysicsManager._nativePhysics = physics;
+      this.physicsManager = new PhysicsManager();
+    }
     this._canvas = canvas;
     // @todo delete
     engineFeatureManager.addObject(this);
@@ -171,6 +198,8 @@ export class Engine extends EventDispatcher {
     this._spriteDefaultMaterial = this._createSpriteMaterial();
     this._spriteMaskDefaultMaterial = this._createSpriteMaskMaterial();
 
+    this._inputManager = new InputManager(this);
+
     const whitePixel = new Uint8Array([255, 255, 255, 255]);
 
     const whiteTexture2D = new Texture2D(this, 1, 1, TextureFormat.R8G8B8A8, false);
@@ -195,6 +224,10 @@ export class Engine extends EventDispatcher {
 
     this._backgroundTextureMesh = PrimitiveMesh.createPlane(this, 2, 2, 1, 1, false);
     this._backgroundTextureMesh.isGCIgnored = true;
+
+    const colorSpace = settings?.colorSpace || ColorSpace.Linear;
+    colorSpace === ColorSpace.Gamma && this._macroCollection.enable(Engine._gammaMacro);
+    this._settings.colorSpace = colorSpace;
   }
 
   /**
@@ -242,7 +275,15 @@ export class Engine extends EventDispatcher {
     const scene = this._sceneManager._activeScene;
     const componentsManager = this._componentsManager;
     if (scene) {
+      scene._activeCameras.sort((camera1, camera2) => camera1.priority - camera2.priority);
+
       componentsManager.callScriptOnStart();
+      if (this.physicsManager) {
+        componentsManager.callColliderOnUpdate();
+        this.physicsManager._update(deltaTime);
+        componentsManager.callColliderOnLateUpdate();
+      }
+      this._inputManager._update();
       componentsManager.callScriptOnUpdate(deltaTime);
       componentsManager.callAnimationUpdate(deltaTime);
       componentsManager.callScriptOnLateUpdate(deltaTime);
@@ -272,7 +313,7 @@ export class Engine extends EventDispatcher {
     if (this._sceneManager) {
       this._whiteTexture2D.destroy(true);
       this._whiteTextureCube.destroy(true);
-
+      this._inputManager._destroy();
       this.trigger(new Event("shutdown", this));
       engineFeatureManager.callFeatureMethod(this, "shutdown", [this]);
 
@@ -328,9 +369,6 @@ export class Engine extends EventDispatcher {
     scene._updateShaderData();
 
     if (cameras.length > 0) {
-      // Sort on priority
-      //@ts-ignore
-      cameras.sort((camera1, camera2) => camera1.priority - camera2.priority);
       for (let i = 0, l = cameras.length; i < l; i++) {
         const camera = cameras[i];
         const cameraEntity = camera.entity;

packages/core/src/EngineSettings.ts

@@ -0,0 +1,9 @@
+import { ColorSpace } from "./enums/ColorSpace";
+
+/**
+ * Render settings.
+ */
+export interface EngineSettings {
+  /** Color space.*/
+  colorSpace?: ColorSpace;
+}