static string CreateMainShaderCode(ImportingAsset importingAsset, int stage)
{
var baseCode = "";
if (stage == 0)
{
if (importingAsset.CustomData1Count > 0)
{
baseCode += "#if _MODEL_\n";
baseCode += string.Format("float4 customData1 = buf_customData1[inst];\n");
baseCode += "#else\n";
baseCode += string.Format("float{0} customData1 = Input.CustomData1;\n", importingAsset.CustomData1Count);
baseCode += "#endif\n";
}
if (importingAsset.CustomData2Count > 0)
{
baseCode += "#if _MODEL_\n";
baseCode += string.Format("float4 customData2 = buf_customData2[inst];\n");
baseCode += "#else\n";
baseCode += string.Format("float{0} customData2 = Input.CustomData2;\n", importingAsset.CustomData2Count);
baseCode += "#endif\n";
}
}
else if (stage == 1)
{
if (importingAsset.CustomData1Count > 0)
{
baseCode += string.Format("float{0} customData1 = Input.CustomData1;", importingAsset.CustomData1Count);
}
if (importingAsset.CustomData2Count > 0)
{
baseCode += string.Format("float{0} customData2 = Input.CustomData2;", importingAsset.CustomData2Count);
}
}
baseCode += importingAsset.Code;
baseCode = baseCode.Replace("$F1$", "float");
baseCode = baseCode.Replace("$F2$", "float2");
baseCode = baseCode.Replace("$F3$", "float3");
baseCode = baseCode.Replace("$F4$", "float4");
baseCode = baseCode.Replace("$TIME$", "_Time.y");
baseCode = baseCode.Replace("$UV$", "uv");
int actualTextureCount = Math.Min(importingAsset.UserTextureSlotMax, importingAsset.Textures.Count);
for (int i = 0; i < actualTextureCount; i++)
{
var keyP = "$TEX_P" + i + "$";
var keyS = "$TEX_S" + i + "$";
if (stage == 0)
{
baseCode = baseCode.Replace(
keyP,
"tex2Dlod(" + importingAsset.Textures[i].Name + ",float4(GetUV(");
baseCode = baseCode.Replace(keyS, "),0,0))");
}
else
{
baseCode = baseCode.Replace(
keyP,
"tex2D(" + importingAsset.Textures[i].Name + ",GetUV(");
baseCode = baseCode.Replace(keyS, "))");
}
}
// invalid texture
for (int i = actualTextureCount; i < importingAsset.Textures.Count; i++)
{
var keyP = "$TEX_P" + i + "$";
var keyS = "$TEX_S" + i + "$";
baseCode = baseCode.Replace(keyP, "float4(");
baseCode = baseCode.Replace(keyS, ",0.0,1.0)");
}
if (stage == 0)
{
if (importingAsset.CustomData1Count == 1)
{
baseCode += "Output.CustomData1 = customData1;";
}
if (importingAsset.CustomData1Count == 2)
{
baseCode += "Output.CustomData1 = customData1.xy;";
}
if (importingAsset.CustomData1Count == 3)
{
baseCode += "Output.CustomData1 = customData1.xyz;";
}
if (importingAsset.CustomData1Count == 4)
{
baseCode += "Output.CustomData1 = customData1.xyzw;";
}
if (importingAsset.CustomData2Count == 1)
{
baseCode += "Output.CustomData2 = customData2;";
}
if (importingAsset.CustomData2Count == 2)
{
baseCode += "Output.CustomData2 = customData2.xy;";
}
if (importingAsset.CustomData2Count == 3)
{
baseCode += "Output.CustomData2 = customData2.xyz;";
}
if (importingAsset.CustomData2Count == 4)
{
baseCode += "Output.CustomData2 = customData2.xyzw;";
}
}
return(baseCode);
}
static Shader CreateShader(string path, ImportingAsset importingAsset)
{
var nl = Environment.NewLine;
var mainVSCode = CreateMainShaderCode(importingAsset, 0);
var mainPSCode = CreateMainShaderCode(importingAsset, 1);
var code = shaderTemplate;
code = code.Replace("@", "#");
string codeProperty = string.Empty;
string codeVariable = string.Empty;
string codeUniforms = string.Empty;
int actualTextureCount = Math.Min(importingAsset.UserTextureSlotMax, importingAsset.Textures.Count);
for (int i = 0; i < actualTextureCount; i++)
{
codeProperty += importingAsset.Textures[i].Name + @"(""Color (RGBA)"", 2D) = ""white"" {}" + nl;
codeVariable += "sampler2D " + importingAsset.Textures[i].Name + ";" + nl;
}
for (int i = 0; i < importingAsset.Uniforms.Count; i++)
{
codeUniforms += "float4 " + importingAsset.Uniforms[i].Name + ";" + nl;
}
// replace for usability
// HACK for efk_xxx_1 and efk_xxx_12
{
var replacingUniforms = importingAsset.Uniforms.ToArray();
replacingUniforms = replacingUniforms.OrderByDescending(_ => _.UniformName.Length).ToArray();
foreach (var kv in replacingUniforms)
{
if (kv.Name == string.Empty)
{
continue;
}
code = code.Replace(kv.UniformName, kv.Name);
mainVSCode = mainVSCode.Replace(kv.UniformName, kv.Name);
mainPSCode = mainPSCode.Replace(kv.UniformName, kv.Name);
}
}
code = code.Replace("%TEX_PROPERTY%", codeProperty);
code = code.Replace("%TEX_VARIABLE%", codeVariable);
code = code.Replace("%UNIFORMS%", codeUniforms);
code = code.Replace("%VSCODE%", mainVSCode);
code = code.Replace("%PSCODE%", mainPSCode);
code = code.Replace("%MATERIAL_NAME%", System.IO.Path.GetFileNameWithoutExtension(path));
if (importingAsset.HasRefraction)
{
code = code.Replace("//PRAGMA_REFRACTION_FLAG", "#pragma multi_compile _ _MATERIAL_REFRACTION_");
}
if (importingAsset.ShadingModel == 0)
{
code = code.Replace("//PRAGMA_LIT_FLAG", "#define _MATERIAL_LIT_ 1");
}
if (importingAsset.CustomData1Count > 0)
{
code = code.Replace("//%CUSTOM_BUF1%", string.Format("StructuredBuffer<float4> buf_customData1;"));
code = code.Replace("//%CUSTOM_VS_INPUT1%", string.Format("float{0} CustomData1;", importingAsset.CustomData1Count));
code = code.Replace("//%CUSTOM_VSPS_INOUT1%", string.Format("float{0} CustomData1 : TEXCOORD7;", importingAsset.CustomData1Count));
}
if (importingAsset.CustomData2Count > 0)
{
code = code.Replace("//%CUSTOM_BUF2%", string.Format("StructuredBuffer<float4> buf_customData2;"));
code = code.Replace("//%CUSTOM_VS_INPUT2%", string.Format("float{0} CustomData2;", importingAsset.CustomData2Count));
code = code.Replace("//%CUSTOM_VSPS_INOUT2%", string.Format("float{0} CustomData2 : TEXCOORD8;", importingAsset.CustomData2Count));
}
// change return codes
code = code.Replace("\r\n", "\n");
AssetDatabase.StartAssetEditing();
using (var writer = new StreamWriter(path))
{
writer.Write(code);
}
AssetDatabase.StopAssetEditing();
AssetDatabase.Refresh(ImportAssetOptions.ImportRecursive);
AssetDatabase.ImportAsset(path, ImportAssetOptions.ImportRecursive);
var asset = AssetDatabase.LoadAssetAtPath <Shader>(path);
return(asset);
}
public static void CreateAsset(string path, ImportingAsset importingAsset)
{
// modify
if (importingAsset.CustomData1Count > 0)
{
importingAsset.CustomData1Count = Math.Max(2, importingAsset.CustomData1Count);
}
if (importingAsset.CustomData2Count > 0)
{
importingAsset.CustomData2Count = Math.Max(2, importingAsset.CustomData2Count);
}
// modifiy importing asset to avoid invalid name
foreach (var texture in importingAsset.Textures)
{
if (texture.Name == string.Empty)
{
texture.Name = texture.UniformName;
}
// Escape
texture.Name = EscapePropertyName(texture.Name);
}
string assetPath = Path.ChangeExtension(path, ".asset");
var asset = AssetDatabase.LoadAssetAtPath <EffekseerMaterialAsset>(assetPath);
if (asset != null)
{
}
string assetDir = assetPath.Substring(0, assetPath.LastIndexOf('/'));
bool isNewAsset = false;
if (asset == null)
{
asset = CreateInstance <EffekseerMaterialAsset>();
isNewAsset = true;
}
if (importingAsset.IsCacheFile)
{
asset.cachedMaterialBuffers = importingAsset.Data;
}
else
{
asset.materialBuffers = importingAsset.Data;
asset.uniforms = importingAsset.Uniforms.ToArray();
asset.textures = importingAsset.Textures.ToArray();
asset.CustomData1Count = importingAsset.CustomData1Count;
asset.CustomData2Count = importingAsset.CustomData2Count;
asset.HasRefraction = importingAsset.HasRefraction;
var shader = CreateShader(Path.ChangeExtension(path, ".shader"), importingAsset);
// sometimes return null
if (shader != null)
{
asset.shader = shader;
}
}
if (isNewAsset)
{
AssetDatabase.CreateAsset(asset, assetPath);
}
else
{
EditorUtility.SetDirty(asset);
}
AssetDatabase.Refresh();
}
