Merge main to dev/0.5

.github/FUNDING.yml

@@ -0,0 +1,4 @@
+# These are supported funding model platforms
+
+github: [oasis-engine]
+open_collective: oasis

README.md

@@ -86,7 +86,7 @@ npm run bootstrap
 Then, to build the source, using npm:
 
 ```sh
-npm run build
+npm run b:all
 ```
 
 ## Links

packages/core/src/Scene.ts

@@ -69,14 +69,6 @@ export class Scene extends EngineObject {
     Scene.sceneFeatureManager.addObject(this);
     shaderData._addRefCount(1);
     this.ambientLight = new AmbientLight(this);
-
-    // @todo: this is device macro,should add when compile shader.
-    if (this._engine._hardwareRenderer.canIUse(GLCapabilityType.shaderTextureLod)) {
-      shaderData.enableMacro("HAS_TEX_LOD");
-    }
-    if (this._engine._hardwareRenderer.canIUse(GLCapabilityType.standardDerivatives)) {
-      shaderData.enableMacro("HAS_DERIVATIVES");
-    }
   }
 
   /**

packages/core/src/Transform.ts

@@ -677,10 +677,7 @@ export class Transform extends Component {
 
   private _translate(translation: Vector3, relativeToLocal: boolean = true): void {
     if (relativeToLocal) {
-      const rotationMat = Transform._tempMat40;
-      Matrix.rotationQuaternion(this.rotationQuaternion, rotationMat);
-      Vector3.transformCoordinate(translation, rotationMat, Transform._tempVec3);
-      this.position = this._position.add(Transform._tempVec3);
+      this.position = this._position.add(translation);
     } else {
       this.worldPosition = this._worldPosition.add(translation);
     }

packages/core/src/asset/request.ts

@@ -76,6 +76,9 @@ function requestImage<T>(url: string, config: RequestConfig): AssetPromise<T> {
         requestAnimationFrame(() => {
           //@ts-ignore
           resolve(img);
+          img.onload = null;
+          img.onerror = null;
+          img.onabort = null;
         });
         clearTimeout(timeoutId);
       };

packages/core/src/shader/Shader.ts

@@ -1,3 +1,4 @@
+import { GLCapabilityType } from "../base/Constant";
 import { Engine } from "../Engine";
 import { ShaderFactory } from "../shaderlib/ShaderFactory";
 import { ShaderDataGroup } from "./enums/ShaderDataGroup";
@@ -157,7 +158,7 @@ export class Shader {
     Shader._getNamesByMacros(macroCollection, macroNameList);
     const macroNameStr = ShaderFactory.parseCustomMacros(macroNameList);
     const versionStr = isWebGL2 ? "#version 300 es" : "#version 100";
-    const precisionStr = `
+    let precisionStr = `
     #ifdef GL_FRAGMENT_PRECISION_HIGH
       precision highp float;
       precision highp int;
@@ -171,6 +172,13 @@ export class Shader {
     #endif
     `;
 
+    if (engine._hardwareRenderer.canIUse(GLCapabilityType.shaderTextureLod)) {
+      precisionStr += "#define HAS_TEX_LOD\n";
+    }
+    if (engine._hardwareRenderer.canIUse(GLCapabilityType.standardDerivatives)) {
+      precisionStr += "#define HAS_DERIVATIVES\n";
+    }
+
     let vertexSource = ShaderFactory.parseIncludes(
       ` ${versionStr}
         ${precisionStr}

packages/core/src/shader/ShaderProgram.ts

@@ -262,7 +262,7 @@ export class ShaderProgram {
       return null;
     }
 
-    if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+    if (Logger.isEnabled && !gl.getProgramParameter(program, gl.LINK_STATUS)) {
       Logger.error("Could not link WebGL program. \n" + gl.getProgramInfoLog(program));
       gl.deleteProgram(program);
       return null;
@@ -291,7 +291,7 @@ export class ShaderProgram {
       return null;
     }
 
-    if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+    if (Logger.isEnabled && !gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
       Logger.error(
         `Could not compile WebGL shader.\n${gl.getShaderInfoLog(shader)}`,
         ShaderProgram._addLineNum(shaderSource)

packages/core/src/shaderlib/ShaderFactory.ts

@@ -4,9 +4,7 @@ import { Logger } from "../base/Logger";
 class ShaderFactory {
   static parseCustomMacros(macros: string[]) {
     return (
-      "#define O3_CUSTOM_MACROS_START\n" +
-      macros.map((m) => `#define ${m}\n`).join("") +
-      "#define O3_CUSTOM_MACROS_END\n"
+      macros.map((m) => `#define ${m}\n`).join("")
     );
   }
 
@@ -33,9 +31,7 @@ class ShaderFactory {
    * */
   static parseExtension(extensions: string[]) {
     return (
-      `#define O3_EXTENSION_START\n` +
-      extensions.map((e) => `#extension ${e} : enable\n`).join("") +
-      `#define O3_EXTENSION_END\n`
+      extensions.map((e) => `#extension ${e} : enable\n`).join("")
     );
   }
 

