lywsvip/engine
1
0
Fork 0
mirror of https://github.com/galacean/engine.git synced 2026-06-04 01:30:13 +08:00
Code Issues Packages Projects Releases Wiki Activity

Fix resource load can't be catched bug (#1316)

Browse Source 
* fix: resource load can't be catched bug
This commit is contained in:
Hu Song
2023-01-05 16:47:01 +08:00
committed by GitHub
parent 0154671a93
commit 212924d431
9 changed files with 165 additions and 154 deletions
Download Patch File Download Diff File Expand all files Collapse all files

132
packages/loader/src/AnimatorControllerLoader.ts
View File

@@ -18,74 +18,76 @@ class AnimatorControllerLoader extends Loader<AnimatorController> {
this.request<any>(item.url, {
...item,
type: "json"
}).then((data) => {
const animatorController = new AnimatorController();
const { layers } = data;
const promises = [];
layers.forEach((layerData, layerIndex: number) => {
const { name, blendingMode, weight, stateMachine: stateMachineData } = layerData;
const layer = new AnimatorControllerLayer(name);
layer.blendingMode = blendingMode;
layer.weight = weight;
if (stateMachineData) {
const { states } = stateMachineData;
const stateMachine = (layer.stateMachine = new AnimatorStateMachine());
states.forEach((stateData, stateIndex: number) => {
const {
name,
speed,
wrapMode,
clipStartNormalizedTime,
clipEndNormalizedTime,
isDefaultState,
clip: clipData
} = stateData;
const state = stateMachine.addState(name);
isDefaultState && (stateMachine.defaultState = state);
state.speed = speed;
state.wrapMode = wrapMode;
state.clipStartTime = clipStartNormalizedTime;
state.clipEndTime = clipEndNormalizedTime;
if (clipData) {
promises.push(
new Promise((resolve) => {
//@ts-ignore
resourceManager.getResourceByRef(clipData).then((clip) => {
resolve({
layerIndex,
stateIndex,
clip
})
.then((data) => {
const animatorController = new AnimatorController();
const { layers } = data;
const promises = [];
layers.forEach((layerData, layerIndex: number) => {
const { name, blendingMode, weight, stateMachine: stateMachineData } = layerData;
const layer = new AnimatorControllerLayer(name);
layer.blendingMode = blendingMode;
layer.weight = weight;
if (stateMachineData) {
const { states } = stateMachineData;
const stateMachine = (layer.stateMachine = new AnimatorStateMachine());
states.forEach((stateData, stateIndex: number) => {
const {
name,
speed,
wrapMode,
clipStartNormalizedTime,
clipEndNormalizedTime,
isDefaultState,
clip: clipData
} = stateData;
const state = stateMachine.addState(name);
isDefaultState && (stateMachine.defaultState = state);
state.speed = speed;
state.wrapMode = wrapMode;
state.clipStartTime = clipStartNormalizedTime;
state.clipEndTime = clipEndNormalizedTime;
if (clipData) {
promises.push(
new Promise((resolve) => {
//@ts-ignore
resourceManager.getResourceByRef(clipData).then((clip) => {
resolve({
layerIndex,
stateIndex,
clip
});
});
});
})
);
}
});
states.forEach((stateData) => {
const { name, transitions } = stateData;
transitions.forEach((transitionData) => {
const { targetStateName, duration, offset, exitTime } = transitionData;
const sourceState = stateMachine.findStateByName(name);
const destState = stateMachine.findStateByName(targetStateName);
const transition = new AnimatorStateTransition();
transition.destinationState = destState;
transition.duration = duration;
transition.exitTime = exitTime;
transition.offset = offset;
sourceState.addTransition(transition);
})
);
}
});
});
}
animatorController.addLayer(layer);
});
Promise.all(promises).then((clipData) => {
clipData.forEach((data) => {
const { layerIndex, stateIndex, clip } = data;
animatorController.layers[layerIndex].stateMachine.states[stateIndex].clip = clip;
states.forEach((stateData) => {
const { name, transitions } = stateData;
transitions.forEach((transitionData) => {
const { targetStateName, duration, offset, exitTime } = transitionData;
const sourceState = stateMachine.findStateByName(name);
const destState = stateMachine.findStateByName(targetStateName);
const transition = new AnimatorStateTransition();
transition.destinationState = destState;
transition.duration = duration;
transition.exitTime = exitTime;
transition.offset = offset;
sourceState.addTransition(transition);
});
});
}
animatorController.addLayer(layer);
});
resolve(animatorController);
});
});
Promise.all(promises).then((clipData) => {
clipData.forEach((data) => {
const { layerIndex, stateIndex, clip } = data;
animatorController.layers[layerIndex].stateMachine.states[stateIndex].clip = clip;
});
resolve(animatorController);
});
})
.catch(reject);
});
}
}

130
packages/loader/src/MaterialLoader.ts
View File

@@ -22,81 +22,83 @@ class MaterialLoader extends Loader<string> {
this.request(item.url, {
...item,
type: "json"
}).then((json: { [key: string]: any }) => {
const engine = resourceManager.engine;
const { name, shader, shaderData, macros, renderState } = json;
})
.then((json: { [key: string]: any }) => {
const engine = resourceManager.engine;
const { name, shader, shaderData, macros, renderState } = json;
let material;
switch (shader) {
case "pbr":
material = new PBRMaterial(engine);
break;
case "pbr-specular":
material = new PBRSpecularMaterial(engine);
break;
case "unlit":
material = new UnlitMaterial(engine);
break;
case "blinn-phong":
material = new BlinnPhongMaterial(engine);
break;
case "bake-pbr":
// @todo refactor custom shader later
// @ts-ignore
material = new PBRBaseMaterial(engine, Shader.find("bake-pbr"));
break;
}
material.name = name;
const texturePromises = new Array<Promise<Texture2D | void>>();
const materialShaderData = material.shaderData;
for (let key in shaderData) {
const { type, value } = shaderData[key];
switch (type) {
case "Vector2":
materialShaderData.setVector2(key, new Vector2(value.x, value.y));
let material;
switch (shader) {
case "pbr":
material = new PBRMaterial(engine);
break;
case "Vector3":
materialShaderData.setVector3(key, new Vector3(value.x, value.y, value.z));
case "pbr-specular":
material = new PBRSpecularMaterial(engine);
break;
case "Vector4":
materialShaderData.setVector4(key, new Vector4(value.x, value.y, value.z, value.w));
case "unlit":
material = new UnlitMaterial(engine);
break;
case "Color":
materialShaderData.setColor(key, new Color(value.r, value.g, value.b, value.a));
case "blinn-phong":
material = new BlinnPhongMaterial(engine);
break;
case "Float":
materialShaderData.setFloat(key, value);
break;
case "Texture":
texturePromises.push(
// @ts-ignore
resourceManager.getResourceByRef<Texture2D>(value).then((texture) => {
materialShaderData.setTexture(key, texture);
})
);
case "bake-pbr":
// @todo refactor custom shader later
// @ts-ignore
material = new PBRBaseMaterial(engine, Shader.find("bake-pbr"));
break;
}
}
material.name = name;
for (let i = 0, length = macros.length; i < length; i++) {
const { name, value } = macros[i];
if (value == undefined) {
materialShaderData.enableMacro(name);
} else {
materialShaderData.enableMacro(name, value);
const texturePromises = new Array<Promise<Texture2D | void>>();
const materialShaderData = material.shaderData;
for (let key in shaderData) {
const { type, value } = shaderData[key];
switch (type) {
case "Vector2":
materialShaderData.setVector2(key, new Vector2(value.x, value.y));
break;
case "Vector3":
materialShaderData.setVector3(key, new Vector3(value.x, value.y, value.z));
break;
case "Vector4":
materialShaderData.setVector4(key, new Vector4(value.x, value.y, value.z, value.w));
break;
case "Color":
materialShaderData.setColor(key, new Color(value.r, value.g, value.b, value.a));
break;
case "Float":
materialShaderData.setFloat(key, value);
break;
case "Texture":
texturePromises.push(
// @ts-ignore
resourceManager.getResourceByRef<Texture2D>(value).then((texture) => {
materialShaderData.setTexture(key, texture);
})
);
break;
}
}
}
for (let key in renderState) {
material[key] = renderState[key];
}
for (let i = 0, length = macros.length; i < length; i++) {
const { name, value } = macros[i];
if (value == undefined) {
materialShaderData.enableMacro(name);
} else {
materialShaderData.enableMacro(name, value);
}
}
Promise.all(texturePromises).then(() => {
resolve(material);
});
});
for (let key in renderState) {
material[key] = renderState[key];
}
return Promise.all(texturePromises).then(() => {
resolve(material);
});
})
.catch(reject);
});
}
}

