private static void ProcessDetails(Dictionary <int, int[, ]> details, DslExpression.DslCalculator calc, string proc, int cx, int cy, int r)
{
int x = cx - r;
int y = cy - r;
int w = r * 2;
int h = r * 2;
int r2 = r * r;
for (int ix = 0; ix < w; ++ix)
{
for (int iy = 0; iy < h; ++iy)
{
int xi = x + ix;
int yi = y + iy;
int dx = xi - cx;
int dy = yi - cy;
if (dx * dx + dy * dy <= r2)
{
foreach (var pair in details)
{
int layer = pair.Key;
var detail = pair.Value[xi, yi];
calc.SetVariable("detail", detail);
calc.Calc(proc, xi, yi, layer);
pair.Value[xi, yi] = (int)Convert.ChangeType(calc.GetVariable("detail"), typeof(int));
}
}
}
}
}
private static bool ExecuteUpdate(string dslFile)
{
try {
if (!File.Exists(dslFile))
{
return(false);
}
bool ret = false;
string txt = File.ReadAllText(dslFile);
Dsl.DslFile file = new Dsl.DslFile();
if (file.Load(dslFile, (string msg) => { Debug.LogError(msg); }))
{
s_Calculator = new DslExpression.DslCalculator();
s_Calculator.Init();
s_Calculator.SetGlobalVariable("@@processkey", s_ProcessKey);
s_Calculator.SetGlobalVariable("@@haskey", s_HasKey);
s_Calculator.SetGlobalVariable("global", DslExpression.CalculatorValue.FromObject(GlobalVariables.Instance));
s_Calculator.Register("verifycacheserver", new DslExpression.ExpressionFactoryHelper <VerifyCacheServerExp>());
foreach (var info in file.DslInfos)
{
s_Calculator.LoadDsl(info);
}
object retObj = s_Calculator.Calc("main");
if (null != retObj)
{
ret = (bool)System.Convert.ChangeType(retObj, typeof(bool));
}
}
return(ret);
}
catch {
return(false);
}
}
private static void ProcessAlphamaps(float[,,] alphamaps, DslExpression.DslCalculator calc, string proc, int cx, int cy, int r)
{
int alphanum = alphamaps.GetLength(2);
int x = cx - r;
int y = cy - r;
int w = r * 2;
int h = r * 2;
int r2 = r * r;
for (int ix = 0; ix < w; ++ix)
{
for (int iy = 0; iy < h; ++iy)
{
int xi = x + ix;
int yi = y + iy;
int dx = xi - cx;
int dy = yi - cy;
if (dx * dx + dy * dy <= r2)
{
float[] alphas = calc.GetVariable("alphas") as float[];
for (int i = 0; i < alphanum; ++i)
{
alphas[i] = alphamaps[xi, yi, i];
}
var v = calc.Calc(proc, xi, yi);
for (int i = 0; i < alphanum; ++i)
{
alphamaps[xi, yi, i] = alphas[i];
}
}
}
}
}
private static void ProcessHeights(float[,] datas, DslExpression.DslCalculator calc, string proc, int cx, int cy, int r)
{
int x = cx - r;
int y = cy - r;
int w = r * 2;
int h = r * 2;
int r2 = r * r;
for (int ix = 0; ix < w; ++ix)
{
for (int iy = 0; iy < h; ++iy)
{
int xi = x + ix;
int yi = y + iy;
int dx = xi - cx;
int dy = yi - cy;
if (dx * dx + dy * dy <= r2)
{
calc.SetVariable("height", datas[yi, xi]);
calc.Calc(proc, xi, yi);
datas[yi, xi] = (float)Convert.ChangeType(calc.GetVariable("height"), typeof(float));
}
}
}
}
private static void ProcessHeights(float[,] datas, DslExpression.DslCalculator calc, string proc, int x, int y, int w, int h)
{
for (int ix = 0; ix < w; ++ix)
{
for (int iy = 0; iy < h; ++iy)
{
int xi = x + ix;
int yi = y + iy;
calc.SetVariable("height", datas[yi, xi]);
calc.Calc(proc, xi, yi);
datas[yi, xi] = (float)Convert.ChangeType(calc.GetVariable("height"), typeof(float));
}
}
}
private static void ProcessDetails(Dictionary <int, int[, ]> details, DslExpression.DslCalculator calc, string proc, int x, int y, int w, int h)
{
for (int ix = 0; ix < w; ++ix)
{
for (int iy = 0; iy < h; ++iy)
{
int xi = x + ix;
int yi = y + iy;
foreach (var pair in details)
{
int layer = pair.Key;
var detail = pair.Value[xi, yi];
calc.SetVariable("detail", detail);
calc.Calc(proc, xi, yi, layer);
pair.Value[xi, yi] = (int)Convert.ChangeType(calc.GetVariable("detail"), typeof(int));
}
}
}
}
private static void ProcessAlphamaps(float[,,] alphamaps, DslExpression.DslCalculator calc, string proc, int x, int y, int w, int h)
{
int alphanum = alphamaps.GetLength(2);
for (int ix = 0; ix < w; ++ix)
{
for (int iy = 0; iy < h; ++iy)
{
int xi = x + ix;
int yi = y + iy;
float[] alphas = calc.GetVariable("alphas") as float[];
for (int i = 0; i < alphanum; ++i)
{
alphas[i] = alphamaps[xi, yi, i];
}
var v = calc.Calc(proc, xi, yi);
for (int i = 0; i < alphanum; ++i)
{
alphamaps[xi, yi, i] = alphas[i];
}
}
}
}
internal static string CalcExpressionString(Dsl.ISyntaxComponent comp, FunctionOptions funcOpts, DslExpression.DslCalculator calculator)
{
StringBuilder sb = new StringBuilder();
GenerateSyntaxComponent(comp, sb, 0, false, funcOpts, calculator);
return(sb.ToString());
}
internal static void GenerateArguments(Dsl.FunctionData data, StringBuilder sb, int indent, int start, FunctionOptions funcOpts, DslExpression.DslCalculator calculator)
{
s_CurSyntax = data;
string prestr = string.Empty;
for (int ix = start; ix < data.Params.Count; ++ix)
{
var param = data.Params[ix];
sb.Append(prestr);
string paramId = param.GetId();
if (param.GetIdType() == (int)Dsl.ValueData.ID_TOKEN && paramId == "...")
{
sb.Append("...");
continue;
}
GenerateSyntaxComponent(param, sb, indent, false, funcOpts, calculator);
prestr = ", ";
}
}
private static void GeneratePrefixPostfixOperator(Dsl.FunctionData data, StringBuilder sb, bool forSplit, FunctionOptions funcOpts, DslExpression.DslCalculator calculator)
{
string id = data.GetId();
if (id == "prefixoperator")
{
var fullCode = data.GetParamId(0) == "true";
var varExp = data.GetParam(1);
var opExp = data.GetParam(2);
if (forSplit)
{
GenerateSyntaxComponent(varExp, sb, 0, false, funcOpts, calculator);
sb.Append(" = ");
GenerateSyntaxComponent(opExp, sb, 0, false, funcOpts, calculator);
}
else if (fullCode)
{
sb.Append("(function() ");
GenerateSyntaxComponent(varExp, sb, 0, false, funcOpts, calculator);
sb.Append(" = ");
GenerateSyntaxComponent(opExp, sb, 0, false, funcOpts, calculator);
sb.Append("; return ");
GenerateSyntaxComponent(varExp, sb, 0, false, funcOpts, calculator);
sb.Append("; end)()");
}
else
{
GenerateSyntaxComponent(varExp, sb, 0, false, funcOpts, calculator);
}
}
else if (id == "postfixoperator")
{
var fullCode = data.GetParamId(0) == "true";
var oldVal = data.GetParamId(1);
var varExp = data.GetParam(2);
var opExp = data.GetParam(3);
if (forSplit)
{
sb.Append("local ");
sb.Append(oldVal);
sb.Append(" = ");
GenerateSyntaxComponent(varExp, sb, 0, false, funcOpts, calculator);
sb.Append("; ");
GenerateSyntaxComponent(varExp, sb, 0, false, funcOpts, calculator);
sb.Append(" = ");
GenerateSyntaxComponent(opExp, sb, 0, false, funcOpts, calculator);
}
else if (fullCode)
{
sb.Append("(function() local ");
sb.Append(oldVal);
sb.Append(" = ");
GenerateSyntaxComponent(varExp, sb, 0, false, funcOpts, calculator);
sb.Append("; ");
GenerateSyntaxComponent(varExp, sb, 0, false, funcOpts, calculator);
sb.Append(" = ");
GenerateSyntaxComponent(opExp, sb, 0, false, funcOpts, calculator);
sb.Append("; return ");
sb.Append(oldVal);
sb.Append("; end)()");
}
else
{
sb.Append(oldVal);
}
}
}
private static void GenerateClosure(Dsl.FunctionData data, StringBuilder sb, int indent, bool forRemove, FunctionOptions funcOpts, DslExpression.DslCalculator calculator)
{
var fcall = data.LowerOrderFunction;
bool fullCode = fcall.GetParamId(0) == "true";
string localName = fcall.GetParamId(1);
bool needDecl = (bool)Convert.ChangeType(fcall.GetParamId(2), typeof(bool));
if (forRemove)
{
if (needDecl)
{
sb.AppendFormatLine("{0}local {1};", GetIndentString(indent), localName);
}
GenerateStatements(data, sb, indent, funcOpts, calculator);
}
else if (fullCode)
{
sb.AppendLine("(function() ");
if (data.HaveStatement())
{
++indent;
if (needDecl)
{
sb.AppendFormatLine("{0}local {1};", GetIndentString(indent), localName);
}
GenerateStatements(data, sb, indent, funcOpts, calculator);
sb.AppendFormatLine("{0}return {1};", GetIndentString(indent), localName);
--indent;
}
sb.AppendFormat("{0}end)()", GetIndentString(indent));
}
else
{
sb.Append(localName);
}
}
private static void ProcessWithDsl(Dsl.FunctionData funcData, string type, float[,] datas, float[, ,] alphamaps, Dictionary <int, int[, ]> details, DslExpression.DslCalculator calc, string proc, ref bool resetTrees)
{
if (null == funcData)
{
return;
}
if (null != funcData)
{
if (type == "height")
{
foreach (var comp in funcData.Params)
{
var callData = comp as Dsl.FunctionData;
if (null != callData)
{
string id = callData.GetId();
if (id == "resettrees")
{
resetTrees = bool.Parse(callData.GetParamId(0));
}
else if (id == "rect")
{
int x = int.Parse(callData.GetParamId(0));
int y = int.Parse(callData.GetParamId(1));
int w = int.Parse(callData.GetParamId(2));
int h = int.Parse(callData.GetParamId(3));
ProcessHeights(datas, calc, proc, x, y, w, h);
}
else if (id == "circle")
{
int x = int.Parse(callData.GetParamId(0));
int y = int.Parse(callData.GetParamId(1));
int r = int.Parse(callData.GetParamId(2));
ProcessHeights(datas, calc, proc, x, y, r);
}
}
}
}
else if (type == "alphamap")
{
int alphanum = alphamaps.GetLength(2);
foreach (var comp in funcData.Params)
{
var callData = comp as Dsl.FunctionData;
if (null != callData)
{
string id = callData.GetId();
if (id == "resettrees")
{
resetTrees = bool.Parse(callData.GetParamId(0));
}
else if (id == "rect")
{
int x = int.Parse(callData.GetParamId(0));
int y = int.Parse(callData.GetParamId(1));
int w = int.Parse(callData.GetParamId(2));
int h = int.Parse(callData.GetParamId(3));
ProcessAlphamaps(alphamaps, calc, proc, x, y, w, h);
}
else if (id == "circle")
{
int x = int.Parse(callData.GetParamId(0));
int y = int.Parse(callData.GetParamId(1));
int r = int.Parse(callData.GetParamId(2));
ProcessAlphamaps(alphamaps, calc, proc, x, y, r);
}
}
}
}
else if (type == "detail")
{
foreach (var comp in funcData.Params)
{
var callData = comp as Dsl.FunctionData;
if (null != callData)
{
string id = callData.GetId();
if (id == "resettrees")
{
resetTrees = bool.Parse(callData.GetParamId(0));
}
else if (id == "rect")
{
int x = int.Parse(callData.GetParamId(0));
int y = int.Parse(callData.GetParamId(1));
int w = int.Parse(callData.GetParamId(2));
int h = int.Parse(callData.GetParamId(3));
ProcessDetails(details, calc, proc, x, y, w, h);
}
else if (id == "circle")
{
int x = int.Parse(callData.GetParamId(0));
int y = int.Parse(callData.GetParamId(1));
int r = int.Parse(callData.GetParamId(2));
ProcessDetails(details, calc, proc, x, y, r);
}
}
}
}
}
}
internal static void Process(GameObject root, Dsl.DslFile file, Dictionary <string, Color32[, ]> samplers, Dictionary <string, Size> cacheInfos)
{
if (null != file)
{
List <TreeInstance> trees = new List <TreeInstance>();
Dictionary <string, int[, ]> caches = new Dictionary <string, int[, ]>();
foreach (var pair in cacheInfos)
{
caches.Add(pair.Key, new int[pair.Value.Width, pair.Value.Height]);
}
var terrain = root.GetComponent <Terrain>();
var terrainData = terrain.terrainData;
var datas = terrainData.GetHeights(0, 0, terrainData.heightmapWidth, terrainData.heightmapHeight);
var alphamaps = terrainData.GetAlphamaps(0, 0, terrainData.alphamapWidth, terrainData.alphamapHeight);
int alphanum = alphamaps.GetLength(2);
int[] layers = terrainData.GetSupportedLayers(0, 0, terrainData.detailWidth, terrainData.detailHeight);
Dictionary <int, int[, ]> details = new Dictionary <int, int[, ]>();
foreach (int layer in layers)
{
var ds = terrainData.GetDetailLayer(0, 0, terrainData.detailWidth, terrainData.detailHeight, layer);
details.Add(layer, ds);
}
var calc = new DslExpression.DslCalculator();
calc.Init();
calc.Register("getheight", new DslExpression.ExpressionFactoryHelper <GetHeightExp>());
calc.Register("getalphamap", new DslExpression.ExpressionFactoryHelper <GetAlphamapExp>());
calc.Register("getalpha", new DslExpression.ExpressionFactoryHelper <GetAlphaExp>());
calc.Register("setalpha", new DslExpression.ExpressionFactoryHelper <SetAlphaExp>());
calc.Register("getdetail", new DslExpression.ExpressionFactoryHelper <GetDetailExp>());
calc.Register("samplered", new DslExpression.ExpressionFactoryHelper <SampleRedExp>());
calc.Register("samplegreen", new DslExpression.ExpressionFactoryHelper <SampleGreenExp>());
calc.Register("sampleblue", new DslExpression.ExpressionFactoryHelper <SampleBlueExp>());
calc.Register("samplealpha", new DslExpression.ExpressionFactoryHelper <SampleAlphaExp>());
calc.Register("getcache", new DslExpression.ExpressionFactoryHelper <GetCacheExp>());
calc.Register("setcache", new DslExpression.ExpressionFactoryHelper <SetCacheExp>());
calc.Register("addtree", new DslExpression.ExpressionFactoryHelper <AddTreeExp>());
calc.SetGlobalVariable("samplers", samplers);
calc.SetGlobalVariable("caches", caches);
calc.SetGlobalVariable("trees", trees);
calc.SetGlobalVariable("heightscalex", terrainData.heightmapScale.x);
calc.SetGlobalVariable("heightscaley", terrainData.heightmapScale.y);
calc.SetGlobalVariable("heightscalez", terrainData.heightmapScale.z);
calc.SetGlobalVariable("heights", datas);
calc.SetGlobalVariable("alphamaps", alphamaps);
calc.SetGlobalVariable("alphanum", alphanum);
calc.SetGlobalVariable("details", details);
calc.SetGlobalVariable("height", 0.0f);
calc.SetGlobalVariable("alphas", new float[alphanum]);
calc.SetGlobalVariable("detail", 0);
bool resetTrees = false;
bool canContinue = true;
foreach (var syntaxComponent in file.DslInfos)
{
var func = syntaxComponent as Dsl.FunctionData;
var info = syntaxComponent as Dsl.StatementData;
if (null == func && null != info)
{
func = info.First;
}
int num = null != info?info.GetFunctionNum() : 1;
bool check = false;
if (num >= 2)
{
string firstId = info.First.GetId();
if (firstId == "input")
{
check = true;
for (int i = 1; i < info.GetFunctionNum(); ++i)
{
string id = info.GetFunctionId(i);
if (id == "height" || id == "alphamap" || id == "detail")
{
}
else
{
check = false;
break;
}
}
}
}
if (!check)
{
canContinue = false;
Debug.LogErrorFormat("error script:{0}, {1}", info.GetLine(), info.ToScriptString(false));
}
}
if (canContinue)
{
int ix = 0;
foreach (var syntaxComponent in file.DslInfos)
{
var info = syntaxComponent as Dsl.StatementData;
if (null == info)
{
continue;
}
for (int i = 1; i < info.GetFunctionNum(); ++i)
{
calc.LoadDsl(ix.ToString(), info.GetFunction(i));
++ix;
}
}
int ix2 = 0;
foreach (var syntaxComponent in file.DslInfos)
{
var info = syntaxComponent as Dsl.StatementData;
if (null == info)
{
continue;
}
for (int i = 1; i < info.GetFunctionNum(); ++i)
{
ProcessWithDsl(info.First, info.GetFunctionId(i), datas, alphamaps, details, calc, ix2.ToString(), ref resetTrees);
++ix2;
}
}
}
terrainData.SetHeights(0, 0, datas);
terrainData.SetAlphamaps(0, 0, alphamaps);
foreach (var pair in details)
{
terrainData.SetDetailLayer(0, 0, pair.Key, pair.Value);
}
if (resetTrees)
{
terrainData.treeInstances = trees.ToArray();
}
else
{
trees.AddRange(terrainData.treeInstances);
terrainData.treeInstances = trees.ToArray();
}
}
}