packages/core/src/texture/enums/TextureFormat.ts

@@ -14,6 +14,8 @@ export enum TextureFormat {
   R5G6B5,
   /** Transparent format,8 bits. */
   Alpha8,
+  /** Luminance/alpha in RGB channel, alpha in A channel. */
+  LuminanceAlpha,
   /** RGBA format,32 bits per channel. */
   R32G32B32A32,
   /** RGB compressed format。*/

packages/loader/src/gltf/GLTFUtil.ts

@@ -266,6 +266,9 @@ export class GLTFUtil {
         // Call requestAnimationFrame to avoid iOS's bug.
         requestAnimationFrame(() => {
           resolve(img);
+          img.onload = null;
+          img.onerror = null;
+          img.onabort = null;
         });
       };
     });

packages/loader/src/scene-loader/AbilityManager.ts

@@ -35,6 +35,9 @@ export class AbilityManager {
     } else if (type === "Model") {
       // TODO
       (ability as any).setProps(abilityProps);
+      if (abilityProps.material) {
+        (ability as any).material = abilityProps.material;
+      }
     } else {
       for (let k in abilityProps) {
         if (abilityProps[k] !== null) {
@@ -54,16 +57,11 @@ export class AbilityManager {
 
   @pluginHook({ before: "beforeAbilityUpdated", after: "abilityUpdated" })
   public update(id: string, key: string, value: any) {
-    if (this.get(id).constructor === Model) {
-      // TODO
-      if (value && this.checkIsAsset(value)) {
-        (this.get(id) as any).setProp(key, this.oasis.resourceManager.get(value.id).resource);
-      } else {
-        (this.get(id) as any).updateProp(key, value);
-      }
+    if (value && this.checkIsAsset(value)) {
+      this.get(id)[key] = this.oasis.resourceManager.get(value.id).resource;
     } else {
-      if (value && this.checkIsAsset(value)) {
-        this.get(id)[key] = this.oasis.resourceManager.get(value.id).resource;
+      if (this.get(id).constructor === Model) {
+        (this.get(id) as any).updateProp(key, value);
       } else {
         this.get(id)[key] = value;
       }

packages/loader/src/scene-loader/SceneManager.ts

@@ -1,3 +1,4 @@
+import { PrimitiveMesh, SkyBoxMaterial } from "@oasis-engine/core";
 import { Oasis } from "./Oasis";
 import { pluginHook } from "./plugins/PluginManager";
 
@@ -25,7 +26,18 @@ export class SceneManager {
 
   private setProp(field, key, prop) {
     const scene = this.oasis.engine.sceneManager.activeScene;
-    if (scene[field]) {
+    if (field === "background" && key === "skyboxTexture") {
+      const sky = scene.background.sky;
+      if (prop) {
+        sky.mesh = PrimitiveMesh.createCuboid(scene.engine, 2, 2, 2);
+        const skyMaterial = new SkyBoxMaterial(scene.engine);
+        skyMaterial.textureCubeMap = this.oasis.resourceManager.get(prop.id).resource;
+        sky.material = skyMaterial;
+      } else {
+        sky.mesh = null;
+        sky.material = null;
+      }
+    } else if (scene[field]) {
       if (prop && prop.type === "asset") {
         scene[field][key] = this.oasis.resourceManager.get(prop.id).resource;
       } else {

packages/loader/src/scene-loader/resources/GLTFResource.ts

@@ -19,16 +19,14 @@ import { UnlitMaterialResource } from "./UnlitMaterialResource";
 
 export class GLTFResource extends SchemaResource {
   load(resourceManager: ResourceManager, assetConfig: AssetConfig, oasis: Oasis): Promise<any> {
-    return resourceManager
-      .load<any>({ url: assetConfig.url, type: AssetType.Prefab })
-      .then((res) => {
-        const gltf = res;
-        if (assetConfig.props) {
-          gltf.newMaterial = (assetConfig.props as any).newMaterial;
-          gltf.animatorControllers = (assetConfig.props as any).animatorControllers;
-        }
-        this._resource = gltf;
-      });
+    return resourceManager.load<any>({ url: assetConfig.url, type: AssetType.Prefab }).then((res) => {
+      const gltf = res;
+      if (assetConfig.props) {
+        gltf.newMaterial = (assetConfig.props as any).newMaterial;
+        gltf.animatorControllers = (assetConfig.props as any).animatorControllers;
+      }
+      this._resource = gltf;
+    });
   }
 
   loadWithAttachedResources(
@@ -53,33 +51,35 @@ export class GLTFResource extends SchemaResource {
             }
           }
         };
-        for (let i = 0; i < materials.length; i++) {
-          const material = materials[i];
-          let materialResource = null;
-          let type = "";
-
-          if (material instanceof PBRMaterial) {
-            materialResource = new PBRMaterialResource(this.resourceManager);
-            type = "PBRMaterial";
-          } else if (material instanceof UnlitMaterial) {
-            materialResource = new UnlitMaterialResource(this.resourceManager);
-            type = "UnlitMaterial";
-          } else if (material instanceof PBRSpecularMaterial) {
-            materialResource = new PBRSpecularMaterialResource(this.resourceManager);
-            type = "PBRSpecularMaterial";
-          } else {
-            materialResource = new BlinnPhongMaterialResource(this.resourceManager);
-            type = "BlinnPhongMaterial";
-          }
+        if (materials?.length) {
+          for (let i = 0; i < materials.length; i++) {
+            const material = materials[i];
+            let materialResource = null;
+            let type = "";
+
+            if (material instanceof PBRMaterial) {
+              materialResource = new PBRMaterialResource(this.resourceManager);
+              type = "PBRMaterial";
+            } else if (material instanceof UnlitMaterial) {
+              materialResource = new UnlitMaterialResource(this.resourceManager);
+              type = "UnlitMaterial";
+            } else if (material instanceof PBRSpecularMaterial) {
+              materialResource = new PBRSpecularMaterialResource(this.resourceManager);
+              type = "PBRSpecularMaterial";
+            } else {
+              materialResource = new BlinnPhongMaterialResource(this.resourceManager);
+              type = "BlinnPhongMaterial";
+            }
 
-          this._attachedResources.push(materialResource);
-          materialLoadPromises.push(
-            materialResource.loadWithAttachedResources(resourceManager, {
-              type,
-              name: material.name,
-              resource: material
-            })
-          );
+            this._attachedResources.push(materialResource);
+            materialLoadPromises.push(
+              materialResource.loadWithAttachedResources(resourceManager, {
+                type,
+                name: material.name,
+                resource: material
+              })
+            );
+          }
         }
 
         if (_animationsIndices.length) {
@@ -113,23 +113,25 @@ export class GLTFResource extends SchemaResource {
             newMaterial.push(matStructure);
           });
         });
-        const loadAttachedController = animatorControllerLoadPromise ? animatorControllerLoadPromise.then((res) => {
-          const { animatorControllers } = result.structure.props;
-          const controllerStructure = res.structure;
-          const controllerResource = res.resources[controllerStructure.index];
-          result.resources.push(controllerResource as any);
-          controllerStructure.index = result.resources.length - 1;
-          const { animationClips } = controllerStructure.props;
-          if (animationClips) {
-            for (let i = 0, length = animationClips.length; i < length; ++i) {
-              const clipStructure = animationClips[i];
-              const clipResource = res.resources[clipStructure.index];
-              result.resources.push(clipResource);
-              clipStructure.index = result.resources.length - 1;
-            }
-          }
-          animatorControllers.push(controllerStructure);
-        }) : Promise.resolve();
+        const loadAttachedController = animatorControllerLoadPromise
+          ? animatorControllerLoadPromise.then((res) => {
+              const { animatorControllers } = result.structure.props;
+              const controllerStructure = res.structure;
+              const controllerResource = res.resources[controllerStructure.index];
+              result.resources.push(controllerResource as any);
+              controllerStructure.index = result.resources.length - 1;
+              const { animationClips } = controllerStructure.props;
+              if (animationClips) {
+                for (let i = 0, length = animationClips.length; i < length; ++i) {
+                  const clipStructure = animationClips[i];
+                  const clipResource = res.resources[clipStructure.index];
+                  result.resources.push(clipResource);
+                  clipStructure.index = result.resources.length - 1;
+                }
+              }
+              animatorControllers.push(controllerStructure);
+            })
+          : Promise.resolve();
         Promise.all([loadAttachedMaterial, loadAttachedController]).then(() => {
           resolve(result);
         });
@@ -175,7 +177,7 @@ export class GLTFResource extends SchemaResource {
         newMaterials[i] = mtlResource.resource;
       } else {
         Logger.warn(
-          `GLTFResource: ${ this.meta.name } can't find asset "material", which id is: ${ newMaterialsConfig[i].id }`
+          `GLTFResource: ${this.meta.name} can't find asset "material", which id is: ${newMaterialsConfig[i].id}`
         );
       }
     }
@@ -203,11 +205,11 @@ export class GLTFResource extends SchemaResource {
     for (let i = 0, length = animatorControllers.length; i < length; i++) {
       const animatorControllerAsset = animatorControllers[i];
       const controllerResource = <AnimatorControllerResource>this.resourceManager.get(animatorControllerAsset.id);
-      controllerResource.gltf= this._resource;
+      controllerResource.gltf = this._resource;
       if (controllerResource) {
         this._attachedResources.push(controllerResource);
       } else {
-        `GLTFResource: ${ this.meta.name } can't find asset "animatorController", which id is: ${ animatorControllerAsset.id }`
+        `GLTFResource: ${this.meta.name} can't find asset "animatorController", which id is: ${animatorControllerAsset.id}`;
       }
     }
   }

packages/loader/src/scene-loader/resources/TextureResource.ts

@@ -38,9 +38,6 @@ export class TextureResource extends SchemaResource {
   setMeta() {
     if (this.resource) {
       this._meta.name = this.resource.name;
-      if (this.resource.image) {
-        this._meta.url = this.resource.image.src;
-      }
     }
   }
 }

packages/loader/src/scene-loader/temp.compatible.ts

@@ -32,7 +32,7 @@ function handleComponents(props) {
     const k = keys[i];
     const v = props[k];
 
-    if (Array.isArray(v) && typeof v[0] !== 'object') {
+    if (Array.isArray(v) && typeof v[0] !== "object") {
       if (["color", "diffuseColor", "specularColor"].indexOf(k) !== -1) {
         props[k] = new Color(v[0], v[1], v[2], v[3]);
       } else if (v.length === 4) {
@@ -54,7 +54,7 @@ function handleSceneProps(props) {
     const k = keys[i];
     const v = props[k];
 
-    if (Array.isArray(v) && typeof v[0] !== 'object') {
+    if (Array.isArray(v) && typeof v[0] !== "object") {
       if (/color/i.test(k)) {
         props[k] = new Color(v[0], v[1], v[2], v[3]);
       } else if (v.length === 4) {
@@ -84,7 +84,7 @@ function handleAssets(props: any = {}) {
       continue;
     }
 
-    if (Array.isArray(value) && typeof value[0] !== 'object') {
+    if (Array.isArray(value) && typeof value[0] !== "object") {
       if (["emissiveColor", "diffuseColor", "specularColor", "baseColor"].indexOf(key) !== -1) {
         props[key] = new Color(value[0], value[1], value[2], value[3]);
       } else if (value.length === 4) {

packages/loader/tests/gltf/parser.test.ts

@@ -69,6 +69,6 @@ describe("AnimationClipLoader Test", () => {
     expect(animations.length === 1).toEqual(true);
     const animation = animations[0];
     expect(animation.name === "animation_AnimatedCube").toEqual(true);
-    expect(animation._curves.length).toEqual(1);
+    expect(animation.curveBindings.length).toEqual(1);
   });
 });