5
packages/loader/src/MeshLoader.ts
View File

@@ -12,7 +12,7 @@ import { decode } from "./resource-deserialize";
@resourceLoader(AssetType.Mesh, ["mesh"])
class MeshLoader extends Loader<ModelMesh> {
load(item: LoadItem, resourceManager: ResourceManager): AssetPromise<ModelMesh> {
return new AssetPromise((resolve) => {
return new AssetPromise((resolve, reject) => {
this.request<any>(item.url, {
...item,
type: "arraybuffer"
@@ -22,7 +22,8 @@ class MeshLoader extends Loader<ModelMesh> {
})
.then((mesh) => {
resolve(mesh);
});
})
.catch(reject);
});
}
}

2
packages/loader/src/SpriteAtlasLoader.ts
View File

@@ -43,7 +43,7 @@ class SpriteAtlasLoader extends Loader<SpriteAtlas> {
)
);
chainPromises.push(imagePromises);
imagePromises.then((imgs) => {
return imagePromises.then((imgs) => {
const { engine } = resourceManager;
// Generate a SpriteAtlas object.
const { _tempRect: tempRect, _tempVec2: tempVec2 } = this;

20
packages/loader/src/SpriteLoader.ts
View File

@@ -16,15 +16,17 @@ class SpriteLoader extends Loader<Sprite> {
this.request<any>(item.url, {
...item,
type: "json"
}).then((data) => {
// @ts-ignore
resourceManager.getResourceByRef<Texture2D>(data.texture).then((texture) => {
const sprite = new Sprite(resourceManager.engine, texture);
sprite.region = data.region;
sprite.pivot = data.pivot;
resolve(sprite);
});
});
})
.then((data) => {
// @ts-ignore
resourceManager.getResourceByRef<Texture2D>(data.texture).then((texture) => {
const sprite = new Sprite(resourceManager.engine, texture);
sprite.region = data.region;
sprite.pivot = data.pivot;
resolve(sprite);
});
})
.catch(reject);
});
}
}

