protected void SetBlend(MyJson_Array enalbesJson, MyJson_Tree functionsJson, BlendMode blend)
{
if (blend == BlendMode.None)
{
return;
}
enalbesJson.AddInt((int)EnableState.BLEND);
var blendFuncSeparate = new int[4];
switch (blend)
{
case BlendMode.Add:
blendFuncSeparate[0] = (int)BlendFactor.SRC_ALPHA;
blendFuncSeparate[1] = (int)BlendFactor.ONE;
blendFuncSeparate[2] = (int)BlendFactor.SRC_ALPHA;
blendFuncSeparate[3] = (int)BlendFactor.ONE;
break;
case BlendMode.Blend:
blendFuncSeparate[0] = (int)BlendFactor.SRC_ALPHA;
blendFuncSeparate[1] = (int)BlendFactor.ONE_MINUS_SRC_ALPHA;
blendFuncSeparate[2] = (int)BlendFactor.ONE;
blendFuncSeparate[3] = (int)BlendFactor.ONE_MINUS_SRC_ALPHA;
break;
case BlendMode.Add_PreMultiply:
blendFuncSeparate[0] = (int)BlendFactor.ONE;
blendFuncSeparate[1] = (int)BlendFactor.ONE;
blendFuncSeparate[2] = (int)BlendFactor.ONE;
blendFuncSeparate[3] = (int)BlendFactor.ONE;
break;
case BlendMode.Blend_PreMultiply:
blendFuncSeparate[0] = (int)BlendFactor.ONE;
blendFuncSeparate[1] = (int)BlendFactor.ONE_MINUS_CONSTANT_ALPHA;
blendFuncSeparate[2] = (int)BlendFactor.ONE;
blendFuncSeparate[3] = (int)BlendFactor.ONE_MINUS_CONSTANT_ALPHA;
break;
case BlendMode.Multiply:
blendFuncSeparate[0] = (int)BlendFactor.ZERO;
blendFuncSeparate[1] = (int)BlendFactor.SRC_COLOR;
blendFuncSeparate[2] = (int)BlendFactor.ZERO;
blendFuncSeparate[3] = (int)BlendFactor.SRC_COLOR;
break;
case BlendMode.Multiply_PreMultiply:
blendFuncSeparate[0] = (int)BlendFactor.ZERO;
blendFuncSeparate[1] = (int)BlendFactor.SRC_COLOR;
blendFuncSeparate[2] = (int)BlendFactor.ZERO;
blendFuncSeparate[3] = (int)BlendFactor.SRC_ALPHA;
break;
}
int[] blendEquationSeparate = { (int)BlendEquation.FUNC_ADD, (int)BlendEquation.FUNC_ADD };
this.SetBlendEquationSeparate(functionsJson, blendEquationSeparate);
this.SetBlendFuncSeparate(functionsJson, blendFuncSeparate);
}
protected void SetDepthFunc(MyJson_Tree functionsJson, int[] depthFuncValue)
{
var depthFunc = new MyJson_Array();
foreach (var v in depthFuncValue)
{
depthFunc.AddInt(v);
}
functionsJson.Add("depthFunc", depthFunc);
}
protected void SetCullFace(MyJson_Tree functionsJson, int[] cullFaceValue)
{
var cullFace = new MyJson_Array();
foreach (var v in cullFaceValue)
{
cullFace.AddInt(v);
}
functionsJson.Add("cullFace", cullFace);
}
protected void SetFrontFace(MyJson_Tree functionsJson, int[] frontFaceValue)
{
var frontFace = new MyJson_Array();
foreach (var v in frontFaceValue)
{
frontFace.AddInt(v);
}
functionsJson.Add("frontFace", frontFace);
}
protected void SetBlendFuncSeparate(MyJson_Tree functionsJson, int[] blendFuncSeparateValue)
{
var blendFuncSeparate = new MyJson_Array();
foreach (var v in blendFuncSeparateValue)
{
blendFuncSeparate.AddInt((int)v);
}
functionsJson.Add("blendFuncSeparate", blendFuncSeparate);
}
protected void SetCullFace(MyJson_Array enalbesJson, MyJson_Tree functionsJson, bool cull)
{
if (cull)
{
int[] frontFace = { (int)FrontFace.CCW };
this.SetFrontFace(functionsJson, frontFace);
int[] cullFace = { (int)CullFace.BACK };
this.SetCullFace(functionsJson, cullFace);
enalbesJson.AddInt((int)EnableState.CULL_FACE);
}
}
protected void SetDepth(MyJson_Array enalbesJson, MyJson_Tree functionsJson, bool zTest, bool zWrite)
{
if (zTest && zWrite)
{
return;
}
if (zTest)
{
int[] depthFunc = { (int)DepthFunc.LEQUAL };
this.SetDepthFunc(functionsJson, depthFunc);
enalbesJson.AddInt((int)EnableState.DEPTH_TEST);
}
int[] depthMask = { zWrite ? 1 : 0 };
this.SetDepthMask(functionsJson, depthMask);
}
public MyJson_Tree Write()
{
this.Update();
var customConfig = ExportConfig.instance.IsCustomShader(this.shaderName);
//
var materialItemJson = new MyJson_Tree();
var extensions = new MyJson_Tree();
materialItemJson.Add("extensions", extensions);
var KHR_techniques_webglJson = new MyJson_Tree();
extensions.Add("KHR_techniques_webgl", KHR_techniques_webglJson);
var paperJson = new MyJson_Tree();
extensions.Add("paper", paperJson);
var valuesJson = new MyJson_Tree();
KHR_techniques_webglJson.Add("values", valuesJson);
//
var source = this.source;
var shaderName = source.shader.name.ToLower();
MyLog.Log("Shader:" + shaderName);
foreach (var value in this.values)
{
valuesJson.Add(value.Key, value.Value);
}
if (customConfig != null && !string.IsNullOrEmpty(customConfig.technique))
{
KHR_techniques_webglJson.SetString("technique", customConfig.technique);
}
else
{
KHR_techniques_webglJson.SetString("technique", this.technique);
}
//paper
paperJson.SetInt("renderQueue", this.source.renderQueue);
if (this.defines.Count > 0)
{
var definesJson = new MyJson_Array();
foreach (var define in this.defines)
{
definesJson.AddString(define);
}
paperJson.Add("defines", definesJson);
}
//
//standard
var isDoubleSide = this.isDoubleSide;
var isTransparent = this.isTransparent;
var blend = this.blendMode;
var statesJson = new MyJson_Tree();
var enable = new MyJson_Array();
if (isDoubleSide || blend != BlendMode.None || isTransparent || (customConfig != null && customConfig.enable != null))
{
//states
paperJson.Add("states", statesJson);
var functionsJson = new MyJson_Tree();
statesJson.Add("enable", enable);
statesJson.Add("functions", functionsJson);
if (customConfig != null && customConfig.enable != null)
{
foreach (var value in customConfig.enable)
{
enable.AddInt(value);
}
if (customConfig.blendEquationSeparate != null)
{
this.SetBlendEquationSeparate(functionsJson, customConfig.blendEquationSeparate);
}
if (customConfig.blendFuncSeparate != null)
{
this.SetBlendFuncSeparate(functionsJson, customConfig.blendFuncSeparate);
}
if (customConfig.frontFace != null)
{
this.SetFrontFace(functionsJson, customConfig.frontFace);
}
if (customConfig.cullFace != null)
{
this.SetCullFace(functionsJson, customConfig.cullFace);
}
if (customConfig.depthFunc != null)
{
this.SetDepthFunc(functionsJson, customConfig.depthFunc);
}
if (customConfig.depthMask != null)
{
this.SetDepthMask(functionsJson, customConfig.depthMask);
}
}
else
{
this.SetBlend(enable, functionsJson, blend);
this.SetCullFace(enable, functionsJson, !isDoubleSide);
this.SetDepth(enable, functionsJson, true, !isTransparent);
}
}
return(materialItemJson);
}
public override bool WriteToJson(GameObject obj, Component component, MyJson_Object compJson)
{
ParticleSystem comp = component as ParticleSystem;
if (!comp.emission.enabled || obj.GetComponent <ParticleSystemRenderer>() == null)
{
MyLog.LogWarning("无效的粒子组件:" + obj.name);
return(false);
}
//main
{
var main = comp.main;
var mainItem = new MyJson_Tree(false);
compJson["main"] = mainItem;
mainItem.SetNumber("duration", main.duration);
mainItem.SetBool("loop", main.loop);
this.AddMinMaxCurve(mainItem, "startDelay", main.startDelay);
this.AddMinMaxCurve(mainItem, "startLifetime", main.startLifetime);
this.AddMinMaxCurve(mainItem, "startSpeed", main.startSpeed);
mainItem.SetBool("startSize3D", main.startSize3D);
if (main.startSize3D)
{
this.AddMinMaxCurve(mainItem, "startSizeX", main.startSizeX);
this.AddMinMaxCurve(mainItem, "startSizeY", main.startSizeY);
this.AddMinMaxCurve(mainItem, "startSizeZ", main.startSizeZ);
}
else
{
this.AddMinMaxCurve(mainItem, "startSizeX", main.startSize);
this.AddMinMaxCurve(mainItem, "startSizeY", main.startSize);
this.AddMinMaxCurve(mainItem, "startSizeZ", main.startSize);
}
mainItem.SetBool("_startRotation3D", main.startRotation3D);
if (main.startRotation3D)
{
this.AddMinMaxCurve(mainItem, "startRotationX", main.startRotationX);
this.AddMinMaxCurve(mainItem, "startRotationY", main.startRotationY);
this.AddMinMaxCurve(mainItem, "startRotationZ", main.startRotationZ);
}
else
{
this.AddMinMaxCurve(mainItem, "startRotationX", main.startRotation);
this.AddMinMaxCurve(mainItem, "startRotationY", main.startRotation);
this.AddMinMaxCurve(mainItem, "startRotationZ", main.startRotation);
}
this.AddMinMaxGradient(mainItem, "startColor", main.startColor);
this.AddMinMaxCurve(mainItem, "gravityModifier", main.gravityModifier);
mainItem.SetEnum("_simulationSpace", main.simulationSpace);
mainItem.SetEnum("scaleMode", main.scalingMode);
mainItem.SetBool("playOnAwake", main.playOnAwake);
if (ExportToolsSetting.instance.estimateMaxParticles)
{
var value = this.EstimateMaxParticles(comp);
mainItem.SetInt("_maxParticles", value);
MyLog.Log(comp.gameObject.name + " 粒子估算:" + value);
}
else
{
mainItem.SetInt("_maxParticles", main.maxParticles);
}
}
//emission
{
var emissionItem = new MyJson_Tree(false);
compJson["emission"] = emissionItem;
this.AddMinMaxCurve(emissionItem, "rateOverTime", comp.emission.rateOverTime);
emissionItem["bursts"] = new MyJson_Array();
var bursts = new ParticleSystem.Burst[comp.emission.burstCount];
comp.emission.GetBursts(bursts);
foreach (var burst in bursts)
{
MyJson_Array burstItem = new MyJson_Array();
burstItem.AddNumber(burst.time);
burstItem.AddInt(burst.minCount);
burstItem.AddInt(burst.maxCount);
burstItem.AddInt(burst.cycleCount);
burstItem.AddNumber(burst.repeatInterval);
(emissionItem["bursts"] as MyJson_Array).Add(burstItem);
}
}
//shape
if (comp.shape.enabled)
{
var shapItem = new MyJson_Tree(false);
compJson["shape"] = shapItem;
shapItem.SetEnum("shapeType", comp.shape.shapeType);
shapItem.SetNumber("angle", comp.shape.angle);
shapItem.SetNumber("length", comp.shape.length);
shapItem.SetEnum("arcMode", comp.shape.arcMode);
shapItem.SetNumber("arc", comp.shape.arc);
shapItem.SetNumber("arcSpread", comp.shape.arcSpread);
shapItem.SetEnum("radiusMode", comp.shape.radiusMode);
shapItem.SetNumber("radius", comp.shape.radius);
shapItem.SetNumber("radiusSpread", comp.shape.radiusSpread);
shapItem.SetVector3("box", comp.shape.box);
shapItem.SetBool("randomDirection", comp.shape.randomDirectionAmount > 0);
shapItem.SetBool("spherizeDirection", comp.shape.sphericalDirectionAmount > 0);
this.AddMinMaxCurve(shapItem, "arcSpeed", comp.shape.arcSpeed);
}
//velocityOverLifetiem
if (comp.velocityOverLifetime.enabled)
{
var velocityOverItem = new MyJson_Tree(false);
compJson["velocityOverLifetime"] = velocityOverItem;
velocityOverItem.SetEnum("_mode", comp.velocityOverLifetime.x.mode);
velocityOverItem.SetEnum("_space", comp.velocityOverLifetime.space);
this.AddMinMaxCurve(velocityOverItem, "_x", comp.velocityOverLifetime.x);
this.AddMinMaxCurve(velocityOverItem, "_y", comp.velocityOverLifetime.y);
this.AddMinMaxCurve(velocityOverItem, "_z", comp.velocityOverLifetime.z);
}
//colorOverLifetime
if (comp.colorOverLifetime.enabled)
{
var colorOverItem = new MyJson_Tree(false);
compJson["colorOverLifetime"] = colorOverItem;
this.AddMinMaxGradient(colorOverItem, "_color", comp.colorOverLifetime.color);
}
//sizeOverLifetime
if (comp.sizeOverLifetime.enabled)
{
var sizeOverItem = new MyJson_Tree(false);
compJson["sizeOverLifetime"] = sizeOverItem;
sizeOverItem.SetBool("_separateAxes", comp.sizeOverLifetime.separateAxes);
this.AddMinMaxCurve(sizeOverItem, "_size", comp.sizeOverLifetime.size);
this.AddMinMaxCurve(sizeOverItem, "_x", comp.sizeOverLifetime.x);
this.AddMinMaxCurve(sizeOverItem, "_y", comp.sizeOverLifetime.y);
this.AddMinMaxCurve(sizeOverItem, "_z", comp.sizeOverLifetime.z);
}
//rotationOverLifetime
if (comp.rotationOverLifetime.enabled)
{
var rotationOverItem = new MyJson_Tree(false);
compJson["rotationOverLifetime"] = rotationOverItem;
rotationOverItem.SetBool("_separateAxes", comp.rotationOverLifetime.separateAxes);
this.AddMinMaxCurve(rotationOverItem, "_x", comp.rotationOverLifetime.x);
this.AddMinMaxCurve(rotationOverItem, "_y", comp.rotationOverLifetime.y);
this.AddMinMaxCurve(rotationOverItem, "_z", comp.rotationOverLifetime.z);
}
//textureSheetAnimationModule
if (comp.textureSheetAnimation.enabled)
{
var textureSheetAnimation = new MyJson_Tree(false);
compJson["textureSheetAnimation"] = textureSheetAnimation;
textureSheetAnimation.SetInt("_numTilesX", comp.textureSheetAnimation.numTilesX);
textureSheetAnimation.SetInt("_numTilesY", comp.textureSheetAnimation.numTilesY);
textureSheetAnimation.SetEnum("_animation", comp.textureSheetAnimation.animation);
textureSheetAnimation.SetBool("_useRandomRow", comp.textureSheetAnimation.useRandomRow);
textureSheetAnimation.SetInt("_cycleCount", comp.textureSheetAnimation.cycleCount);
textureSheetAnimation.SetInt("_rowIndex", comp.textureSheetAnimation.rowIndex);
this.AddMinMaxCurve(textureSheetAnimation, "_frameOverTime", comp.textureSheetAnimation.frameOverTime, comp.textureSheetAnimation.numTilesX * comp.textureSheetAnimation.numTilesY);
this.AddMinMaxCurve(textureSheetAnimation, "_startFrame", comp.textureSheetAnimation.startFrame);
}
return(true);
}
