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 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 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) { 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 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) { //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) { 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); 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 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 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); }