public string Evaluate(WooState state)
{
string ret;
if (_Codeblock != null)
{
ret = "{";
ret += _Codeblock.Evaluate(state);
ret += "}";
return(ret);
}
ret = _String;
if (_Arguments.Count() > 0)
{
ret += "(";
for (int i = 0; i < _Arguments.Count(); i++)
{
ret += _Arguments[i].Evaluate(state);
if (i < _Arguments.Count() - 1)
{
ret += ",";
}
}
ret += ")";
}
return(ret);
}
public void Execute(ref WooState state)
{
if (state._PreviousState != null)
{
state = state._PreviousState;
}
}
public string Evaluate(WooState state)
{
if (_IsNull)
{
return(_Argument.Evaluate(state));
}
else
{
if (_AssignOp.Equals("=", StringComparison.Ordinal))
{
return("set(" + _Target + ", " + _Argument.Evaluate(state) + ")");
}
if (_AssignOp.Equals("*=", StringComparison.Ordinal))
{
return("set(" + _Target + ", mul(" + _Target + ", " + _Argument.Evaluate(state) + "))");
}
if (_AssignOp.Equals("/=", StringComparison.Ordinal))
{
return("set(" + _Target + ", div(" + _Target + ", " + _Argument.Evaluate(state) + "))");
}
if (_AssignOp.Equals("-=", StringComparison.Ordinal))
{
return("set(" + _Target + ", sub(" + _Target + ", " + _Argument.Evaluate(state) + "))");
}
if (_AssignOp.Equals("+=", StringComparison.Ordinal))
{
return("set(" + _Target + ", add(" + _Target + ", " + _Argument.Evaluate(state) + "))");
}
}
throw new EvaluateException("Failed to evaluate shader statement");
}
public void CreateElement(bool preview, XElement parent)
{
if (!_ParseSuccessful)
{
return;
}
try
{
foreach (Rule r in _Rules)
{
if (r._Name.Equals("main", StringComparison.InvariantCultureIgnoreCase))
{
WooState state = new WooState();
state._Rules = _Rules;
state._Shaders = _Shaders;
state._Random = new Random(10);//_Seed);
state._Parent = parent;
state._Preview = preview;
r.Execute(ref state);
}
}
}
catch (EvaluateException e)
{
MessageBox.Show(e._WooMessage);
}
}
public void Execute(ref WooState state)
{
if (state._Recursions > 0 || !state.GetRule(_RulePrototype._Name).CanRecurse())
{
state._Recursions--;
for (int i = 0; i < _ArgValue.Count(); i++)
{
if (_RulePrototype._Args[i]._Type == VarType.varVector)
{
state.AddVector(_RulePrototype._Args[i]._Name, _ArgValue[i].EvaluateVector(ref state));
}
else if (_RulePrototype._Args[i]._Type == VarType.varFloat)
{
state.AddFloat(_RulePrototype._Args[i]._Name, _ArgValue[i].EvaluateFloat(ref state));
}
}
state.GetRule(_RulePrototype._Name).Execute(ref state);
for (int i = 0; i < _ArgValue.Count(); i++)
{
if (_RulePrototype._Args[i]._Type == VarType.varVector)
{
state.RemoveVector(_RulePrototype._Args[i]._Name);
}
else if (_RulePrototype._Args[i]._Type == VarType.varFloat)
{
state.RemoveFloat(_RulePrototype._Args[i]._Name);
}
}
state._Recursions++;
}
}
public Vector3 EvaluateVector(ref WooState state)
{
Vector3 arg = _Arg.EvaluateVector(ref state);
arg.Normalise();
return(arg);
}
public void ExecuteFloat(ref WooState state, string varName, Expression expression)
{
double value = expression.EvaluateFloat(ref state);
double current = state.GetValueFloat(varName);
state.SetValue(varName, value + current);
}
public void Execute(ref WooState state)
{
Vector3 colourVec = _ColourExpr.EvaluateVector(ref state);
Colour colour = new Colour(colourVec.x, colourVec.y, colourVec.z);
Vector3 direction = _DirectionExpr.EvaluateVector(ref state);
double area = _AreaExpr.EvaluateFloat(ref state);
if (area < 0)
{
area = 0;
}
if (area > 0.99)
{
area = 0.99;
}
double samples = _SamplesExpr.EvaluateFloat(ref state);
if (samples < 1)
{
samples = 1;
}
DirectionalLight directionalLight = new DirectionalLight(colour, direction, (float)area, (int)samples);
directionalLight.CreateElement(state._Parent, new Vector3(0, 0, 0));
}
public double EvaluateFloat(ref WooState state)
{
double output = 0;
double randVal = state._Random.NextDouble();
switch (_RangeType)
{
case RangeTypeT.Single:
output = val1;
break;
case RangeTypeT.Binary:
if (randVal > 0.5)
{
output = val1;
}
else
{
output = val2;
}
break;
case RangeTypeT.Continuous:
output = ((val2 - val1) * randVal) + val1;
break;
}
return(output);
}
public void Execute(ref WooState state)
{
foreach (Statement s in _Statements)
{
s.Execute(ref state);
}
}
public override void Execute(ref WooState state)
{
if (state._Objects > 0)
{
state._Objects--;
Vector3 val = new Vector3(0.0, 0.5, 0.0);
val.y *= state._Scale.y;
val.Mul(state._Rotation);
Fractal newFractal = new Fractal(new Vector3(state._Position.x + val.x, state._Position.y + val.y, state._Position.z + val.z),
state._Scale * 0.5,
state._Rotation,
state._DistanceMinimum,
state._DistanceScale,
state._DistanceOffset,
state._DistanceIterations,
state._DistanceExtents,
state._StepSize,
state._FractalIterations,
state._FractalIterationCount,
state._ColourIterationCount,
state._DEMode);
newFractal._Material = GenerateMaterial(state);
newFractal.CreateElement(state._Preview, state._Parent);
}
}
public void Execute(ref WooState state)
{
foreach (Statement s in _Statements)
{
s.Execute(ref state);
}
}
public string Evaluate(WooState state)
{
string ret;
if (_Codeblock != null)
{
ret = "{";
ret += _Codeblock.Evaluate(state);
ret += "}";
return ret;
}
ret = _String;
if (_Arguments.Count() > 0)
{
ret += "(";
for (int i =0; i<_Arguments.Count(); i++)
{
ret += _Arguments[i].Evaluate(state);
if (i<_Arguments.Count()-1) ret += ",";
}
ret += ")";
}
return ret;
}
public void ExecuteFloat(ref WooState state, string varName, Expression expression)
{
double value = expression.EvaluateFloat(ref state);
// state.GetValue(floatVar);
state.SetValueOverride(varName, value);
}
public void Execute(ref WooState state)
{
double rand = state._Random.NextDouble();
double totalWeight = 0;
foreach (Expression e in _Weight)
{
totalWeight += e.EvaluateFloat(ref state);
}
rand *= totalWeight;
double currentWeight = 0;
int i = 0;
while (currentWeight < rand)
{
currentWeight += _Weight[i++].EvaluateFloat(ref state);
}
if (state._Recursions > 0 || !state.GetRule(_Rule[i - 1]).CanRecurse())
{
state._Recursions--;
WooState newState = state.Clone();
state.GetRule(_Rule[i - 1]).Execute(ref newState);
state._Recursions++;
}
}
public void Execute(ref WooState state)
{
Vector3 colourVec = _ColourExpr.EvaluateVector(ref state);
Colour colour = new Colour(colourVec.x, colourVec.y, colourVec.z);
AmbientLight ambientLight = new AmbientLight(colour);
ambientLight.CreateElement(state._Parent, new Vector3(0, 0, 0));
}
public void ExecuteVector(ref WooState state, string varName, Expression expression)
{
Vector3 value = expression.EvaluateVector(ref state);
Vector3 current = state.GetValueVector(varName);
current.x += value.x;
current.y += value.y;
current.z += value.z;
state.SetValue(varName, current);
}
public void Execute(ref WooState state)
{
if (state._Recursions > 0 || !state.GetRule(_Callee).CanRecurse())
{
state._Recursions--;
// WooState newState = state.Clone();
state.GetRule(_Callee).Execute(ref state);
state._Recursions++;
}
}
public override void Execute(ref WooState state)
{
if (state._Objects > 0)
{
state._Objects--;
Circle newCircle = new Circle(new Vector3(state._Position.x, state._Position.y, state._Position.z), state._Scale * 0.5, state._Rotation);
newCircle._Material = GenerateMaterial(state);
newCircle.CreateElement(state._Preview, state._Parent);
}
}
public void Execute(ref WooState state)
{
if (state._Recursions == 0)
{
state._Recursions--;
WooState newState = state.Clone();
state.GetRule(_Callee).Execute(ref newState);
state._Recursions++;
}
}
public string Evaluate(WooState state)
{
string ret = "";
foreach (ShaderStatement statement in _Statements)
{
ret += statement.Evaluate(state);
}
return(ret);
}
public override void Execute(ref WooState state)
{
if (state._Objects > 0)
{
state._Objects--;
Circle newCircle = new Circle(new Vector3(state._Position.x, state._Position.y, state._Position.z), state._Scale * 0.5, state._Rotation);
newCircle._Material = GenerateMaterial(state);
newCircle.CreateElement(state._Preview, state._Parent);
}
}
public void Execute(ref WooState state)
{
if (state._Recursions == 0)
{
state._Recursions--;
WooState newState = state.Clone();
state.GetRule(_Callee).Execute(ref newState);
state._Recursions++;
}
}
public void Execute(ref WooState state)
{
if (state._Recursions > 0 || !state.GetRule(_Callee).CanRecurse())
{
state._Recursions--;
// WooState newState = state.Clone();
state.GetRule(_Callee).Execute(ref state);
state._Recursions++;
}
}
public void Execute(ref WooState state)
{
int cycles = 0;
for (int i = 0; i < _Expression.EvaluateFloat(ref state); i++)
{
_RepeatBlock.Execute(ref state);
if (cycles++ > 10000)
return;
}
}
public void ExecuteVector(ref WooState state, string varName, Expression expression)
{
Vector3 value = expression.EvaluateVector(ref state);
Vector3 current = state.GetValueVector(varName);
current.x += value.x;
current.y += value.y;
current.z += value.z;
state.SetValue(varName, current);
}
public void Execute(ref WooState state)
{
if (_ShaderMode)
{
state._DistanceFunction = state.GetShader(_DistanceFunction).Evaluate(state);
}
else
{
state._DistanceFunction = "set(distance, " + _DistanceFunction + ")";
}
}
public void Execute(ref WooState state)
{
Vector3 colourVec = _ColourExpr.EvaluateVector(ref state);
Colour colour = new Colour(colourVec.x, colourVec.y, colourVec.z);
Vector3 position = _PositionExpr.EvaluateVector(ref state);
PointLight pointLight = new PointLight(colour, position);
pointLight.CreateElement(state._Parent, position);
}
public void Execute(ref WooState state)
{
Vector3 colourVec = _ColourExpr.EvaluateVector(ref state);
Colour colour = new Colour(colourVec.x, colourVec.y, colourVec.z);
Background background = new Background();
background._BackgroundColour = colour;
background._Simple = true;
background.CreateElement(state._Parent);
}
public void Execute(ref WooState state)
{
if (_ShaderMode)
{
state._DistanceFunction = state.GetShader(_DistanceFunction).Evaluate(state);
}
else
{
state._DistanceFunction = "set(distance, " + _DistanceFunction + ")";
}
}
public Vector3 EvaluateVector(ref WooState state)
{
if (_Type == VarType.varVector)
{
return(state.GetValueVector(_Variable));
}
else
{
throw new EvaluateException("Float variables can't evaluate to vectors.\n");
}
}
public double EvaluateFloat(ref WooState state)
{
if (_Type == VarType.varFloat)
{
return(state.GetValueFloat(_Variable));
}
else
{
throw new EvaluateException("Vector variables can't evaluate to floats.\n");
}
}
public void Execute(ref WooState state)
{
if (_ReturnType == VarType.varFloat)
{
_AssignOp.ExecuteFloat(ref state, _Var, _Expression);
}
else if (_ReturnType == VarType.varVector)
{
_AssignOp.ExecuteVector(ref state, _Var, _Expression);
}
}
public void Execute(ref WooState state)
{
if (_ReturnType == VarType.varFloat)
{
_AssignOp.ExecuteFloat(ref state, _Var, _Expression);
}
else if (_ReturnType == VarType.varVector)
{
_AssignOp.ExecuteVector(ref state, _Var, _Expression);
}
}
public void Execute(ref WooState state)
{
//WooState newState = state.Clone();
if (state._Recursions > 0 || !state.GetRule(_Callee).CanRecurse())
{
state._Recursions--;
for (int i = 0; i < (int)(_Expr.EvaluateFloat(ref state)+0.5); i++)
{
state.GetRule(_Callee).Execute(ref state);
}
state._Recursions++;
}
}
public void Execute(ref WooState state)
{
int cycles = 0;
for (int i = 0; i < _Expression.EvaluateFloat(ref state); i++)
{
_RepeatBlock.Execute(ref state);
if (cycles++ > 10000)
{
return;
}
}
}
public void Execute(ref WooState state)
{
//WooState newState = state.Clone();
if (state._Recursions > 0 || !state.GetRule(_Callee).CanRecurse())
{
state._Recursions--;
for (int i = 0; i < (int)(_Expr.EvaluateFloat(ref state) + 0.5); i++)
{
state.GetRule(_Callee).Execute(ref state);
}
state._Recursions++;
}
}
public override void Execute(ref WooState state)
{
if (state._Objects > 0)
{
state._Objects--;
Vector3 val = new Vector3(0.0, 0.5, 0.0);
val.y *= state._Scale.y;
val.Mul(state._Rotation);
Cylinder newCylinder = new Cylinder(new Vector3(state._Position.x + val.x, state._Position.y + val.y, state._Position.z + val.z), state._Scale * 0.5, state._Rotation);
newCylinder._Material = GenerateMaterial(state);
newCylinder.CreateElement(state._Preview, state._Parent);
}
}
public override void Execute(ref WooState state)
{
if (state._Objects > 0)
{
state._Objects--;
Vector3 val = new Vector3(0.0, 0.5, 0.0);
val.y *= state._Scale.y;
val.Mul(state._Rotation);
Cube newCube = new Cube(new Vector3(state._Position.x + val.x, state._Position.y + val.y, state._Position.z + val.z), state._Scale, state._Rotation);
newCube._Material = GenerateMaterial(state);
newCube.CreateElement(state._Preview, state._Parent);
}
}
public void Execute(ref WooState state)
{
for (int i = 0; i < _IfBlock.Count; i++)
{
if (_IfBlock[i]._Condition.Evaluate(ref state))
{
_IfBlock[i]._Block.Execute(ref state);
return;
}
}
if (_ElseBlock != null)
{
_ElseBlock.Execute(ref state);
}
}
public void Execute(ref WooState state)
{
for (int i = 0; i < _IfBlock.Count; i++)
{
if (_IfBlock[i]._Condition.Evaluate(ref state))
{
_IfBlock[i]._Block.Execute(ref state);
return;
}
}
if (_ElseBlock != null)
{
_ElseBlock.Execute(ref state);
}
}
public void Execute(ref WooState state)
{
Vector3 colourVec = _ColourExpr.EvaluateVector(ref state);
Colour colour = new Colour(colourVec.x, colourVec.y, colourVec.z);
double samples = _SamplesExpr.EvaluateFloat(ref state);
if (samples < 1)
{
samples = 1;
}
WorldLight worldLight = new WorldLight(colour, (int)samples);
worldLight.CreateElement(state._Parent, new Vector3(0, 0, 0));
}
public void Execute(ref WooState state)
{
Vector3 colourVec = _ColourExpr.EvaluateVector(ref state);
Colour colour = new Colour(colourVec.x, colourVec.y, colourVec.z);
Vector3 direction = _DirectionExpr.EvaluateVector(ref state);
double area = _AreaExpr.EvaluateFloat(ref state);
if (area < 0) area = 0;
if (area > 0.99) area = 0.99;
double samples = _SamplesExpr.EvaluateFloat(ref state);
if (samples < 1) samples = 1;
DirectionalLight directionalLight = new DirectionalLight(colour, direction, (float)area, (int)samples);
directionalLight.CreateElement(state._Parent, new Vector3(0,0,0));
}
public override void Execute(ref WooState state)
{
if (state._Objects > 0)
{
state._Objects--;
Vector3 val = new Vector3(0.0, 0.5, 0.0);
val.y *= state._Scale.y;
val.Mul(state._Rotation);
Vector3 pos = new Vector3(state._Position.x + val.x, state._Position.y + val.y, state._Position.z + val.z);
SphereLight newLight = new SphereLight(state._Diff,
pos,
(float)(state._Scale.y * 0.5),
2);
newLight.CreateElement(state._Parent, pos);
}
}
public void Execute(ref WooState state)
{
double rand = state._Random.NextDouble();
double totalWeight = 0;
foreach (Expression e in _Weight) totalWeight += e.EvaluateFloat(ref state);
rand *= totalWeight;
double currentWeight = 0;
int i = 0;
while (currentWeight < rand)
{
currentWeight += _Weight[i++].EvaluateFloat(ref state);
}
if (state._Recursions > 0 || !state.GetRule(_Rule[i - 1]).CanRecurse())
{
state._Recursions--;
WooState newState = state.Clone();
state.GetRule(_Rule[i - 1]).Execute(ref newState);
state._Recursions++;
}
}
public override void Execute(ref WooState state)
{
if (state._Objects > 0)
{
state._Objects--;
Vector3 val = new Vector3(0.0, 0.5, 0.0);
val.y *= state._Scale.y;
val.Mul(state._Rotation);
SVO newSVO = new SVO(new Vector3(state._Position.x + val.x, state._Position.y + val.y, state._Position.z + val.z),
state._Scale,
state._Rotation,
state._DistanceFunction,
state._DistanceMinimum,
state._DistanceScale,
state._DistanceOffset,
state._StepSize,
state._Depth);
newSVO._Material = GenerateMaterial(state);
newSVO.CreateElement(state._Preview, state._Parent);
}
}
public void Execute(ref WooState state)
{
if (state._Recursions > 0 || !state.GetRule(_RulePrototype._Name).CanRecurse())
{
state._Recursions--;
for (int i=0; i<_ArgValue.Count(); i++)
{
if (_RulePrototype._Args[i]._Type == VarType.varVector)
state.AddVector(_RulePrototype._Args[i]._Name, _ArgValue[i].EvaluateVector(ref state));
else if (_RulePrototype._Args[i]._Type == VarType.varFloat)
state.AddFloat(_RulePrototype._Args[i]._Name, _ArgValue[i].EvaluateFloat(ref state));
}
state.GetRule(_RulePrototype._Name).Execute(ref state);
for (int i = 0; i < _ArgValue.Count(); i++)
{
if (_RulePrototype._Args[i]._Type == VarType.varVector)
state.RemoveVector(_RulePrototype._Args[i]._Name);
else if (_RulePrototype._Args[i]._Type == VarType.varFloat)
state.RemoveFloat(_RulePrototype._Args[i]._Name);
}
state._Recursions++;
}
}
public void Execute(ref WooState state)
{
Vector3 colourVec = _ColourExpr.EvaluateVector(ref state);
Colour colour = new Colour(colourVec.x, colourVec.y, colourVec.z);
Vector3 position = _PositionExpr.EvaluateVector(ref state);
PointLight pointLight = new PointLight(colour, position);
pointLight.CreateElement(state._Parent, position);
}
public void Execute(ref WooState state)
{
Vector3 colourVec = _ColourExpr.EvaluateVector(ref state);
Colour colour = new Colour(colourVec.x, colourVec.y, colourVec.z);
double samples = _SamplesExpr.EvaluateFloat(ref state);
if (samples < 1) samples = 1;
WorldLight worldLight = new WorldLight(colour, (int)samples);
worldLight.CreateElement(state._Parent, new Vector3(0, 0, 0));
}
public void Execute(ref WooState state)
{
Vector3 colourVec = _ColourExpr.EvaluateVector(ref state);
Colour colour = new Colour(colourVec.x, colourVec.y, colourVec.z);
Background background = new Background();
background._BackgroundColour = colour;
background._Simple = true;
background.CreateElement(state._Parent);
}
public Vector3 EvaluateVector(ref WooState state)
{
return new Vector3(_XExpr.EvaluateFloat(ref state),
_YExpr.EvaluateFloat(ref state),
_ZExpr.EvaluateFloat(ref state));
}
public Vector3 EvaluateVector(ref WooState state)
{
Vector3 arg = _Arg.EvaluateVector(ref state);
arg.Normalise();
return arg;
}
public void Execute(ref WooState state)
{
state._MengerPattern = _Pattern;
}
public void CreateElement(bool preview, XElement parent)
{
if (!_ParseSuccessful)
return;
try
{
foreach (Rule r in _Rules)
{
if (r._Name.Equals("main", StringComparison.InvariantCultureIgnoreCase))
{
WooState state = new WooState();
state._Rules = _Rules;
state._Shaders = _Shaders;
state._Random = new Random(10);//_Seed);
state._Parent = parent;
state._Preview = preview;
r.Execute(ref state);
}
}
}
catch (EvaluateException e)
{
MessageBox.Show(e._WooMessage);
}
}
public void Execute(ref WooState state)
{
state._MaterialFunction = state.GetShader(_MaterialFunction).Evaluate(state);
}
public virtual void Execute(ref WooState state)
{
block.Execute(ref state);
}
protected Material GenerateMaterial(WooState state)
{
Material ret = new Material();
ret._DiffuseColour = state._Diff;
ret._Reflectivity = state._Refl;
ret._EmissiveColour = state._Emi;
ret._SpecularColour = state._Spec;
ret._AbsorptionColour = state._Abs;
ret._Opacity = (float)state._Opacity;
ret._Density = (float)state._Density;
ret._TintDensity = (float)state._TintDensity;
ret._RefractiveIndex = (float)state._RefractiveIndex;
ret._SpecularPower = (float)state._Power;
ret._Shininess = (float)state._Gloss;
ret._MaterialFunction = state._MaterialFunction;
return ret;
}
public void ExecuteFloat(ref WooState state, string varName, Expression expression)
{
double value = expression.EvaluateFloat(ref state);
double current = state.GetValueFloat(varName);
state.SetValue(varName, value + current);
}
public double EvaluateFloat(ref WooState state)
{
return Math.Sqrt(_Expr.EvaluateFloat(ref state));
}
public double EvaluateFloat(ref WooState state)
{
return Math.Sin(2 * Math.PI * _Expr.EvaluateFloat(ref state) / 360);
}