10
packages/loader/src/gltf/parser/MeshParser.ts
View File

@@ -104,10 +104,12 @@ export class MeshParser extends Parser {
meshPromises[i] = Promise.all(primitivePromises);
}
AssetPromise.all(meshPromises).then((meshes: ModelMesh[][]) => {
glTFResource.meshes = meshes;
meshesPromiseInfo.resolve(meshes);
});
AssetPromise.all(meshPromises)
.then((meshes: ModelMesh[][]) => {
glTFResource.meshes = meshes;
meshesPromiseInfo.resolve(meshes);
})
.catch(meshesPromiseInfo.reject);
return meshesPromiseInfo.promise;
}

6
packages/loader/src/gltf/parser/SceneParser.ts
View File

@@ -66,9 +66,9 @@ export class SceneParser extends Parser {
gltf.extensions && delete gltf.extensions["OASIS_materials_remap"];
AssetPromise.all(promises).then(() => {
defaultSceneRootPromiseInfo.resolve(glTFResource.defaultSceneRoot);
});
AssetPromise.all(promises)
.then(() => defaultSceneRootPromiseInfo.resolve(glTFResource.defaultSceneRoot))
.catch(defaultSceneRootPromiseInfo.reject);
return defaultSceneRootPromiseInfo.promise;
}

10
packages/loader/src/gltf/parser/TextureParser.ts
View File

@@ -54,10 +54,12 @@ export class TextureParser extends Parser {
});
}
})
).then((textures: Texture2D[]) => {
glTFResource.textures = textures;
texturesPromiseInfo.resolve(textures);
});
)
.then((textures: Texture2D[]) => {
glTFResource.textures = textures;
texturesPromiseInfo.resolve(textures);
})
.catch(texturesPromiseInfo.reject);
return texturesPromiseInfo.promise;
}
}

4
packages/loader/src/resource-deserialize/resources/prefab/ReflectionParser.ts
View File

@@ -120,7 +120,7 @@ export class ReflectionParser {
}
}
return new Promise((resolve) => {
return new Promise((resolve, reject) => {
Promise.all(promises).then(() => {
const handle = this.customParseComponentHandles[instance.constructor.name];
if (handle) {
@@ -130,7 +130,7 @@ export class ReflectionParser {
} else {
resolve(instance);
}
});
}).catch(reject)
});
}