Adds unit tests for async material constructor

Author: mzschwartz5

packages/engine/Source/Scene/Material.js

@@ -675,23 +675,26 @@ function initializeMaterial(options, result) {
   // If the cache contains this material type, build the material template off of the stored template.
   const cachedMaterial = Material._materialCache.getMaterial(result.type);
   if (defined(cachedMaterial)) {
-    const template = clone(cachedMaterial.fabric, true);
+    const template = clone(
+      cachedMaterial.fabric ?? cachedMaterial._template,
+      true,
+    );
     result._template = combine(result._template, template, true);
     translucent = cachedMaterial.translucent;
   }
 
   // Make sure the template has no obvious errors. More error checking happens later.
   checkForTemplateErrors(result);
 
+  createMethodDefinition(result);
+  createUniforms(result);
+  createSubMaterials(result);
+
   // If the material has a new type, add it to the cache.
   if (!defined(cachedMaterial)) {
     Material._materialCache.addMaterial(result.type, result);
   }
 
-  createMethodDefinition(result);
-  createUniforms(result);
-  createSubMaterials(result);
-
   const defaultTranslucent =
     result._translucentFunctions.length === 0 ? true : undefined;
   translucent = translucent ?? defaultTranslucent;
@@ -970,7 +973,7 @@ function createTexture2DUpdateFunction(uniformId) {
  *
  * @param {Material} material The material to load the texture for.
  * @param {string} uniformId The ID of the uniform of the image.
- * @returns {Promise} A promise that resolves when the image is loaded, or a resolved promise if image loading is not necessary.
+ * @returns A promise that resolves when the image is loaded, or a resolved promise if image loading is not necessary.
  *
  * @private
  */
@@ -1053,9 +1056,9 @@ function createCubeMapUpdateFunction(uniformId) {
  *
  * @param {Material} material The material to load the cubemap images for.
  * @param {string} uniformId The ID of the uniform that corresponds to the cubemap images.
- * @returns {Promise} A promise that resolves when the images are loaded, or a resolved promise if image loading is not necessary.
+ * @returns A promise that resolves when the images are loaded, or a resolved promise if image loading is not necessary.
  */
-async function loadCubeMapImagesForUniform(material, uniformId) {
+function loadCubeMapImagesForUniform(material, uniformId) {
   const uniforms = material.uniforms;
   const uniformValue = uniforms[uniformId];
   if (uniformValue === Material.DefaultCubeMapId) {

packages/engine/Specs/Scene/MaterialSpec.js

@@ -630,6 +630,93 @@ describe(
       });
     });
 
+    it("creates a material using fromTypeAsync", async function () {
+      const material = await Material.fromTypeAsync("Color");
+      renderMaterial(material);
+    });
+
+    it("loads a 2D texture image synchronously when awaiting fromTypeAsync", async function () {
+      const imageMaterial = await Material.fromTypeAsync("Image", {
+        image: "./Data/Images/Blue.png",
+      });
+      renderMaterial(imageMaterial);
+    });
+
+    it("loads cubemap images synchronously when awaiting fromTypeAsync", async function () {
+      // First make a material with a cubemap, then use its type to make a second cubemap material asynchronously.
+      const material = new Material({
+        strict: true,
+        fabric: {
+          uniforms: {
+            cubeMap: {
+              positiveX: "./Data/Images/Blue.png",
+              negativeX: "./Data/Images/Blue.png",
+              positiveY: "./Data/Images/Blue.png",
+              negativeY: "./Data/Images/Blue.png",
+              positiveZ: "./Data/Images/Blue.png",
+              negativeZ: "./Data/Images/Blue.png",
+            },
+          },
+          source:
+            "uniform samplerCube cubeMap;\n" +
+            "czm_material czm_getMaterial(czm_materialInput materialInput)\n" +
+            "{\n" +
+            "    czm_material material = czm_getDefaultMaterial(materialInput);\n" +
+            "    material.diffuse = czm_textureCube(cubeMap, vec3(1.0)).xyz;\n" +
+            "    return material;\n" +
+            "}\n",
+        },
+      });
+
+      const materialFromTypeAsync = await Material.fromTypeAsync(
+        material.type,
+        {
+          cubeMap: {
+            positiveX: "./Data/Images/Green.png",
+            negativeX: "./Data/Images/Green.png",
+            positiveY: "./Data/Images/Green.png",
+            negativeY: "./Data/Images/Green.png",
+            positiveZ: "./Data/Images/Green.png",
+            negativeZ: "./Data/Images/Green.png",
+          },
+        },
+      );
+
+      renderMaterial(materialFromTypeAsync);
+    });
+
+    it("loads sub-materials synchronously when awaiting fromTypeAsync", async function () {
+      // First make a material with submaterials, then use its type to make a second material asynchronously.
+      const material = new Material({
+        strict: true,
+        fabric: {
+          materials: {
+            greenMaterial: {
+              type: "Image",
+              uniforms: {
+                image: "./Data/Images/Green.png", // Green image
+              },
+            },
+            blueMaterial: {
+              type: "Image",
+              uniforms: {
+                image: "./Data/Images/Blue.png", // Blue image
+              },
+            },
+          },
+          components: {
+            diffuse:
+              "clamp(greenMaterial.diffuse + blueMaterial.diffuse, 0.0, 1.0)",
+          },
+        },
+      });
+
+      const materialFromTypeAsync = await Material.fromTypeAsync(material.type);
+      renderMaterial(materialFromTypeAsync, false, function (rgba) {
+        expect(rgba).toEqual([0, 255, 255, 255]); // Expect cyan from green + blue
+      });
+    });
+
     it("creates material with custom texture filter", function () {
       const materialLinear = new Material({
         fabric: {