private static glTFMaterial Migrate(JsonNode vrm0XMaterial, string materialName, Dictionary <int, int> renderQueueMapper)
{
try
{
if (MigrationMaterialUtil.GetShaderName(vrm0XMaterial) != Unity0XShaderName)
{
return(null);
}
var baseColorFactor = MigrationMaterialUtil.GetBaseColorFactor(vrm0XMaterial);
var baseColorTexture = MigrationMaterialUtil.GetBaseColorTexture(vrm0XMaterial);
var emissiveTexture = new glTFMaterialEmissiveTextureInfo
{
index = baseColorTexture.index,
extensions = baseColorTexture.extensions,
};
var renderQueue = MigrationMaterialUtil.GetRenderQueue(vrm0XMaterial) ?? Unity0XDefaultRenderQueue;
var renderQueueOffset = renderQueueMapper.ContainsKey(renderQueue) ? renderQueueMapper[renderQueue] : 0;
var mtoonMaterial = new glTFMaterial
{
name = materialName,
extensions = new glTFExtensionExport().Add(
glTF_KHR_materials_unlit.ExtensionName,
new ArraySegment <byte>(glTF_KHR_materials_unlit.Raw)
),
pbrMetallicRoughness = new glTFPbrMetallicRoughness
{
baseColorFactor = new[] { 0f, 0f, 0f, baseColorFactor[3] }, // black + _Color.a
baseColorTexture = baseColorTexture, // _MainTex
metallicFactor = 0f,
roughnessFactor = 1f,
},
alphaMode = "BLEND",
alphaCutoff = 0.5f,
doubleSided = false,
emissiveFactor = new[] { baseColorFactor[0], baseColorFactor[1], baseColorFactor[2] }, // _Color.rgb
emissiveTexture = emissiveTexture,
};
var mtoon10 = new VRMC_materials_mtoon
{
SpecVersion = Vrm10Exporter.MTOON_SPEC_VERSION,
TransparentWithZWrite = true, // transparent with zWrite
RenderQueueOffsetNumber = renderQueueOffset,
ShadeColorFactor = new[] { 0f, 0f, 0f }, // black
OutlineWidthMode = OutlineWidthMode.none // disable outline
};
UniGLTF.Extensions.VRMC_materials_mtoon.GltfSerializer.SerializeTo(ref mtoonMaterial.extensions,
mtoon10);
return(mtoonMaterial);
}
catch (Exception)
{
Debug.LogWarning($"Migration failed in VRM/UnlitTransparentZWrite material: {materialName}");
return(null);
}
}
public static int?TryGetRenderQueue(glTFMaterial material, VRMC_materials_mtoon mToon)
{
var renderQueueOffset = mToon?.RenderQueueOffsetNumber;
if (renderQueueOffset.HasValue)
{
var renderMode = GetMToonRenderMode(material, mToon);
return(MToon.Utils.GetRenderQueueRequirement(renderMode).DefaultValue +
renderQueueOffset.Value);
}
return(default);
public static void Migrate(glTF gltf, JsonNode json)
{
for (int i = 0; i < gltf.materials.Count; ++i)
{
var vrmMaterial = json["extensions"]["VRM"]["materialProperties"][i];
if (vrmMaterial["shader"].GetString() != "VRM/MToon")
{
continue;
}
// VRM-0 MToon の情報
var mtoon = MToonValue.Create(vrmMaterial);
// KHR_materials_unlit として fallback した情報が入っている
var gltfMaterial = gltf.materials[i];
if (!glTF_KHR_materials_unlit.IsEnable(gltfMaterial))
{
// 古いモデルは無い場合がある
// throw new Exception($"[{i}]{gltfMaterial.name} has no extensions");
}
var extensions = new glTFExtensionExport();
gltfMaterial.extensions = extensions;
extensions.Add(
glTF_KHR_materials_unlit.ExtensionName,
new ArraySegment <byte>(glTF_KHR_materials_unlit.Raw));
//
// definition の中身を gltfMaterial と gltfMaterial.extensions.VRMC_materials_mtoon に移し替える
//
var dst = new VRMC_materials_mtoon();
// Color
gltfMaterial.pbrMetallicRoughness.baseColorFactor = mtoon.Definition.Color.LitColor.ToFloat4();
if (mtoon.TextureIndexMap.MainTex.HasValue)
{
gltfMaterial.pbrMetallicRoughness.baseColorTexture = new glTFMaterialBaseColorTextureInfo
{
index = mtoon.TextureIndexMap.MainTex.Value
};
if (!mtoon.OffsetScale.TryGetValue("_MainTex", out float[] value))
private static bool TryGetUvAnimationMaskTexture(GltfParser parser, VRMC_materials_mtoon mToon, out (SubAssetKey, TextureImportParam) pair)
{
return(TryGetLinearTexture(parser, new Vrm10TextureInfo(mToon.UvAnimationMaskTexture), out pair));
}
private static bool TryGetOutlineWidthMultiplyTexture(GltfParser parser, VRMC_materials_mtoon mToon, out (SubAssetKey, TextureImportParam) pair)
{
return(TryGetLinearTexture(parser, new Vrm10TextureInfo(mToon.OutlineWidthMultiplyTexture), out pair));
}
private static bool TryGetMatcapTexture(GltfData data, VRMC_materials_mtoon mToon, out (SubAssetKey, TextureDescriptor) pair)
{
return(TryGetSRGBTexture(data, new Vrm10TextureInfo(mToon.ShadingShiftTexture), out pair));
}
public static IEnumerable <(string key, Color value)> TryGetAllColors(glTFMaterial material, VRMC_materials_mtoon mToon)
{
const ColorSpace gltfColorSpace = ColorSpace.Linear;
var baseColor = material?.pbrMetallicRoughness?.baseColorFactor?.ToColor4(gltfColorSpace, ColorSpace.sRGB);
if (baseColor.HasValue)
{
yield return(MToon.Utils.PropColor, baseColor.Value);
}
var emissionColor = material?.emissiveFactor?.ToColor3(gltfColorSpace, ColorSpace.Linear);
if (emissionColor.HasValue)
{
yield return(MToon.Utils.PropEmissionColor, emissionColor.Value);
}
var shadeColor = mToon?.ShadeColorFactor?.ToColor3(gltfColorSpace, ColorSpace.sRGB);
if (shadeColor.HasValue)
{
yield return(MToon.Utils.PropShadeColor, shadeColor.Value);
}
var rimColor = mToon?.ParametricRimColorFactor?.ToColor3(gltfColorSpace, ColorSpace.Linear);
if (rimColor.HasValue)
{
yield return(MToon.Utils.PropRimColor, rimColor.Value);
}
var outlineColor = mToon?.OutlineColorFactor?.ToColor3(gltfColorSpace, ColorSpace.sRGB);
if (outlineColor.HasValue)
{
yield return(MToon.Utils.PropOutlineColor, outlineColor.Value);
}
}
private static MToon10OutlineMode GetMToon10OutlineWidthMode(glTFMaterial material, VRMC_materials_mtoon mToon)
{
switch (mToon?.OutlineWidthMode)
{
case OutlineWidthMode.none:
return(MToon10OutlineMode.None);
case OutlineWidthMode.worldCoordinates:
return(MToon10OutlineMode.World);
case OutlineWidthMode.screenCoordinates:
return(MToon10OutlineMode.Screen);
default:
// Invalid
Debug.LogWarning("Invalid outlineWidthMode");
return(MToon10OutlineMode.None);
}
}
private static MToon10TransparentWithZWriteMode GetMToon10TransparentWithZWriteMode(glTFMaterial material, VRMC_materials_mtoon mtoon)
{
if (mtoon?.TransparentWithZWrite == true)
{
return(MToon10TransparentWithZWriteMode.On);
}
else
{
return(MToon10TransparentWithZWriteMode.Off);
}
}
/// <summary>
/// Create a MToon definition.
/// </summary>
/// <param name="mtoon"></param>
/// <returns></returns>
protected virtual MToonDefinition CreateMtoonDefinition(VRMC_materials_mtoon mtoon)
{
MToonDefinition mtoonDefinition = new MToonDefinition();
// Meta
mtoonDefinition.Meta = new MetaDefinition()
{
VersionNumber = MToon.Utils.VersionNumber,
Implementation = MToon.Utils.Implementation,
};
// Rendering
mtoonDefinition.Rendering = new RenderingDefinition()
{
RenderMode = (MToon.RenderMode)mtoon.renderMode,
CullMode = (MToon.CullMode)mtoon.cullMode,
RenderQueueOffsetNumber = mtoon.renderQueueOffsetNumber,
};
// Color
mtoonDefinition.Color = new ColorDefinition()
{
LitColor = ArrayConverter.ToColor(mtoon.litFactor, gamma: true),
LitMultiplyTexture = GetTexture(MToon.Utils.PropMainTex, mtoon.litMultiplyTexture),
ShadeColor = ArrayConverter.ToColor(mtoon.shadeFactor, gamma: true),
ShadeMultiplyTexture = GetTexture(MToon.Utils.PropShadeTexture, mtoon.shadeMultiplyTexture),
CutoutThresholdValue = mtoon.cutoutThresholdFactor,
};
// Lighting
mtoonDefinition.Lighting = new LightingDefinition();
mtoonDefinition.Lighting.LitAndShadeMixing = new LitAndShadeMixingDefinition()
{
ShadingShiftValue = mtoon.shadingShiftFactor,
ShadingToonyValue = mtoon.shadingToonyFactor,
ShadowReceiveMultiplierValue = mtoon.shadowReceiveMultiplierFactor,
ShadowReceiveMultiplierMultiplyTexture = GetTexture(MToon.Utils.PropReceiveShadowTexture, mtoon.shadowReceiveMultiplierMultiplyTexture),
LitAndShadeMixingMultiplierValue = mtoon.litAndShadeMixingMultiplierFactor,
LitAndShadeMixingMultiplierMultiplyTexture = GetTexture(MToon.Utils.PropShadingGradeTexture, mtoon.litAndShadeMixingMultiplierMultiplyTexture),
};
mtoonDefinition.Lighting.LightingInfluence = new LightingInfluenceDefinition()
{
LightColorAttenuationValue = mtoon.lightColorAttenuationFactor,
GiIntensityValue = mtoon.giIntensityFactor,
};
mtoonDefinition.Lighting.Normal = new NormalDefinition()
{
NormalTexture = GetTexture(MToon.Utils.PropBumpMap, mtoon.normalTexture),
NormalScaleValue = mtoon.normalScaleFactor,
};
// Emission
mtoonDefinition.Emission = new EmissionDefinition()
{
EmissionColor = ArrayConverter.ToColor(mtoon.emissionFactor, gamma: true),
EmissionMultiplyTexture = GetTexture(MToon.Utils.PropEmissionMap, mtoon.emissionMultiplyTexture),
};
// MatCap
mtoonDefinition.MatCap = new MatCapDefinition()
{
AdditiveTexture = GetTexture(MToon.Utils.PropSphereAdd, mtoon.additiveTexture),
};
// Rim
mtoonDefinition.Rim = new RimDefinition()
{
RimColor = ArrayConverter.ToColor(mtoon.rimFactor, gamma: true),
RimMultiplyTexture = GetTexture(MToon.Utils.PropRimTexture, mtoon.rimMultiplyTexture),
RimLightingMixValue = mtoon.rimLightingMixFactor,
RimFresnelPowerValue = mtoon.rimFresnelPowerFactor,
RimLiftValue = mtoon.rimLiftFactor,
};
// Outline
mtoonDefinition.Outline = new OutlineDefinition()
{
OutlineWidthMode = (MToon.OutlineWidthMode)mtoon.outlineWidthMode,
OutlineWidthValue = mtoon.outlineWidthFactor,
OutlineWidthMultiplyTexture = GetTexture(MToon.Utils.PropOutlineWidthTexture, mtoon.outlineWidthMultiplyTexture),
OutlineScaledMaxDistanceValue = mtoon.outlineScaledMaxDistanceFactor,
OutlineColorMode = (MToon.OutlineColorMode)mtoon.outlineColorMode,
OutlineColor = ArrayConverter.ToColor(mtoon.outlineFactor, gamma: true),
OutlineLightingMixValue = mtoon.outlineLightingMixFactor,
};
// Texture Option
mtoonDefinition.TextureOption = new TextureUvCoordsDefinition()
{
MainTextureLeftBottomOriginScale = ArrayConverter.ToVector2(mtoon.mainTextureLeftBottomOriginScale),
MainTextureLeftBottomOriginOffset = ArrayConverter.ToVector2(mtoon.mainTextureLeftBottomOriginOffset),
UvAnimationMaskTexture = GetTexture(MToon.Utils.PropUvAnimMaskTexture, mtoon.uvAnimationMaskTexture),
UvAnimationScrollXSpeedValue = mtoon.uvAnimationScrollXSpeedFactor,
UvAnimationScrollYSpeedValue = mtoon.uvAnimationScrollYSpeedFactor,
UvAnimationRotationSpeedValue = mtoon.uvAnimationRotationSpeedFactor,
};
return(mtoonDefinition);
}
private static bool TryGetUvAnimationMaskTexture(GltfData data, VRMC_materials_mtoon mToon, out (SubAssetKey, TextureDescriptor) pair)
{
return(TryGetLinearTexture(data, new Vrm10TextureInfo(mToon.UvAnimationMaskTexture), out pair));
}
private static bool TryGetOutlineWidthMultiplyTexture(GltfData data, VRMC_materials_mtoon mToon, out (SubAssetKey, TextureDescriptor) pair)
{
return(TryGetLinearTexture(data, new Vrm10TextureInfo(mToon.OutlineWidthMultiplyTexture), out pair));
}
private static bool TryGetRimMultiplyTexture(GltfData data, VRMC_materials_mtoon mToon, out (SubAssetKey, TextureDescriptor) pair)
{
return(TryGetSRGBTexture(data, new Vrm10TextureInfo(mToon.RimMultiplyTexture), out pair));
}
public static IEnumerable <(string key, (SubAssetKey, TextureDescriptor))> EnumerateAllTextures(GltfData data, glTFMaterial material, VRMC_materials_mtoon mToon)
{
if (TryGetBaseColorTexture(data, material, out var litTex))
{
yield return(MToon10Prop.BaseColorTexture.ToUnityShaderLabName(), litTex);
}
if (TryGetEmissiveTexture(data, material, out var emissiveTex))
{
yield return(MToon10Prop.EmissiveTexture.ToUnityShaderLabName(), emissiveTex);
}
if (TryGetNormalTexture(data, material, out var normalTex))
{
yield return(MToon10Prop.NormalTexture.ToUnityShaderLabName(), normalTex);
}
if (TryGetShadeMultiplyTexture(data, mToon, out var shadeTex))
{
yield return(MToon10Prop.ShadeColorTexture.ToUnityShaderLabName(), shadeTex);
}
if (TryGetShadingShiftTexture(data, mToon, out var shadeShiftTex))
{
yield return(MToon10Prop.ShadingShiftTexture.ToUnityShaderLabName(), shadeShiftTex);
}
if (TryGetMatcapTexture(data, mToon, out var matcapTex))
{
yield return(MToon10Prop.MatcapTexture.ToUnityShaderLabName(), matcapTex);
}
if (TryGetRimMultiplyTexture(data, mToon, out var rimTex))
{
yield return(MToon10Prop.RimMultiplyTexture.ToUnityShaderLabName(), rimTex);
}
if (TryGetOutlineWidthMultiplyTexture(data, mToon, out var outlineTex))
{
yield return(MToon10Prop.OutlineWidthMultiplyTexture.ToUnityShaderLabName(), outlineTex);
}
if (TryGetUvAnimationMaskTexture(data, mToon, out var uvAnimMaskTex))
{
yield return(MToon10Prop.UvAnimationMaskTexture.ToUnityShaderLabName(), uvAnimMaskTex);
}
}
public static glTFMaterial MToonToGltf(this MToonMaterial mtoon, List <Texture> textures)
{
var material = mtoon.UnlitToGltf(textures);
var dst = new VRMC_materials_mtoon();
// Color
material.pbrMetallicRoughness.baseColorFactor = mtoon.Definition.Color.LitColor.ToFloat4();
if (mtoon.Definition.Color.LitMultiplyTexture != null)
{
material.pbrMetallicRoughness.baseColorTexture = new glTFMaterialBaseColorTextureInfo
{
index = mtoon.Definition.Color.LitMultiplyTexture.ToIndex(textures).Value
};
}
dst.ShadeFactor = mtoon.Definition.Color.ShadeColor.ToFloat3();
dst.ShadeMultiplyTexture = mtoon.Definition.Color.ShadeMultiplyTexture.ToIndex(textures);
material.alphaCutoff = mtoon.Definition.Color.CutoutThresholdValue;
// Outline
dst.OutlineColorMode = (UniGLTF.Extensions.VRMC_materials_mtoon.OutlineColorMode)mtoon.Definition.Outline.OutlineColorMode;
dst.OutlineFactor = mtoon.Definition.Outline.OutlineColor.ToFloat3();
dst.OutlineLightingMixFactor = mtoon.Definition.Outline.OutlineLightingMixValue;
dst.OutlineScaledMaxDistanceFactor = mtoon.Definition.Outline.OutlineScaledMaxDistanceValue;
dst.OutlineWidthMode = (UniGLTF.Extensions.VRMC_materials_mtoon.OutlineWidthMode)mtoon.Definition.Outline.OutlineWidthMode;
dst.OutlineWidthFactor = mtoon.Definition.Outline.OutlineWidthValue;
dst.OutlineWidthMultiplyTexture = mtoon.Definition.Outline.OutlineWidthMultiplyTexture.ToIndex(textures);
// Emission
material.emissiveFactor = mtoon.Definition.Emission.EmissionColor.ToFloat3();
if (mtoon.Definition.Emission.EmissionMultiplyTexture != null)
{
material.emissiveTexture = new glTFMaterialEmissiveTextureInfo
{
index = textures.IndexOfNullable(mtoon.Definition.Emission.EmissionMultiplyTexture.Texture).Value
};
}
// Light
dst.GiIntensityFactor = mtoon.Definition.Lighting.LightingInfluence.GiIntensityValue;
dst.LightColorAttenuationFactor = mtoon.Definition.Lighting.LightingInfluence.LightColorAttenuationValue;
dst.ShadingShiftFactor = mtoon.Definition.Lighting.LitAndShadeMixing.ShadingShiftValue;
dst.ShadingToonyFactor = mtoon.Definition.Lighting.LitAndShadeMixing.ShadingToonyValue;
if (mtoon.Definition.Lighting.Normal.NormalTexture != null)
{
material.normalTexture = new glTFMaterialNormalTextureInfo
{
index = textures.IndexOfNullable(mtoon.Definition.Lighting.Normal.NormalTexture.Texture).Value,
scale = mtoon.Definition.Lighting.Normal.NormalScaleValue
};
}
// matcap
dst.AdditiveTexture = mtoon.Definition.MatCap.AdditiveTexture.ToIndex(textures);
// rendering
switch (mtoon.Definition.Rendering.CullMode)
{
case CullMode.Back:
material.doubleSided = false;
break;
case CullMode.Off:
material.doubleSided = true;
break;
case CullMode.Front:
// GLTF not support
material.doubleSided = false;
break;
default:
throw new NotImplementedException();
}
(material.alphaMode, dst.TransparentWithZWrite) = GetRenderMode(mtoon.Definition.Rendering.RenderMode);
dst.RenderQueueOffsetNumber = mtoon.Definition.Rendering.RenderQueueOffsetNumber;
// rim
dst.RimFactor = mtoon.Definition.Rim.RimColor.ToFloat3();
dst.RimMultiplyTexture = mtoon.Definition.Rim.RimMultiplyTexture.ToIndex(textures);
dst.RimLiftFactor = mtoon.Definition.Rim.RimLiftValue;
dst.RimFresnelPowerFactor = mtoon.Definition.Rim.RimFresnelPowerValue;
dst.RimLightingMixFactor = mtoon.Definition.Rim.RimLightingMixValue;
// texture option
dst.UvAnimationMaskTexture = mtoon.Definition.TextureOption.UvAnimationMaskTexture.ToIndex(textures);
dst.UvAnimationRotationSpeedFactor = mtoon.Definition.TextureOption.UvAnimationRotationSpeedValue;
dst.UvAnimationScrollXSpeedFactor = mtoon.Definition.TextureOption.UvAnimationScrollXSpeedValue;
dst.UvAnimationScrollYSpeedFactor = mtoon.Definition.TextureOption.UvAnimationScrollYSpeedValue;
if (material.pbrMetallicRoughness.baseColorTexture != null)
{
var offset = mtoon.Definition.TextureOption.MainTextureLeftBottomOriginOffset;
var scale = mtoon.Definition.TextureOption.MainTextureLeftBottomOriginScale;
glTF_KHR_texture_transform.Serialize(
material.pbrMetallicRoughness.baseColorTexture,
(offset.X, offset.Y),
(scale.X, scale.Y)
);
}
UniGLTF.Extensions.VRMC_materials_mtoon.GltfSerializer.SerializeTo(ref material.extensions, dst);
return(material);
}
public static IEnumerable <(string key, float value)> TryGetAllFloats(glTFMaterial material, VRMC_materials_mtoon mToon)
{
// Rendering
var alphaMode = GetMToon10AlphaMode(material);
{
yield return(MToon10Prop.AlphaMode.ToUnityShaderLabName(), (float)alphaMode);
}
var transparentWithZWrite = GetMToon10TransparentWithZWriteMode(material, mToon);
{
yield return(MToon10Prop.TransparentWithZWrite.ToUnityShaderLabName(), (float)transparentWithZWrite);
}
var cutoff = material?.alphaCutoff;
if (cutoff.HasValue)
{
yield return(MToon10Prop.AlphaCutoff.ToUnityShaderLabName(), cutoff.Value);
}
var renderQueueOffset = mToon?.RenderQueueOffsetNumber;
if (renderQueueOffset.HasValue)
{
yield return(MToon10Prop.RenderQueueOffsetNumber.ToUnityShaderLabName(), (float)renderQueueOffset);
}
var doubleSidedMode = GetMToon10DoubleSidedMode(material, mToon);
{
yield return(MToon10Prop.DoubleSided.ToUnityShaderLabName(), (float)doubleSidedMode);
}
// Lighting
var normalScale = material?.normalTexture?.scale;
if (normalScale.HasValue)
{
yield return(MToon10Prop.NormalTextureScale.ToUnityShaderLabName(), normalScale.Value);
}
var shadingShift = mToon?.ShadingShiftFactor;
if (shadingShift.HasValue)
{
yield return(MToon10Prop.ShadingShiftFactor.ToUnityShaderLabName(), shadingShift.Value);
}
var shadingShiftTextureScale = mToon?.ShadingShiftTexture?.Scale;
if (shadingShiftTextureScale.HasValue)
{
yield return(MToon10Prop.ShadingShiftTextureScale.ToUnityShaderLabName(), shadingShiftTextureScale.Value);
}
var shadingToony = mToon?.ShadingToonyFactor;
if (shadingToony.HasValue)
{
yield return(MToon10Prop.ShadingToonyFactor.ToUnityShaderLabName(), shadingToony.Value);
}
// GI
var giEqualization = mToon?.GiEqualizationFactor;
if (giEqualization.HasValue)
{
yield return(MToon10Prop.GiEqualizationFactor.ToUnityShaderLabName(), giEqualization.Value);
}
// Emission
// Rim Lighting
var rimFresnelPower = mToon?.ParametricRimFresnelPowerFactor;
if (rimFresnelPower.HasValue)
{
yield return(MToon10Prop.ParametricRimFresnelPowerFactor.ToUnityShaderLabName(), rimFresnelPower.Value);
}
var rimLift = mToon?.ParametricRimLiftFactor;
if (rimLift.HasValue)
{
yield return(MToon10Prop.ParametricRimLiftFactor.ToUnityShaderLabName(), rimLift.Value);
}
var rimLightMix = mToon?.RimLightingMixFactor;
if (rimLightMix.HasValue)
{
yield return(MToon10Prop.RimLightingMixFactor.ToUnityShaderLabName(), rimLightMix.Value);
}
// Outline
var outlineMode = GetMToon10OutlineWidthMode(material, mToon);
{
yield return(MToon10Prop.OutlineWidthMode.ToUnityShaderLabName(), (float)outlineMode);
}
var outlineWidth = mToon?.OutlineWidthFactor;
if (outlineWidth.HasValue)
{
yield return(MToon10Prop.OutlineWidthFactor.ToUnityShaderLabName(), outlineWidth.Value);
}
var outlineLightMix = mToon?.OutlineLightingMixFactor;
if (outlineLightMix.HasValue)
{
yield return(MToon10Prop.OutlineLightingMixFactor.ToUnityShaderLabName(), outlineLightMix.Value);
}
// UV Animation
var uvAnimSpeedScrollX = mToon?.UvAnimationScrollXSpeedFactor;
if (uvAnimSpeedScrollX.HasValue)
{
yield return(MToon10Prop.UvAnimationScrollXSpeedFactor.ToUnityShaderLabName(), uvAnimSpeedScrollX.Value);
}
var uvAnimSpeedScrollY = mToon?.UvAnimationScrollYSpeedFactor;
if (uvAnimSpeedScrollY.HasValue)
{
// UV coords conversion.
// glTF (top-left origin) to Unity (bottom-left origin)
const float invertY = -1f;
yield return(MToon10Prop.UvAnimationScrollYSpeedFactor.ToUnityShaderLabName(), uvAnimSpeedScrollY.Value *invertY);
}
var uvAnimSpeedRotation = mToon?.UvAnimationRotationSpeedFactor;
if (uvAnimSpeedRotation.HasValue)
{
yield return(MToon10Prop.UvAnimationRotationSpeedFactor.ToUnityShaderLabName(), uvAnimSpeedRotation.Value);
}
// UI
if (true /* TODO: mToon.IsAdvancedMode */)
{
yield return(MToon10Prop.EditorEditMode.ToUnityShaderLabName(), 1);
}
}
public static MToonMaterial MToonFromGltf(glTFMaterial material, List <Texture> textures, VRMC_materials_mtoon extension)
{
var mtoon = new MToonMaterial(material.name);
var Meta = new MetaDefinition
{
Implementation = "Santarh/MToon",
};
var Color = new ColorDefinition
{
LitColor = material.pbrMetallicRoughness.baseColorFactor.ToLinearColor(Nan),
LitMultiplyTexture = material.pbrMetallicRoughness.baseColorTexture?.index.GetTexture(textures),
ShadeColor = extension.ShadeFactor.ToLinearColor(Nan),
ShadeMultiplyTexture = extension.ShadeMultiplyTexture.GetTexture(textures),
CutoutThresholdValue = material.alphaCutoff,
};
var Outline = new OutlineDefinition
{
OutlineColorMode = (VrmLib.MToon.OutlineColorMode)extension.OutlineColorMode,
OutlineColor = extension.OutlineFactor.ToLinearColor(Nan),
OutlineLightingMixValue = extension.OutlineLightingMixFactor.Value,
OutlineScaledMaxDistanceValue = extension.OutlineScaledMaxDistanceFactor.Value,
OutlineWidthMode = (VrmLib.MToon.OutlineWidthMode)extension.OutlineWidthMode,
OutlineWidthValue = extension.OutlineWidthFactor.Value,
OutlineWidthMultiplyTexture = extension.OutlineWidthMultiplyTexture.GetTexture(textures),
};
var Emission = new EmissionDefinition
{
EmissionColor = material.emissiveFactor.ToLinearColor(Nan),
};
if (material.emissiveTexture != null)
{
Emission.EmissionMultiplyTexture = material.emissiveTexture.index.GetTexture(textures);
}
var Lighting = new LightingDefinition
{
LightingInfluence = new LightingInfluenceDefinition
{
GiIntensityValue = extension.GiIntensityFactor.Value,
LightColorAttenuationValue = extension.LightColorAttenuationFactor.Value,
},
LitAndShadeMixing = new LitAndShadeMixingDefinition
{
ShadingShiftValue = extension.ShadingShiftFactor.Value,
ShadingToonyValue = extension.ShadingToonyFactor.Value,
},
Normal = new NormalDefinition
{
},
};
if (material.normalTexture != null)
{
Lighting.Normal.NormalScaleValue = material.normalTexture.scale;
Lighting.Normal.NormalTexture = material.normalTexture.index.GetTexture(textures);
}
var MatCap = new MatCapDefinition
{
AdditiveTexture = extension.AdditiveTexture.GetTexture(textures)
};
var Rendering = new RenderingDefinition
{
CullMode = material.doubleSided ? CullMode.Off : CullMode.Back,
RenderMode = GetRenderMode(material.alphaMode, extension.TransparentWithZWrite.Value),
RenderQueueOffsetNumber = extension.RenderQueueOffsetNumber.Value,
};
var Rim = new RimDefinition
{
RimColor = extension.RimFactor.ToLinearColor(Nan),
RimMultiplyTexture = extension.RimMultiplyTexture.GetTexture(textures),
RimLiftValue = extension.RimLiftFactor.Value,
RimFresnelPowerValue = extension.RimFresnelPowerFactor.Value,
RimLightingMixValue = extension.RimLightingMixFactor.Value,
};
var TextureOption = new TextureUvCoordsDefinition
{
UvAnimationMaskTexture = extension.UvAnimationMaskTexture.GetTexture(textures),
UvAnimationRotationSpeedValue = extension.UvAnimationRotationSpeedFactor.Value,
UvAnimationScrollXSpeedValue = extension.UvAnimationScrollXSpeedFactor.Value,
UvAnimationScrollYSpeedValue = extension.UvAnimationScrollYSpeedFactor.Value,
};
if (glTF_KHR_texture_transform.TryGet(material.pbrMetallicRoughness.baseColorTexture, out glTF_KHR_texture_transform t))
{
TextureOption.MainTextureLeftBottomOriginOffset = t.offset.ToVector2();
TextureOption.MainTextureLeftBottomOriginScale = t.scale.ToVector2();
}
mtoon.Definition = new MToonDefinition
{
Meta = Meta,
Color = Color,
Outline = Outline,
Emission = Emission,
Lighting = Lighting,
MatCap = MatCap,
Rendering = Rendering,
Rim = Rim,
TextureOption = TextureOption,
};
return(mtoon);
}
private static MToon10DoubleSidedMode GetMToon10DoubleSidedMode(glTFMaterial material, VRMC_materials_mtoon mToon)
{
if (material?.doubleSided == true)
{
return(MToon10DoubleSidedMode.On);
}
else
{
return(MToon10DoubleSidedMode.Off);
}
}
public static IEnumerable <(string key, (SubAssetKey, TextureImportParam))> TryGetAllTextures(GltfParser parser, glTFMaterial material, VRMC_materials_mtoon mToon)
{
if (TryGetBaseColorTexture(parser, material, out var litTex))
{
yield return(MToon.Utils.PropMainTex, litTex);
}
if (TryGetEmissiveTexture(parser, material, out var emissiveTex))
{
yield return(MToon.Utils.PropEmissionMap, emissiveTex);
}
if (TryGetNormalTexture(parser, material, out var normalTex))
{
yield return("_BumpMap", normalTex);
}
if (TryGetShadeMultiplyTexture(parser, mToon, out var shadeTex))
{
yield return(MToon.Utils.PropShadeTexture, shadeTex);
}
if (TryGetShadingShiftTexture(parser, mToon, out var shadeShiftTex))
{
Debug.LogWarning("Need VRM 1.0 MToon implementation.");
yield return("_NEED_IMPLEMENTATION_MTOON_1_0_shadingShiftTexture", shadeShiftTex);
}
if (TryGetMatcapTexture(parser, mToon, out var matcapTex))
{
yield return(MToon.Utils.PropSphereAdd, matcapTex);
}
if (TryGetRimMultiplyTexture(parser, mToon, out var rimTex))
{
yield return(MToon.Utils.PropRimTexture, rimTex);
}
if (TryGetOutlineWidthMultiplyTexture(parser, mToon, out var outlineTex))
{
yield return(MToon.Utils.PropOutlineWidthTexture, outlineTex);
}
if (TryGetUvAnimationMaskTexture(parser, mToon, out var uvAnimMaskTex))
{
yield return(MToon.Utils.PropUvAnimMaskTexture, uvAnimMaskTex);
}
}
public static IEnumerable <(string key, Color value)> TryGetAllColors(glTFMaterial material, VRMC_materials_mtoon mToon)
{
const ColorSpace gltfColorSpace = ColorSpace.Linear;
// Rendering
var baseColor = material?.pbrMetallicRoughness?.baseColorFactor?.ToColor4(gltfColorSpace, ColorSpace.sRGB);
if (baseColor.HasValue)
{
yield return(MToon10Prop.BaseColorFactor.ToUnityShaderLabName(), baseColor.Value);
}
// Lighting
var shadeColor = mToon?.ShadeColorFactor?.ToColor3(gltfColorSpace, ColorSpace.sRGB);
if (shadeColor.HasValue)
{
yield return(MToon10Prop.ShadeColorFactor.ToUnityShaderLabName(), shadeColor.Value);
}
// GI
// Emission
// Emissive factor should be stored in Linear space
var emissionColor = material?.emissiveFactor?.ToColor3(gltfColorSpace, ColorSpace.Linear);
if (emissionColor.HasValue)
{
yield return(MToon10Prop.EmissiveFactor.ToUnityShaderLabName(), emissionColor.Value);
}
// Rim Lighting
var rimColor = mToon?.ParametricRimColorFactor?.ToColor3(gltfColorSpace, ColorSpace.sRGB);
if (rimColor.HasValue)
{
yield return(MToon10Prop.ParametricRimColorFactor.ToUnityShaderLabName(), rimColor.Value);
}
// Outline
var outlineColor = mToon?.OutlineColorFactor?.ToColor3(gltfColorSpace, ColorSpace.sRGB);
if (outlineColor.HasValue)
{
yield return(MToon10Prop.OutlineColorFactor.ToUnityShaderLabName(), outlineColor.Value);
}
// UV Animation
}
private static bool TryGetMatcapTexture(GltfParser parser, VRMC_materials_mtoon mToon, out (SubAssetKey, TextureImportParam) pair)
{
return(TryGetSRGBTexture(parser, new Vrm10TextureInfo(mToon.ShadingShiftTexture), out pair));
}
public static IEnumerable <(string key, Vector4 value)> TryGetAllFloatArrays(glTFMaterial material, VRMC_materials_mtoon mToon)
{
yield break;
}
private static bool TryGetRimMultiplyTexture(GltfParser parser, VRMC_materials_mtoon mToon, out (SubAssetKey, TextureImportParam) pair)
{
return(TryGetSRGBTexture(parser, new Vrm10TextureInfo(mToon.RimMultiplyTexture), out pair));
}
public static IEnumerable <(string key, float value)> TryGetAllFloats(glTFMaterial material, VRMC_materials_mtoon mToon)
{
var renderMode = GetMToonRenderMode(material, mToon);
{
yield return(MToon.Utils.PropBlendMode, (float)renderMode);
}
var cullMode = GetMToonCullMode(material, mToon);
{
yield return(MToon.Utils.PropCullMode, (float)cullMode);
}
var outlineMode = GetMToonOutlineWidthMode(material, mToon);
{
yield return(MToon.Utils.PropOutlineWidthMode, (float)outlineMode);
// In case of VRM 1.0 MToon, outline color mode is always MixedLighting.
yield return(MToon.Utils.PropOutlineColorMode, (float)MToon.OutlineColorMode.MixedLighting);
}
var cutoff = material?.alphaCutoff;
if (cutoff.HasValue)
{
yield return(MToon.Utils.PropCutoff, cutoff.Value);
}
var normalScale = material?.normalTexture?.scale;
if (normalScale.HasValue)
{
yield return("_BumpScale", normalScale.Value);
}
var shadingShift = mToon?.ShadingShiftFactor;
if (shadingShift.HasValue)
{
yield return(MToon.Utils.PropShadeShift, shadingShift.Value);
}
var shadingShiftTextureScale = mToon?.ShadingShiftTexture?.Scale;
if (shadingShiftTextureScale.HasValue)
{
Debug.LogWarning("Need VRM 1.0 MToon implementation.");
yield return("_NEED_IMPLEMENTATION_MTOON_1_0_shadingShiftTextureScale", shadingShiftTextureScale.Value);
}
var shadingToony = mToon?.ShadingToonyFactor;
if (shadingToony.HasValue)
{
yield return(MToon.Utils.PropShadeToony, shadingToony.Value);
}
var giIntensity = mToon?.GiIntensityFactor;
if (giIntensity.HasValue)
{
yield return(MToon.Utils.PropIndirectLightIntensity, giIntensity.Value);
}
var rimLightMix = mToon?.RimLightingMixFactor;
if (rimLightMix.HasValue)
{
yield return(MToon.Utils.PropRimLightingMix, rimLightMix.Value);
}
var rimFresnelPower = mToon?.ParametricRimFresnelPowerFactor;
if (rimFresnelPower.HasValue)
{
yield return(MToon.Utils.PropRimFresnelPower, rimFresnelPower.Value);
}
var rimLift = mToon?.ParametricRimLiftFactor;
if (rimLift.HasValue)
{
yield return(MToon.Utils.PropRimLift, rimLift.Value);
}
// Unit conversion.
// Because Unity implemented MToon uses centimeter unit in width parameter.
var outlineWidth = mToon?.OutlineWidthFactor;
if (outlineWidth.HasValue)
{
const float meterToCentimeter = 100f;
yield return(MToon.Utils.PropOutlineWidth, outlineWidth.Value *meterToCentimeter);
}
var outlineLightMix = mToon?.OutlineLightingMixFactor;
if (outlineLightMix.HasValue)
{
yield return(MToon.Utils.PropOutlineLightingMix, outlineLightMix.Value);
}
var uvAnimSpeedScrollX = mToon?.UvAnimationScrollXSpeedFactor;
if (uvAnimSpeedScrollX.HasValue)
{
yield return(MToon.Utils.PropUvAnimScrollX, uvAnimSpeedScrollX.Value);
}
// UV coords conversion.
// glTF (top-left origin) to Unity (bottom-left origin)
var uvAnimSpeedScrollY = mToon?.UvAnimationScrollYSpeedFactor;
if (uvAnimSpeedScrollY.HasValue)
{
const float invertY = -1f;
yield return(MToon.Utils.PropUvAnimScrollY, uvAnimSpeedScrollY.Value *invertY);
}
var uvAnimSpeedRotation = mToon?.UvAnimationRotationSpeedFactor;
if (uvAnimSpeedRotation.HasValue)
{
yield return(MToon.Utils.PropUvAnimRotation, uvAnimSpeedRotation.Value);
}
}
/// <summary>
/// Create a VRM MToon material.
/// </summary>
/// <param name="m"></param>
/// <param name="textureManager"></param>
/// <returns></returns>
protected virtual glTFMaterial CreateVrmMtoonMaterial(Material m, TextureExportManager textureManager)
{
MToonDefinition mtoonDefinition = MToon.Utils.GetMToonParametersFromMaterial(m);
var mtoon = new VRMC_materials_mtoon()
{
// Meta
version = mtoonDefinition.Meta.VersionNumber.ToString(),
// Rendering
renderMode = (MToonRenderMode)mtoonDefinition.Rendering.RenderMode,
cullMode = (MToonCullMode)mtoonDefinition.Rendering.CullMode,
renderQueueOffsetNumber = mtoonDefinition.Rendering.RenderQueueOffsetNumber,
// Color
litFactor = mtoonDefinition.Color.LitColor.linear.ToArray(),
litMultiplyTexture = -1,
shadeFactor = mtoonDefinition.Color.ShadeColor.linear.ToArray(),
shadeMultiplyTexture = -1,
cutoutThresholdFactor = mtoonDefinition.Color.CutoutThresholdValue,
// Lighting
shadingShiftFactor = mtoonDefinition.Lighting.LitAndShadeMixing.ShadingShiftValue,
shadingToonyFactor = mtoonDefinition.Lighting.LitAndShadeMixing.ShadingToonyValue,
shadowReceiveMultiplierFactor = mtoonDefinition.Lighting.LitAndShadeMixing.ShadowReceiveMultiplierValue,
shadowReceiveMultiplierMultiplyTexture = -1,
litAndShadeMixingMultiplierFactor = mtoonDefinition.Lighting.LitAndShadeMixing.LitAndShadeMixingMultiplierValue,
litAndShadeMixingMultiplierMultiplyTexture = -1,
lightColorAttenuationFactor = mtoonDefinition.Lighting.LightingInfluence.LightColorAttenuationValue,
giIntensityFactor = mtoonDefinition.Lighting.LightingInfluence.GiIntensityValue,
normalTexture = -1,
normalScaleFactor = mtoonDefinition.Lighting.Normal.NormalScaleValue,
// Emission
emissionFactor = mtoonDefinition.Emission.EmissionColor.linear.ToArray(),
emissionMultiplyTexture = -1,
// MatCap
additiveTexture = -1,
// Rim
rimFactor = mtoonDefinition.Rim.RimColor.linear.ToArray(),
rimMultiplyTexture = -1,
rimLightingMixFactor = mtoonDefinition.Rim.RimLightingMixValue,
rimFresnelPowerFactor = mtoonDefinition.Rim.RimFresnelPowerValue,
rimLiftFactor = mtoonDefinition.Rim.RimLiftValue,
// Outline
outlineWidthMode = (MToonOutlineWidthMode)mtoonDefinition.Outline.OutlineWidthMode,
outlineWidthFactor = mtoonDefinition.Outline.OutlineWidthValue,
outlineWidthMultiplyTexture = -1,
outlineScaledMaxDistanceFactor = mtoonDefinition.Outline.OutlineScaledMaxDistanceValue,
outlineColorMode = (MToonOutlineColorMode)mtoonDefinition.Outline.OutlineColorMode,
outlineFactor = mtoonDefinition.Outline.OutlineColor.linear.ToArray(),
outlineLightingMixFactor = mtoonDefinition.Outline.OutlineLightingMixValue,
// TextureOption
mainTextureLeftBottomOriginScale = new float[]
{
mtoonDefinition.TextureOption.MainTextureLeftBottomOriginScale.x,
mtoonDefinition.TextureOption.MainTextureLeftBottomOriginScale.y
},
mainTextureLeftBottomOriginOffset = new float[]
{
mtoonDefinition.TextureOption.MainTextureLeftBottomOriginOffset.x,
mtoonDefinition.TextureOption.MainTextureLeftBottomOriginOffset.y
},
uvAnimationMaskTexture = -1,
uvAnimationScrollXSpeedFactor = mtoonDefinition.TextureOption.UvAnimationScrollXSpeedValue,
uvAnimationScrollYSpeedFactor = mtoonDefinition.TextureOption.UvAnimationScrollYSpeedValue,
uvAnimationRotationSpeedFactor = mtoonDefinition.TextureOption.UvAnimationRotationSpeedValue,
};
// Textures
mtoon.litMultiplyTexture = textureManager.CopyAndGetIndex(mtoonDefinition.Color.LitMultiplyTexture, RenderTextureReadWrite.sRGB);
mtoon.shadeMultiplyTexture = textureManager.CopyAndGetIndex(mtoonDefinition.Color.ShadeMultiplyTexture, RenderTextureReadWrite.sRGB);
mtoon.shadowReceiveMultiplierMultiplyTexture = textureManager.CopyAndGetIndex(mtoonDefinition.Lighting.LitAndShadeMixing.ShadowReceiveMultiplierMultiplyTexture, RenderTextureReadWrite.sRGB);
mtoon.litAndShadeMixingMultiplierMultiplyTexture = textureManager.CopyAndGetIndex(mtoonDefinition.Lighting.LitAndShadeMixing.LitAndShadeMixingMultiplierMultiplyTexture, RenderTextureReadWrite.sRGB);
mtoon.normalTexture = textureManager.ConvertAndGetIndex(mtoonDefinition.Lighting.Normal.NormalTexture, new NormalConverter());
mtoon.emissionMultiplyTexture = textureManager.CopyAndGetIndex(mtoonDefinition.Emission.EmissionMultiplyTexture, RenderTextureReadWrite.sRGB);
mtoon.additiveTexture = textureManager.CopyAndGetIndex(mtoonDefinition.MatCap.AdditiveTexture, RenderTextureReadWrite.sRGB);
mtoon.rimMultiplyTexture = textureManager.CopyAndGetIndex(mtoonDefinition.Rim.RimMultiplyTexture, RenderTextureReadWrite.sRGB);
mtoon.outlineWidthMultiplyTexture = textureManager.CopyAndGetIndex(mtoonDefinition.Outline.OutlineWidthMultiplyTexture, RenderTextureReadWrite.sRGB);
mtoon.uvAnimationMaskTexture = textureManager.CopyAndGetIndex(mtoonDefinition.TextureOption.UvAnimationMaskTexture, RenderTextureReadWrite.sRGB);
var material = CreateVrmDefaultMaterial(m, mtoonDefinition.Rendering.RenderMode);
// Double Sided
switch (mtoon.cullMode)
{
case MToonCullMode.Off:
material.doubleSided = true;
break;
case MToonCullMode.Front:
case MToonCullMode.Back:
material.doubleSided = false;
break;
default:
break;
}
// PBR Metallic Roughness
{
if (mtoon.litFactor != null)
{
if (material.pbrMetallicRoughness == null)
{
material.pbrMetallicRoughness = new glTFPbrMetallicRoughness();
}
material.pbrMetallicRoughness.baseColorFactor = mtoon.litFactor;
}
if (mtoon.litMultiplyTexture != -1)
{
if (material.pbrMetallicRoughness == null)
{
material.pbrMetallicRoughness = new glTFPbrMetallicRoughness();
}
material.pbrMetallicRoughness.baseColorTexture = new glTFMaterialBaseColorTextureInfo()
{
index = mtoon.litMultiplyTexture,
};
//material.pbrMetallicRoughness.metallicFactor = 1.0f;
//material.pbrMetallicRoughness.roughnessFactor = 1.0f;
}
}
// Normal Texture
if (mtoon.normalTexture != -1)
{
material.normalTexture = new glTFMaterialNormalTextureInfo()
{
index = mtoon.normalTexture,
scale = mtoon.normalScaleFactor,
};
}
// Emissive
{
material.emissiveFactor = mtoon.emissionFactor;
if (mtoon.emissionMultiplyTexture != -1)
{
material.emissiveTexture = new glTFMaterialEmissiveTextureInfo()
{
index = mtoon.emissionMultiplyTexture,
};
}
}
// Extensions
material.extensions = new glTFMaterial_extensions()
{
VGO_materials = new VGO_materials(m.shader.name),
VRMC_materials_mtoon = mtoon,
};
return(material);
}
