loadMaterial method

Implementation

Future<Material> loadMaterial(materialIndex) async {
  final parser = this;
  final json = this.json;
  final extensions = this.extensions;
  Map<String, dynamic> materialDef = json["materials"][materialIndex];

  dynamic materialType;
  Map<String, dynamic> materialParams = {};
  Map<String, dynamic> materialExtensions = materialDef["extensions"] ?? {};

  List pending = [];

  if (materialExtensions[gltfExtensions["KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS"]] != null) {
    final sgExtension = extensions[gltfExtensions["KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS"]];
    materialType = sgExtension.getMaterialType(materialIndex);
    pending.add(sgExtension.extendParams(materialParams, materialDef, parser));
  }
  else if (materialExtensions[gltfExtensions["KHR_MATERIALS_UNLIT"]] != null) {
    final kmuExtension = extensions[gltfExtensions["KHR_MATERIALS_UNLIT"]];
    materialType = kmuExtension.getMaterialType(materialIndex);
    pending.add(kmuExtension.extendParams(materialParams, materialDef, parser));
  }
  else {
    // Specification:
    // https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#metallic-roughness-material

    Map<String, dynamic> metallicRoughness =
        materialDef["pbrMetallicRoughness"] ?? {};

    materialParams["color"] = Color(1.0, 1.0, 1.0);
    materialParams["opacity"] = 1.0;

    if (metallicRoughness["baseColorFactor"] is List) {
      List<double> array = List<double>.from(metallicRoughness["baseColorFactor"].map((e) => e.toDouble()));

      (materialParams["color"] as Color).setRGB( array[0], array[1], array[2]);
      materialParams["opacity"] = array[3];
    }

    if (metallicRoughness["baseColorTexture"] != null) {
      pending.add(await parser.assignTexture(materialParams, 'map', metallicRoughness["baseColorTexture"], SRGBColorSpace));
    }

    materialParams["metalness"] = metallicRoughness["metallicFactor"] ?? 1.0;
    materialParams["roughness"] = metallicRoughness["roughnessFactor"] ?? 1.0;

    if (metallicRoughness["metallicRoughnessTexture"] != null) {
      pending.add(await parser.assignTexture(materialParams, 'metalnessMap',
          metallicRoughness["metallicRoughnessTexture"]));
      pending.add(await parser.assignTexture(materialParams, 'roughnessMap',
          metallicRoughness["metallicRoughnessTexture"]));
    }

    materialType = await _invokeOne((ext) async {
      return ext?.getMaterialType != null
          ? await ext?.getMaterialType?.call(materialIndex)
          : null;
    });

    final v = await _invokeAll((ext) {
      return ext?.extendMaterialParams != null &&
          ext?.extendMaterialParams?.call(materialIndex, materialParams) != null;
    });

    pending.add(v);
  }

  if (materialDef["doubleSided"] == true) {
    materialParams["side"] = DoubleSide;
  }

  final alphaMode = materialDef["alphaMode"] ?? gltfAlphaModes["OPAQUE"];

  if (alphaMode == gltfAlphaModes["BLEND"]) {
    materialParams["transparent"] = true;

    // See: https://github.com/mrdoob/three.js/issues/17706
    materialParams["depthWrite"] = false;
  }
  else {
    materialParams["transparent"] = false;

    if (alphaMode == gltfAlphaModes["MASK"]) {
      materialParams["alphaTest"] = materialDef["alphaCutoff"] ?? 0.5;
    }
  }

  if (materialDef["normalTexture"] != null &&
      materialType != MeshBasicMaterial) {
    pending.add(await parser.assignTexture(
        materialParams, 'normalMap', materialDef["normalTexture"]));

    if (materialDef["normalTexture"]["scale"] != null) {
      materialParams["normalScale"] = Vector2(
          materialDef["normalTexture"]["scale"],
          materialDef["normalTexture"]["scale"]);
    }
  }

  if (materialDef["occlusionTexture"] != null &&
      materialType != MeshBasicMaterial) {
    pending.add(await parser.assignTexture(
        materialParams, 'aoMap', materialDef["occlusionTexture"]));

    if (materialDef["occlusionTexture"]["strength"] != null) {
      materialParams["aoMapIntensity"] =
          materialDef["occlusionTexture"]["strength"];
    }
  }

  if (materialDef["emissiveFactor"] != null &&materialType != MeshBasicMaterial) {
    final emissiveFactor = List<double>.from(materialDef["emissiveFactor"].map((e) => e.toDouble()));
    materialParams["emissive"] = new Color().setRGB( emissiveFactor[0], emissiveFactor[1], emissiveFactor[2]);
  }

  if (materialDef["emissiveTexture"] != null &&
      materialType != MeshBasicMaterial
  ) {
    pending.add(await parser.assignTexture(materialParams, 'emissiveMap', materialDef["emissiveTexture"], SRGBColorSpace));
  }

  // await Future.wait(pending);

  late Material material;

  if (materialType == GLTFMeshStandardSGMaterial) {
    material = extensions[gltfExtensions["KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS"]].createMaterial(materialParams);
  } else {
    material = createMaterialType(materialType, materialParams);
  }

  if (materialDef["name"] != null) material.name = materialDef["name"];

  assignExtrasToUserData(material, materialDef);

  parser.associations[material] = {
    "type": 'materials',
    "index": materialIndex,
    "materials": materialIndex
  };

  if (materialDef["extensions"] != null){
    addUnknownExtensionsToUserData(extensions, material, materialDef);
  }

  return material;
}