├── GrammarGen ├── Grammars │ ├── AcaciaTree │ ├── City │ ├── ConiferTree │ ├── Dragon │ ├── Features │ ├── HilbertCollision │ ├── LevyC │ ├── Mondrian │ ├── OakTree │ ├── PoplarTree │ ├── Sierpinski │ ├── SimpleBranching │ ├── TABOPF124A │ ├── TABOPF124AP │ ├── TABOPF124B │ ├── TABOPF124C │ ├── TABOPF124CS │ ├── TABOPF124CV │ ├── Wikipedia │ └── Willow ├── Parser ├── Resources │ ├── ArraysStub │ ├── BootstrapStub │ ├── Common.rb │ ├── DistTerminalStub │ ├── ExportStub │ ├── Expression.treetop │ ├── Grammar.rb │ ├── LSystem.treetop │ ├── Parser.rb │ ├── Primitives.treetop │ └── SymbolStub └── Source │ ├── AmpersandSymbol.hpp │ ├── BackSlashSymbol.hpp │ ├── BuildingMesh.hpp │ ├── CaretSymbol.hpp │ ├── Distributions.hpp │ ├── ExclamationSymbol.hpp │ ├── ForwardSlashSymbol.hpp │ ├── LeftBracketSymbol.hpp │ ├── MinusSymbol.hpp │ ├── PipeSymbol.hpp │ ├── PlusSymbol.hpp │ ├── RightBracketSymbol.hpp │ ├── TABOPF124CS │ ├── Arrays.hpp │ ├── CSymbol.hpp │ ├── FSymbol.hpp │ ├── TABOPF124CS.cpp │ └── TABOPF124CS.pro │ └── Willow │ ├── ASymbol.hpp │ ├── Arrays.hpp │ ├── BackSlash_0Symbol.hpp │ ├── BackSlash_10Symbol.hpp │ ├── BackSlash_11Symbol.hpp │ ├── BackSlash_12Symbol.hpp │ ├── BackSlash_13Symbol.hpp │ ├── BackSlash_14Symbol.hpp │ ├── BackSlash_15Symbol.hpp │ ├── BackSlash_16Symbol.hpp │ ├── BackSlash_17Symbol.hpp │ ├── BackSlash_18Symbol.hpp │ ├── BackSlash_19Symbol.hpp │ ├── BackSlash_1Symbol.hpp │ ├── BackSlash_2Symbol.hpp │ ├── BackSlash_3Symbol.hpp │ ├── BackSlash_4Symbol.hpp │ ├── BackSlash_5Symbol.hpp │ ├── BackSlash_6Symbol.hpp │ ├── BackSlash_7Symbol.hpp │ ├── BackSlash_8Symbol.hpp │ ├── BackSlash_9Symbol.hpp │ ├── CSymbol.hpp │ ├── ColorSymbol.hpp │ ├── ESymbol.hpp │ ├── EtrunkSymbol.hpp │ ├── LSymbol.hpp │ ├── LeafSymbol.hpp │ ├── LeafconnectorSymbol.hpp │ ├── LnoneSymbol.hpp │ ├── Local │ ├── VectorT.hpp │ ├── Width.cpp │ └── Width.hpp │ ├── MSymbol.hpp │ ├── Minus_0Symbol.hpp │ ├── Minus_10Symbol.hpp │ ├── Minus_1Symbol.hpp │ ├── Minus_2Symbol.hpp │ ├── Minus_3Symbol.hpp │ ├── Minus_4Symbol.hpp │ ├── Minus_5Symbol.hpp │ ├── Minus_6Symbol.hpp │ ├── Minus_7Symbol.hpp │ ├── Minus_8Symbol.hpp │ ├── Minus_9Symbol.hpp │ ├── Plus_0Symbol.hpp │ ├── Plus_10Symbol.hpp │ ├── Plus_11Symbol.hpp │ ├── Plus_12Symbol.hpp │ ├── Plus_13Symbol.hpp │ ├── Plus_1Symbol.hpp │ ├── Plus_2Symbol.hpp │ ├── Plus_3Symbol.hpp │ ├── Plus_4Symbol.hpp │ ├── Plus_5Symbol.hpp │ ├── Plus_6Symbol.hpp │ ├── Plus_7Symbol.hpp │ ├── Plus_8Symbol.hpp │ ├── Plus_9Symbol.hpp │ ├── PolygonSymbol.hpp │ ├── StemSymbol.hpp │ ├── Stem_0Symbol.hpp │ ├── Stem_10Symbol.hpp │ ├── Stem_11Symbol.hpp │ ├── Stem_12Symbol.hpp │ ├── Stem_13Symbol.hpp │ ├── Stem_1Symbol.hpp │ ├── Stem_2Symbol.hpp │ ├── Stem_3Symbol.hpp │ ├── Stem_4Symbol.hpp │ ├── Stem_5Symbol.hpp │ ├── Stem_6Symbol.hpp │ ├── Stem_7Symbol.hpp │ ├── Stem_8Symbol.hpp │ ├── Stem_9Symbol.hpp │ ├── TSymbol.hpp │ ├── TurnperptovecSymbol.hpp │ ├── TurntovecSymbol.hpp │ ├── TurnupSymbol.hpp │ ├── TurnztovecSymbol.hpp │ ├── WidthSymbol.hpp │ └── Willow.cpp ├── ProcModeler ├── Bootstrap └── src │ ├── Main.cpp │ ├── ModelRenderWidget.cpp │ ├── ModelRenderWidget.hpp │ ├── ModelSimulation.cpp │ ├── ModelSimulation.hpp │ ├── ModelWindow.cpp │ ├── ModelWindow.hpp │ ├── SketchBasedProceduralModel.cpp │ ├── SketchBasedProceduralModel.hpp │ ├── SketchingWidget.cpp │ └── SketchingWidget.hpp ├── README.md └── libProcModel ├── Bootstrap └── src ├── BBoxHelper.cpp ├── BBoxHelper.hpp ├── Common.hpp ├── DerivationTree.cpp ├── DerivationTree.hpp ├── GrammarPlugin.cpp ├── GrammarPlugin.hpp ├── Math.hpp ├── Mesh.cpp ├── Mesh.hpp ├── ProceduralModel.cpp ├── ProceduralModel.hpp ├── Production.hpp ├── ResourceHandler.cpp ├── ResourceHandler.hpp ├── Symbol.hpp ├── SymbolEntry.hpp └── SymbolStringIterator.hpp /GrammarGen/Grammars/Dragon: -------------------------------------------------------------------------------- 1 | Axiom: F(1)X; 2 | DerivationLength: 20; 3 | X -> X+(90)YF(1); 4 | Y -> F(1)X-(90)Y; -------------------------------------------------------------------------------- /GrammarGen/Grammars/Features: -------------------------------------------------------------------------------- 1 | // A Modification of a grammar from The Algorithmic Beauty of Plants 2 | 3 | #define initial_angle 11.0 4 | #define falloff_factor 0.5 5 | #define initial_level 0 6 | #define max_levels 6 7 | 8 | // An array 9 | @array = {1,2,3.5,7,10}; 10 | 11 | // The depth limit 12 | 13 | DerivationLength: 6; 14 | 15 | // The axiom 16 | 17 | Axiom: A(initial_level, initial_angle); 18 | 19 | // The productions 20 | // 21 | // Here, C takes three parameters: a length, and then RGB values for the segment it draws. 22 | // It's render method should look like the following: 23 | // 24 | // glColor3f(params[1],params[2],params[3]); 25 | // glBegin(GL_LINES); glVertex3f(0,0,0); glVertex3f(0,params[0],0); glEnd(); 26 | // glColor3f(1,1,1); 27 | // 28 | 29 | A(level, angle) <1-level/max_levels> -> 30 | A(level, angle) [ +(angle) C(UniformSample(0,level),level/max_levels,0,0) +(angle) A(level+1, falloff_factor*angle) ] 31 | A(level, angle) [ -(angle) C(UniformSample(0,level),0,level/max_levels,0) -(angle) A(level+1, falloff_factor*angle) ] 32 | A(level, angle) F(1) G(1,2); 33 | 34 | F(a) -> F(a)F(a); 35 | 36 | A(level, angle) -> C(UniformSample(0,level),0,0,1); 37 | 38 | G(a,b) : a+b>=0 && a+1<10 -> F(@array{a/2+1}); 39 | G(a,b) : a-b>=0 && b+1<5 -> F(@array{a/2+1}); -------------------------------------------------------------------------------- /GrammarGen/Grammars/HilbertCollision: -------------------------------------------------------------------------------- 1 | // Hilbert Curve 2 | 3 | #define la1 UniformSample(85,95) 4 | #define la2 UniformSample(265,275) 5 | #define la3 UniformSample(265,275) 6 | #define la4 UniformSample(85,95) 7 | 8 | #define ra1 UniformSample(265,275) 9 | #define ra2 UniformSample(85,95) 10 | #define ra3 UniformSample(85,95) 11 | #define ra4 UniformSample(265,275) 12 | 13 | #define aa 270 14 | #define steps 10 15 | 16 | DerivationLength: 10; 17 | Axiom : Collisioninit(-1,-1,1,1,1,1,1)+(aa)L(0); 18 | 19 | Collisioninit(minx,miny,maxx,maxy,sizex,sizey,n) -> Collisioninit(-2*n-2, -2*n-2, 2*n+2, 2*n + 2, 2*n+1, 2*n+1, 2*n+1); 20 | 21 | //L(n) < n/steps > -> S(1); 22 | L(n) < 1 - n / steps > -> +(la1)R(n+1)Line(1) +(la2)L(n+1)Line(1)L(n+1) +(la3)Line(1)R(n+1) +(la4); 23 | 24 | //R(n) < n/steps > -> S(1); 25 | 26 | R(n) < 1 - n/steps> -> +(ra1)L(n+1)Line(1) +(ra2)R(n+1)Line(1)R(n+1) +(ra3)Line(1)L(n+1) +(ra4); 27 | 28 | S(n) -> S(2*n+1); 29 | -------------------------------------------------------------------------------- /GrammarGen/Grammars/LevyC: -------------------------------------------------------------------------------- 1 | Axiom : F(1); 2 | DerivationLength: 10; 3 | F(a)->+(45)F(a)-(45)-(45)F(a)+(45); -------------------------------------------------------------------------------- /GrammarGen/Grammars/Mondrian: -------------------------------------------------------------------------------- 1 | 2 | // Macros defining rules: 3 | 4 | // Symbol stores: size x, y, n (subdivision) 5 | 6 | 7 | /////////////////////////////////////////////////////////////////////////////////////// 8 | 9 | DerivationLength: 30; 10 | Axiom : Color(1,1,1) Rect(10,10,6); 11 | 12 | /////////////////////////////////////////////////////////////////////////////////////// 13 | 14 | #define ChooseSplitRatio(prob,ratio) \ 15 | Rect1(x,y,n,type) -> Rect2(x,y,n,type,ratio) 16 | 17 | 18 | //ChooseSplitRatio(1/36,1/12); 19 | ChooseSplitRatio(1/36,1/10); 20 | //ChooseSplitRatio(1/24,1/7); 21 | ChooseSplitRatio(1/18,1/5); 22 | //ChooseSplitRatio(1/12,1/3); 23 | //ChooseSplitRatio(1/10,2/5); 24 | ChooseSplitRatio(1/8,1/2); 25 | ChooseSplitRatio(1/10,3/5); 26 | //ChooseSplitRatio(1/12,2/3); 27 | //ChooseSplitRatio(1/18,4/5); 28 | //ChooseSplitRatio(1/24,6/7); 29 | ChooseSplitRatio(1/24,1/1); 30 | 31 | // choose the split or color 32 | Rect(x,y,n) <0.4> : n > 0 && y > x/5 -> Rect1(x,y,n-1,1); // vertical 33 | Rect(x,y,n) <0.4> : n > 0 && x > y/5 -> Rect1(x,y,n-1,2); // horizontal 34 | 35 | Rect(x,y,n) <0.2> -> C(x,y); 36 | 37 | C(x,y) <1/2> -> Coloredrect(1,1,1,x,y); // white 38 | C(x,y) <1/18> -> Coloredrect(1,1,0,x,y); // yellow 39 | C(x,y) <1/18> -> Coloredrect(1,0,0,x,y); // red 40 | C(x,y) <1/18> -> Coloredrect(0,0,1,x,y); // blue 41 | //C(x,y) <1/24> -> Coloredrect(0.5,0.5,0.5,x,y); // grey 42 | C(x,y) <1/36> -> Coloredrect(0.1,0.1,0.1,x,y); // black 43 | 44 | 45 | // no split for ratio 1 46 | Rect2(x,y,n,type,ratio) : ratio == 1 -> Rect(x,y,n); 47 | 48 | // vertical split 49 | Rect2(x,y,n,type,ratio) : type == 1 && ratio < 1 -> [Rect(x,y*ratio,n)] Movexy(0,y*ratio) Rect(x,y*(1-ratio),n); 50 | 51 | // horizontal split 52 | Rect2(x,y,n,type,ratio) : type == 2 && ratio < 1 -> [Rect(x*ratio,y,n)] Movexy(x*ratio,0) Rect(x*(1-ratio),y,n); 53 | -------------------------------------------------------------------------------- /GrammarGen/Grammars/Sierpinski: -------------------------------------------------------------------------------- 1 | Axiom: F(1)XF(1)-(60)-(60)F(1)F(1)-(60)-(60)F(1)F(1); 2 | DerivationLength: 9; 3 | F(a) -> F(1)F(1); 4 | X -> -(60)-(60)F(1)XF(1)+(60)+(60)F(1)XF(1)+(60)+(60)F(1)XF(1)-(60)-(60); -------------------------------------------------------------------------------- /GrammarGen/Grammars/SimpleBranching: -------------------------------------------------------------------------------- 1 | #define angle_left 35 2 | #define angle_right 35 3 | #define max_levels 50 4 | 5 | DerivationLength: 50; 6 | 7 | Axiom : A(1); 8 | 9 | A(n) < 1/n > -> [-(angle_left) F(1) A(n+1)] +(angle_right) F(1) A(n+1); 10 | A(n) < 1 - 1/n> -> +(angle_left) F(1) A(n+1); 11 | //A(n) < n/max_levels > -> T; 12 | -------------------------------------------------------------------------------- /GrammarGen/Grammars/TABOPF124A: -------------------------------------------------------------------------------- 1 | Axiom : F(1); 2 | 3 | DerivationLength: 5; 4 | 5 | F(a)->F(1)[+F(1)]F(1)[-F(1)]F(1); -------------------------------------------------------------------------------- /GrammarGen/Grammars/TABOPF124AP: -------------------------------------------------------------------------------- 1 | Axiom : F(1); 2 | F(x)->F(0.5*x)[+F(x)]F(x)[-F(x)]F(2.0*x); -------------------------------------------------------------------------------- /GrammarGen/Grammars/TABOPF124B: -------------------------------------------------------------------------------- 1 | Axiom : F(1); 2 | F(a)->F(1)[+F(1)]F(1)[-F(1)][F(1)]; -------------------------------------------------------------------------------- /GrammarGen/Grammars/TABOPF124C: -------------------------------------------------------------------------------- 1 | Axiom : F(1); 2 | F(x)->F(1)F(1)-[-F(1)+F(1)+F(1)]+[+F(1)-F(1)-F(1)]; -------------------------------------------------------------------------------- /GrammarGen/Grammars/TABOPF124CS: -------------------------------------------------------------------------------- 1 | Axiom : F(0); 2 | F(l)<1-l/10>->F(l+1)[-F(l+1)]F(l+1)[+F(l+1)]F(l+1); 3 | F(l)->C; -------------------------------------------------------------------------------- /GrammarGen/Grammars/TABOPF124CV: -------------------------------------------------------------------------------- 1 | Axiom : M(45); 2 | M(a) -> F(1)F(1)-(a)[-(a)M(0.5*a)+(a)M(0.5*a)+(a)M(0.5*a)]+(a)[+(a)M(0.5*a)-(a)M(0.5*a)-(a)M(0.5*a)]; -------------------------------------------------------------------------------- /GrammarGen/Grammars/Wikipedia: -------------------------------------------------------------------------------- 1 | Axiom : X; 2 | X<0.5> -> F(1)+[[X]-X]+F(1)[-F(1)X]+X; 3 | X<0.5> -> F(1)-[[X]+X]+F(1)[+F(1)X]-X; 4 | F(a) -> F(1)F(1); -------------------------------------------------------------------------------- /GrammarGen/Parser: -------------------------------------------------------------------------------- 1 | #!/usr/bin/ruby 2 | 3 | ############################################################# 4 | # Generic path fix # 5 | ############################################################# 6 | $: << File.dirname(__FILE__) 7 | 8 | ############################################################# 9 | # Includes # 10 | ############################################################# 11 | require 'Resources/Parser' 12 | 13 | if ARGV.size < 1 or ARGV.size > 3 then puts "Usage: Parser.rb filename [filename]"; Process.exit; end 14 | 15 | if ARGV.size==1 16 | 17 | fileName = ARGV[0] 18 | 19 | myParser=Parser.new 20 | 21 | myParser.loadGrammarFile(fileName) 22 | myParser.parse 23 | myParser.finalize 24 | myParser.writeFiles 25 | myParser.build 26 | 27 | elsif ARGV.size==2 28 | 29 | oldFileName = ARGV[0] 30 | newFileName = ARGV[1] 31 | 32 | oldParser = Parser.new 33 | newParser = Parser.new 34 | 35 | oldParser.loadGrammarFile(oldFileName) 36 | oldParser.parse 37 | oldGrammar = oldParser.grammar 38 | oldTerminals = oldGrammar.terminals 39 | oldSymbolHash = oldGrammar.symbolHash 40 | 41 | newParser.loadGrammarFile(newFileName) 42 | newParser.parse 43 | newGrammar = newParser.grammar 44 | newTerminals = newGrammar.terminals 45 | newNonTerminals = newGrammar.nonTerminals 46 | newSymbolHash = newGrammar.symbolHash 47 | 48 | transformedTerminals = oldParser.grammar.terminals & newParser.grammar.nonTerminals 49 | addedTerminals = newTerminals - oldTerminals 50 | 51 | transformedTerminals.each do |symbol,numParams| 52 | safeToIncrement = false 53 | oldTerminals.each do |s,numP| 54 | if safeToIncrement and newTerminals.member?([s,numP]) then 55 | oldValue = newSymbolHash[s] 56 | newSymbolHash[s] = oldValue + 1 57 | end 58 | if symbol == s then safeToIncrement = true end 59 | end 60 | 61 | addedTerminals.each do |s,numP| 62 | oldValue = newSymbolHash[s] 63 | newSymbolHash[s] = oldValue + oldTerminals.size 64 | end 65 | 66 | newSymbolHash[symbol]=oldSymbolHash[symbol] 67 | end 68 | 69 | newParser.finalize 70 | newParser.writeFiles(oldParser.fileName+newParser.fileName) 71 | newParser.build 72 | end 73 | -------------------------------------------------------------------------------- /GrammarGen/Resources/ArraysStub: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _ARRAYS_HPP_ 6 | #define _ARRAYS_HPP_ 7 | 8 | namespace ProceduralModeling{ 9 | 10 | namespace Arrays{ 11 | 12 | %ARRAYS% 13 | 14 | //##################################################################### 15 | } // namespace Arrays 16 | 17 | //##################################################################### 18 | } // namespace ProceduralModeling 19 | 20 | #endif //_ARRAYS_HPP_ -------------------------------------------------------------------------------- /GrammarGen/Resources/Common.rb: -------------------------------------------------------------------------------- 1 | class Distribution 2 | 3 | attr_accessor :name, :boundsArray 4 | 5 | def initialize(name,boundsArray) 6 | @name = name 7 | @boundsArray = boundsArray 8 | end 9 | 10 | end 11 | 12 | class ParamArray 13 | 14 | attr_accessor :name, :indexExpression 15 | 16 | def initialize(name,indexExpression) 17 | @name = name 18 | @indexExpression = indexExpression 19 | end 20 | 21 | end 22 | 23 | class Production 24 | 25 | attr_accessor :predecessor, :conditional, :probability, :successor 26 | 27 | def initialize(predecessor,conditional,probability,successor) 28 | @predecessor=predecessor 29 | @conditional=conditional 30 | @probability=probability 31 | @successor=successor 32 | end 33 | 34 | end 35 | -------------------------------------------------------------------------------- /GrammarGen/Resources/DistTerminalStub: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _%HEADERGUARD%_%EXTENSION%_SYMBOL_HPP_ 6 | #define _%HEADERGUARD%_%EXTENSION%_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "%SYMBOLNAME%Symbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class %SYMBOLNAME%_%EXTENSION%Symbol 15 | //##################################################################### 16 | class %SYMBOLNAME%_%EXTENSION%Symbol : public %SYMBOLNAME%Symbol 17 | { 18 | public: 19 | %SYMBOLNAME%_%EXTENSION%Symbol(Symbol** symbolTable) 20 | :%SYMBOLNAME%Symbol(true,%MAXSYMBOLS%,%MAXSYMBOLENTRIES%,%NUMDIFFUSIONPARAMS%,%NUMFORMALPARAMS%,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | %RENDER% 26 | } 27 | 28 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 29 | { 30 | %PRODUCTIONS% 31 | } 32 | 33 | virtual ushort setFlags(const float* params) const 34 | { 35 | %ISVALID% 36 | } 37 | 38 | virtual float logDiffusionProbability(const float* params) const 39 | { 40 | %LOGPROBABILITY% 41 | } 42 | 43 | virtual void initGraphics() 44 | { 45 | %SYMBOLNAME%Symbol::initGraphics(); 46 | } 47 | 48 | virtual void saveToMesh(const float* params) const 49 | { 50 | %SAVETOMESH% 51 | } 52 | 53 | virtual void voxel(const float* params) const 54 | { 55 | %VOXEL% 56 | } 57 | 58 | virtual const char* symbolName() const 59 | { return "%SYMBOLNAME%_%EXTENSION%"; } 60 | 61 | //##################################################################### 62 | }; 63 | 64 | //##################################################################### 65 | } // namespace ProceduralModeling 66 | 67 | #endif //_%HEADERGUARD%_%EXTENSION%_SYMBOL_HPP_ 68 | -------------------------------------------------------------------------------- /GrammarGen/Resources/Primitives.treetop: -------------------------------------------------------------------------------- 1 | require 'Resources/Common' 2 | 3 | grammar Primitives 4 | 5 | rule variableName 6 | [a-z] [a-z0-9]* ('_' [a-z0-9]+)* 7 | { 8 | def Parsed() text_value end 9 | } 10 | end 11 | 12 | rule arrayName 13 | '@' variableName 14 | { 15 | def Parsed() variableName.text_value end 16 | } 17 | end 18 | 19 | rule symbolName 20 | [A-Z] [a-z0-9]* # Cannot add "_" here if we keep [0-9], for name collision reasons 21 | { 22 | def Parsed() text_value end 23 | } 24 | end 25 | 26 | rule number 27 | ('-'? [1-9] [0-9]* ( '.' [0-9]+ )? / '-'? '0' ('.' [0-9]+)?) 28 | { 29 | def Parsed() text_value end 30 | } 31 | end 32 | 33 | # Make sure to keep these patterns in sync 34 | # with mathSymbols and probDists in the Parser 35 | rule mathSymbol 36 | ('+' / '-' / '*' / '/') 37 | { 38 | def Parsed() text_value end 39 | } 40 | end 41 | 42 | rule comparisonOperator 43 | ('<=' / '>=' / '==' / '!=' / '>' / '<') 44 | { 45 | def Parsed() text_value end 46 | } 47 | end 48 | 49 | rule binaryBooleanOperator 50 | ('&&' / '||' / '^') 51 | { 52 | def Parsed() text_value end 53 | } 54 | end 55 | 56 | rule unaryBooleanOperator 57 | '!' 58 | { 59 | def Parsed() text_value end 60 | } 61 | end 62 | 63 | rule booleanLiteral 64 | ('true' / 'false') 65 | { 66 | def Parsed() text_value end 67 | } 68 | end 69 | 70 | rule mathFunction 71 | ('abs' / 'acos' / 'asin' / 'atan' / 'ceil' / 'cos' / 'cosh' / 'exp' / 'fabs' / 'floor' / 'log' / 'log10' / 'sin' / 'sinh' / 'sqrt' / 'tan' / 'tanh') 72 | { 73 | def Parsed() text_value end 74 | } 75 | end 76 | 77 | rule probDist 78 | distName:('NormalSample' / 'UniformSample') '(' ws* firstParam:(probExpression) ws* ',' ws* secondParam:(probExpression) ws* ')' 79 | { 80 | def Parsed() [ Distribution.new(distName.text_value, [firstParam.Parsed, secondParam.Parsed]) ] end 81 | } 82 | end 83 | 84 | # Make sure to keep this pattern in sync 85 | # with turtleSymbols in the Parser 86 | rule turtleSymbol 87 | ws* symbol:('+' / '-' / '&' / '^' / '\\' / '/' / '!') '(' ws* probExpression ws* ')' ws* 88 | { 89 | def Parsed() [symbol.text_value, [ probExpression.Parsed ]] end 90 | } 91 | / ws* ('+' / '-' / '&' / '^' / '\\' / '/' / '!') ws* 92 | { 93 | def Parsed() [text_value, [ ['22.5'] ]] end 94 | } 95 | / ws* '|' ws* 96 | { 97 | def Parsed() [text_value, []] end 98 | } 99 | end 100 | 101 | rule ws 102 | [ \r\t\n] 103 | end 104 | 105 | end 106 | -------------------------------------------------------------------------------- /GrammarGen/Resources/SymbolStub: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _%HEADERGUARD%_SYMBOL_HPP_ 6 | #define _%HEADERGUARD%_SYMBOL_HPP_ 7 | 8 | #include "Arrays.hpp" 9 | #include "Distributions.hpp" 10 | #include "Symbol.hpp" 11 | %INCLUDES% 12 | namespace ProceduralModeling{ 13 | 14 | //##################################################################### 15 | // Class %SYMBOLNAME%Symbol 16 | //##################################################################### 17 | class %SYMBOLNAME%Symbol : public Symbol 18 | { 19 | public: 20 | %SYMBOLNAME%Symbol(Symbol** symbolTable) 21 | :Symbol(%TERMINAL%,%MAXSYMBOLS%,%MAXSYMBOLENTRIES%,0,%NUMFORMALPARAMS%,symbolTable) 22 | {} 23 | 24 | %SYMBOLNAME%Symbol(const bool isTerminal,const uint maxNumSymbols,const uint maxNumSymbolEntries,const uint numDiffusionParams,const uint numFormalParams,Symbol** symbolTable) 25 | :Symbol(isTerminal,maxNumSymbols,maxNumSymbolEntries,numDiffusionParams,numFormalParams,symbolTable) 26 | {} 27 | 28 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 29 | { 30 | %PRODUCTIONS% 31 | } 32 | 33 | virtual ushort setFlags(const float* params) const 34 | { 35 | %ISVALID% 36 | } 37 | 38 | virtual void render(const float* params) const 39 | { 40 | %RENDER% 41 | } 42 | 43 | virtual void initGraphics() 44 | { 45 | %INITGRAPHICS% 46 | } 47 | 48 | virtual void saveToMesh(const float* params) const 49 | { 50 | %SAVETOMESH% 51 | } 52 | 53 | virtual void voxel(const float* params) const 54 | { 55 | %VOXEL% 56 | } 57 | 58 | virtual const char* symbolName() const 59 | { return "%SYMBOLNAME%"; } 60 | 61 | //##################################################################### 62 | }; 63 | 64 | //##################################################################### 65 | } // namespace ProceduralModeling 66 | 67 | #endif //_%HEADERGUARD%_SYMBOL_HPP_ 68 | -------------------------------------------------------------------------------- /GrammarGen/Source/AmpersandSymbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _AMPERSAND_SYMBOL_HPP_ 6 | #define _AMPERSAND_SYMBOL_HPP_ 7 | 8 | #include "Symbol.hpp" 9 | 10 | namespace ProceduralModeling{ 11 | 12 | //##################################################################### 13 | // Class AmpersandSymbol 14 | //##################################################################### 15 | class AmpersandSymbol : public Symbol 16 | { 17 | public: 18 | AmpersandSymbol(Symbol** symbolTable) 19 | :Symbol(true,1,2,0,1,symbolTable) 20 | {} 21 | 22 | AmpersandSymbol(const bool isTerminal,const uint maxNumSymbols,const uint maxNumSymbolEntries,const uint numDiffusionParams,const uint numFormalParams,Symbol** symbolTable) 23 | :Symbol(isTerminal,maxNumSymbols,maxNumSymbolEntries,numDiffusionParams,numFormalParams,symbolTable) 24 | {} 25 | 26 | virtual void render(const float* params) const 27 | { 28 | glRotatef(-params[0],1,0,0); 29 | } 30 | 31 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 32 | { 33 | output[0].mID=4; 34 | output[1].mParam=input[0].mParam; 35 | logProbability=0; 36 | return 2; 37 | } 38 | 39 | virtual ushort setFlags(const float* params) const 40 | { 41 | return SymbolEntry::DETERMINISTIC; 42 | } 43 | 44 | virtual void saveToMesh(const float* params) const 45 | { 46 | mResourceHandler->getOutputMesh()->curDirTrans().rotate(-params[0],1,0,0); 47 | } 48 | 49 | virtual const char* symbolName() const 50 | { return "&"; } 51 | 52 | //##################################################################### 53 | }; 54 | 55 | //##################################################################### 56 | } // namespace ProceduralModeling 57 | 58 | #endif //_AMPERSAND_SYMBOL_HPP_ 59 | -------------------------------------------------------------------------------- /GrammarGen/Source/BackSlashSymbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _BACK_SLASH_SYMBOL_HPP_ 6 | #define _BACK_SLASH_SYMBOL_HPP_ 7 | 8 | #include "Symbol.hpp" 9 | 10 | namespace ProceduralModeling{ 11 | 12 | //##################################################################### 13 | // Class BackSlashSymbol 14 | //##################################################################### 15 | class BackSlashSymbol : public Symbol 16 | { 17 | public: 18 | BackSlashSymbol(Symbol** symbolTable) 19 | :Symbol(true,1,2,0,1,symbolTable) 20 | {} 21 | 22 | BackSlashSymbol(const bool isTerminal,const uint maxNumSymbols,const uint maxNumSymbolEntries,const uint numDiffusionParams,const uint numFormalParams,Symbol** symbolTable) 23 | :Symbol(isTerminal,maxNumSymbols,maxNumSymbolEntries,numDiffusionParams,numFormalParams,symbolTable) 24 | {} 25 | 26 | virtual void render(const float* params) const 27 | { 28 | glRotatef(-params[0],0,1,0); 29 | } 30 | 31 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 32 | { 33 | output[0].mID=6; 34 | output[1].mParam=input[0].mParam; 35 | logProbability=0; 36 | return 2; 37 | } 38 | 39 | virtual ushort setFlags(const float* params) const 40 | { 41 | return SymbolEntry::DETERMINISTIC; 42 | } 43 | 44 | virtual void saveToMesh(const float* params) const 45 | { 46 | mResourceHandler->getOutputMesh()->curDirTrans().rotate(-params[0], 0, 1, 0); 47 | } 48 | 49 | virtual const char* symbolName() const 50 | { return "\\"; } 51 | 52 | //##################################################################### 53 | }; 54 | 55 | //##################################################################### 56 | } // namespace ProceduralModeling 57 | 58 | #endif //_BACK_SLASH_SYMBOL_HPP_ 59 | -------------------------------------------------------------------------------- /GrammarGen/Source/BuildingMesh.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Yu Lou. 3 | //##################################################################### 4 | #ifndef _BUILDING_MESH_HPP_ 5 | #define _BUILDING_MESH_HPP_ 6 | 7 | #include "Mesh.hpp" 8 | 9 | using ProceduralModeling::TriangleMesh; 10 | using ProceduralModeling::GLMaterial; 11 | using ProceduralModeling::UseMat; 12 | using ProceduralModeling::SubMesh; 13 | 14 | struct SubObj 15 | { 16 | QVector mTransformation; 17 | TriangleMesh* mMesh; 18 | QString mName; 19 | }; 20 | 21 | struct Wall 22 | { 23 | QVector3D mNormal; 24 | QVector3D mPosition[4]; 25 | }; 26 | 27 | struct Rooftop 28 | { 29 | // QVector3D mNormal; 30 | // QVector3D mPosition[4]; 31 | // z-1, z+1, x-1, x+1 32 | bool side[4]; 33 | QVector3D bottomPos[4]; 34 | QVector3D topPos[4]; 35 | }; 36 | 37 | class BuildingMesh : public TriangleMesh 38 | { 39 | protected: 40 | bool mEnableSaveToMesh; 41 | QStack mMatrixState; 42 | QVector mSubObject; 43 | QVector mWalls; 44 | int*** mInternal; 45 | int mGrids[16][16][16]; 46 | 47 | public: 48 | BuildingMesh():mInternal(NULL){} 49 | ~BuildingMesh() { } 50 | void init(); 51 | void initInternal(const QString& path, int w, int h, int d); 52 | bool internalPart(float x, float y, float z); 53 | void processRoofs(QVector& rooftops) const; 54 | void addObj(TriangleMesh* mesh, const QString& name); 55 | void addWall(float p1, float p2); 56 | void addRooftop(float p1, float p2, float offset); 57 | void pushState(); 58 | void popState(); 59 | QMatrix4x4& curDirTrans(); 60 | void saveToObjFile(const QString& path) const; 61 | }; 62 | 63 | #endif 64 | -------------------------------------------------------------------------------- /GrammarGen/Source/CaretSymbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _CARET_SYMBOL_HPP_ 6 | #define _CARET_SYMBOL_HPP_ 7 | 8 | #include "Symbol.hpp" 9 | 10 | namespace ProceduralModeling{ 11 | 12 | //##################################################################### 13 | // Class CaretSymbol 14 | //##################################################################### 15 | class CaretSymbol : public Symbol 16 | { 17 | public: 18 | CaretSymbol(Symbol** symbolTable) 19 | :Symbol(true,1,2,0,1,symbolTable) 20 | {} 21 | 22 | CaretSymbol(const bool isTerminal,const uint maxNumSymbols,const uint maxNumSymbolEntries,const uint numDiffusionParams,const uint numFormalParams,Symbol** symbolTable) 23 | :Symbol(isTerminal,maxNumSymbols,maxNumSymbolEntries,numDiffusionParams,numFormalParams,symbolTable) 24 | {} 25 | 26 | virtual void render(const float* params) const 27 | { 28 | glRotatef(params[0],1,0,0); 29 | } 30 | 31 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 32 | { 33 | output[0].mID=5; 34 | output[1].mParam=input[0].mParam; 35 | logProbability=0; 36 | return 2; 37 | } 38 | 39 | virtual ushort setFlags(const float* params) const 40 | { 41 | return SymbolEntry::DETERMINISTIC; 42 | } 43 | 44 | virtual void saveToMesh(const float* params) const 45 | { 46 | mResourceHandler->getOutputMesh()->curDirTrans().rotate(params[0],1,0,0); 47 | } 48 | 49 | virtual const char* symbolName() const 50 | { return "^"; } 51 | 52 | //##################################################################### 53 | }; 54 | 55 | //##################################################################### 56 | } // namespace ProceduralModeling 57 | 58 | #endif //_CARET_SYMBOL_HPP_ 59 | -------------------------------------------------------------------------------- /GrammarGen/Source/Distributions.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _DISTRIBUTIONS_HPP_ 6 | #define _DISTRIBUTIONS_HPP_ 7 | 8 | #include "Common.hpp" 9 | #include "Math.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class Distributions 15 | //##################################################################### 16 | class Distributions 17 | { 18 | public: 19 | static float UniformSample(const float min,const float max,const float sample) 20 | { assert(min<=max); return min+sample*(max-min); } 21 | 22 | static float NormalSample(const float mean,const float variance,const float sampleOne,const float sampleTwo) 23 | { assert(variance>=0); return mean+sqrt(variance)*sqrt(-2*log(sampleOne))*cos(TWO_PI*sampleTwo); } 24 | 25 | static float UniformEval(const float min,const float max,const float sample) 26 | { assert(min!=max); return 1/(max-min); } 27 | 28 | static float NormalEval(const float mean,const float variance,const float sampleOne,const float sampleTwo) 29 | { assert(variance>=0); return pow(sampleOne,Math::sqr(cos(2*M_PI*sampleTwo)))/(SQRT_TWO_PI*sqrt(variance)); } 30 | 31 | //##################################################################### 32 | }; 33 | 34 | //##################################################################### 35 | } // namespace ProceduralModeling 36 | 37 | #endif //_DISTRIBUTIONS_HPP_ 38 | -------------------------------------------------------------------------------- /GrammarGen/Source/ExclamationSymbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _EXCLAMATION_SYMBOL_HPP_ 6 | #define _EXCLAMATION_SYMBOL_HPP_ 7 | 8 | #include "Symbol.hpp" 9 | 10 | namespace ProceduralModeling{ 11 | 12 | //##################################################################### 13 | // Class ExclamationSymbol 14 | //##################################################################### 15 | class ExclamationSymbol : public Symbol 16 | { 17 | public: 18 | ExclamationSymbol(Symbol** symbolTable) 19 | :Symbol(true,1,2,0,1,symbolTable) 20 | {} 21 | 22 | ExclamationSymbol(const bool isTerminal,const uint maxNumSymbols,const uint maxNumSymbolEntries,const uint numDiffusionParams,const uint numFormalParams,Symbol** symbolTable) 23 | :Symbol(isTerminal,maxNumSymbols,maxNumSymbolEntries,numDiffusionParams,numFormalParams,symbolTable) 24 | {} 25 | 26 | virtual void render(const float* params) const 27 | { 28 | glLineWidth(params[0]); 29 | } 30 | 31 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 32 | { 33 | output[0].mID=9; 34 | output[1].mParam=input[0].mParam; 35 | logProbability=0; 36 | return 2; 37 | } 38 | 39 | virtual ushort setFlags(const float* params) const 40 | { 41 | return SymbolEntry::DETERMINISTIC; 42 | } 43 | 44 | virtual const char* symbolName() const 45 | { return "!"; } 46 | 47 | //##################################################################### 48 | }; 49 | 50 | //##################################################################### 51 | } // namespace ProceduralModeling 52 | 53 | #endif //_EXCLAMATION_SYMBOL_HPP_ 54 | -------------------------------------------------------------------------------- /GrammarGen/Source/ForwardSlashSymbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _FORWARD_SLASH_SYMBOL_HPP_ 6 | #define _FORWARD_SLASH_SYMBOL_HPP_ 7 | 8 | #include "Symbol.hpp" 9 | 10 | namespace ProceduralModeling{ 11 | 12 | //##################################################################### 13 | // Class ForwardSlashSymbol 14 | //##################################################################### 15 | class ForwardSlashSymbol : public Symbol 16 | { 17 | public: 18 | ForwardSlashSymbol(Symbol** symbolTable) 19 | :Symbol(true,1,2,0,1,symbolTable) 20 | {} 21 | 22 | ForwardSlashSymbol(const bool isTerminal,const uint maxNumSymbols,const uint maxNumSymbolEntries,const uint numDiffusionParams,const uint numFormalParams,Symbol** symbolTable) 23 | :Symbol(isTerminal,maxNumSymbols,maxNumSymbolEntries,numDiffusionParams,numFormalParams,symbolTable) 24 | {} 25 | 26 | virtual void render(const float* params) const 27 | { 28 | glRotatef(params[0],0,1,0); 29 | } 30 | 31 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 32 | { 33 | output[0].mID=7; 34 | output[1].mParam=input[0].mParam; 35 | logProbability=0; 36 | return 2; 37 | } 38 | 39 | virtual ushort setFlags(const float* params) const 40 | { 41 | return SymbolEntry::DETERMINISTIC; 42 | } 43 | 44 | virtual void saveToMesh(const float* params) const 45 | { 46 | mResourceHandler->getOutputMesh()->curDirTrans().rotate(params[0],0,1,0); 47 | } 48 | 49 | virtual const char* symbolName() const 50 | { return "/"; } 51 | 52 | //##################################################################### 53 | }; 54 | 55 | //##################################################################### 56 | } // namespace ProceduralModeling 57 | 58 | #endif //_FORWARD_SLASH_SYMBOL_HPP_ 59 | -------------------------------------------------------------------------------- /GrammarGen/Source/LeftBracketSymbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _LEFT_BRACKET_SYMBOL_HPP_ 6 | #define _LEFT_BRACKET_SYMBOL_HPP_ 7 | 8 | #include "Symbol.hpp" 9 | 10 | namespace ProceduralModeling{ 11 | 12 | //##################################################################### 13 | // Class LeftBracketSymbol 14 | //##################################################################### 15 | class LeftBracketSymbol : public Symbol 16 | { 17 | public: 18 | LeftBracketSymbol(Symbol** symbolTable) 19 | :Symbol(true,1,1,0,0,symbolTable) 20 | {} 21 | 22 | LeftBracketSymbol(const bool isTerminal,const uint maxNumSymbols,const uint maxNumSymbolEntries,const uint numDiffusionParams,const uint numFormalParams,Symbol** symbolTable) 23 | :Symbol(isTerminal,maxNumSymbols,maxNumSymbolEntries,numDiffusionParams,numFormalParams,symbolTable) 24 | {} 25 | 26 | virtual void render(const float* params) const 27 | { 28 | glPushMatrix(); 29 | } 30 | 31 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 32 | { 33 | output[0].mID=0; 34 | logProbability=0; 35 | return 1; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual void saveToMesh(const float* params) const 44 | { 45 | mResourceHandler->getOutputMesh()->pushState(); 46 | } 47 | 48 | virtual void voxel(const float* params) const 49 | { 50 | mResourceHandler->pushBBoxMatrix(); 51 | } 52 | 53 | virtual const char* symbolName() const 54 | { return "["; } 55 | 56 | //##################################################################### 57 | }; 58 | 59 | //##################################################################### 60 | } // namespace ProceduralModeling 61 | 62 | #endif //_LEFT_BRACKET_SYMBOL_HPP_ 63 | -------------------------------------------------------------------------------- /GrammarGen/Source/MinusSymbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _MINUS_SYMBOL_HPP_ 6 | #define _MINUS_SYMBOL_HPP_ 7 | 8 | #include "Symbol.hpp" 9 | 10 | namespace ProceduralModeling{ 11 | 12 | //##################################################################### 13 | // Class MinusSymbol 14 | //##################################################################### 15 | class MinusSymbol : public Symbol 16 | { 17 | public: 18 | MinusSymbol(Symbol** symbolTable) 19 | :Symbol(true,1,2,0,1,symbolTable) 20 | {} 21 | 22 | MinusSymbol(const bool isTerminal,const uint maxNumSymbols,const uint maxNumSymbolEntries,const uint numDiffusionParams,const uint numFormalParams,Symbol** symbolTable) 23 | :Symbol(isTerminal,maxNumSymbols,maxNumSymbolEntries,numDiffusionParams,numFormalParams,symbolTable) 24 | {} 25 | 26 | virtual void render(const float* params) const 27 | { 28 | glRotatef(-params[0],0,0,1); 29 | } 30 | 31 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 32 | { 33 | output[0].mID=3; 34 | output[1].mParam=input[0].mParam; 35 | logProbability=0; 36 | return 2; 37 | } 38 | 39 | virtual ushort setFlags(const float* params) const 40 | { 41 | return SymbolEntry::DETERMINISTIC; 42 | } 43 | 44 | virtual void saveToMesh(const float* params) const 45 | { 46 | mResourceHandler->getOutputMesh()->curDirTrans().rotate(-params[0],0,0,1); 47 | } 48 | 49 | virtual const char* symbolName() const 50 | { return "-"; } 51 | 52 | //##################################################################### 53 | }; 54 | 55 | //##################################################################### 56 | } // namespace ProceduralModeling 57 | 58 | #endif //_MINUS_SYMBOL_HPP_ 59 | -------------------------------------------------------------------------------- /GrammarGen/Source/PipeSymbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _PIPE_SYMBOL_HPP_ 6 | #define _PIPE_SYMBOL_HPP_ 7 | 8 | #include "Symbol.hpp" 9 | 10 | namespace ProceduralModeling{ 11 | 12 | //##################################################################### 13 | // Class PipeSymbol 14 | //##################################################################### 15 | class PipeSymbol : public Symbol 16 | { 17 | public: 18 | PipeSymbol(Symbol** symbolTable) 19 | :Symbol(true,1,1,0,0,symbolTable) 20 | {} 21 | 22 | PipeSymbol(const bool isTerminal,const uint maxNumSymbols,const uint maxNumSymbolEntries,const uint numDiffusionParams,const uint numFormalParams,Symbol** symbolTable) 23 | :Symbol(isTerminal,maxNumSymbols,maxNumSymbolEntries,numDiffusionParams,numFormalParams,symbolTable) 24 | {} 25 | 26 | virtual void render(const float* params) const 27 | { 28 | glRotatef(180,0,1,0); 29 | } 30 | 31 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 32 | { 33 | output[0].mID=8; 34 | logProbability=0; 35 | return 1; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual const char* symbolName() const 44 | { return "|"; } 45 | 46 | //##################################################################### 47 | }; 48 | 49 | //##################################################################### 50 | } // namespace ProceduralModeling 51 | 52 | #endif //_PIPE_SYMBOL_HPP_ 53 | -------------------------------------------------------------------------------- /GrammarGen/Source/PlusSymbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _PLUS_SYMBOL_HPP_ 6 | #define _PLUS_SYMBOL_HPP_ 7 | 8 | #include "Symbol.hpp" 9 | 10 | namespace ProceduralModeling{ 11 | 12 | //##################################################################### 13 | // Class PlusSymbol 14 | //##################################################################### 15 | class PlusSymbol : public Symbol 16 | { 17 | public: 18 | PlusSymbol(Symbol** symbolTable) 19 | :Symbol(true,1,2,0,1,symbolTable) 20 | {} 21 | 22 | PlusSymbol(const bool isTerminal,const uint maxNumSymbols,const uint maxNumSymbolEntries,const uint numDiffusionParams,const uint numFormalParams,Symbol** symbolTable) 23 | :Symbol(isTerminal,maxNumSymbols,maxNumSymbolEntries,numDiffusionParams,numFormalParams,symbolTable) 24 | {} 25 | 26 | virtual void render(const float* params) const 27 | { 28 | glRotatef(params[0],0,0,1); 29 | } 30 | 31 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 32 | { 33 | output[0].mID=2; 34 | output[1].mParam=input[0].mParam; 35 | logProbability=0; 36 | return 2; 37 | } 38 | 39 | virtual ushort setFlags(const float* params) const 40 | { 41 | return SymbolEntry::DETERMINISTIC; 42 | } 43 | 44 | virtual void saveToMesh(const float* params) const 45 | { 46 | mResourceHandler->getOutputMesh()->curDirTrans().rotate(params[0], 0, 0, 1); 47 | } 48 | 49 | virtual const char* symbolName() const 50 | { return "+"; } 51 | 52 | //##################################################################### 53 | }; 54 | 55 | //##################################################################### 56 | } // namespace ProceduralModeling 57 | 58 | #endif //_PLUS_SYMBOL_HPP_ 59 | -------------------------------------------------------------------------------- /GrammarGen/Source/RightBracketSymbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _RIGHT_BRACKET_SYMBOL_HPP_ 6 | #define _RIGHT_BRACKET_SYMBOL_HPP_ 7 | 8 | #include "Symbol.hpp" 9 | 10 | namespace ProceduralModeling{ 11 | 12 | //##################################################################### 13 | // Class RightBracketSymbol 14 | //##################################################################### 15 | class RightBracketSymbol : public Symbol 16 | { 17 | public: 18 | RightBracketSymbol(Symbol** symbolTable) 19 | :Symbol(true,1,1,0,0,symbolTable) 20 | {} 21 | 22 | RightBracketSymbol(const bool isTerminal,const uint maxNumSymbols,const uint maxNumSymbolEntries,const uint numDiffusionParams,const uint numFormalParams,Symbol** symbolTable) 23 | :Symbol(isTerminal,maxNumSymbols,maxNumSymbolEntries,numDiffusionParams,numFormalParams,symbolTable) 24 | {} 25 | 26 | virtual void render(const float* params) const 27 | { 28 | glPopMatrix(); 29 | } 30 | 31 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 32 | { 33 | output[0].mID=1; 34 | logProbability=0; 35 | return 1; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual void saveToMesh(const float* params) const 44 | { 45 | mResourceHandler->getOutputMesh()->popState(); 46 | } 47 | 48 | virtual void voxel(const float* params) const 49 | { 50 | mResourceHandler->popBBoxMatrix(); 51 | } 52 | 53 | virtual const char* symbolName() const 54 | { return "]"; } 55 | 56 | //##################################################################### 57 | }; 58 | 59 | //##################################################################### 60 | } // namespace ProceduralModeling 61 | 62 | #endif //_RIGHT_BRACKET_SYMBOL_HPP_ 63 | -------------------------------------------------------------------------------- /GrammarGen/Source/TABOPF124CS/Arrays.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _ARRAYS_HPP_ 6 | #define _ARRAYS_HPP_ 7 | 8 | namespace ProceduralModeling{ 9 | 10 | namespace Arrays{ 11 | 12 | 13 | 14 | //##################################################################### 15 | } // namespace Arrays 16 | 17 | //##################################################################### 18 | } // namespace ProceduralModeling 19 | 20 | #endif //_ARRAYS_HPP_ -------------------------------------------------------------------------------- /GrammarGen/Source/TABOPF124CS/CSymbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _C_SYMBOL_HPP_ 6 | #define _C_SYMBOL_HPP_ 7 | 8 | #include "Arrays.hpp" 9 | #include "Distributions.hpp" 10 | #include "Symbol.hpp" 11 | 12 | namespace ProceduralModeling{ 13 | 14 | //##################################################################### 15 | // Class CSymbol 16 | //##################################################################### 17 | class CSymbol : public Symbol 18 | { 19 | public: 20 | CSymbol(Symbol** symbolTable) 21 | :Symbol(true,1,1,0,0,symbolTable) 22 | {} 23 | 24 | CSymbol(const bool isTerminal,const uint maxNumSymbols,const uint maxNumSymbolEntries,const uint numDiffusionParams,const uint numFormalParams,Symbol** symbolTable) 25 | :Symbol(isTerminal,maxNumSymbols,maxNumSymbolEntries,numDiffusionParams,numFormalParams,symbolTable) 26 | {} 27 | 28 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 29 | { 30 | output[0].mID=200; 31 | logProbability=0; 32 | return 1; 33 | } 34 | 35 | virtual ushort setFlags(const float* params) const 36 | { 37 | return SymbolEntry::DETERMINISTIC; 38 | } 39 | 40 | virtual void render(const float* params) const 41 | { 42 | 43 | } 44 | 45 | virtual void initGraphics() 46 | { 47 | 48 | } 49 | 50 | virtual void saveToMesh(const float* params) const 51 | { 52 | 53 | } 54 | 55 | virtual void voxel(const float* params) const 56 | { 57 | 58 | } 59 | 60 | virtual const char* symbolName() const 61 | { return "C"; } 62 | 63 | //##################################################################### 64 | }; 65 | 66 | //##################################################################### 67 | } // namespace ProceduralModeling 68 | 69 | #endif //_C_SYMBOL_HPP_ 70 | -------------------------------------------------------------------------------- /GrammarGen/Source/TABOPF124CS/TABOPF124CS.pro: -------------------------------------------------------------------------------- 1 | ###################################################################### 2 | # Automatically generated by qmake (2.01a) Tue Sep 6 16:20:16 2011 3 | ###################################################################### 4 | 5 | TEMPLATE = lib 6 | QT += opengl 7 | CONFIG += debug_and_release plugin build_all 8 | INCLUDEPATH += ../../Source ../../../Common/include/ 9 | DESTDIR = ../../Plugins 10 | QMAKE_CXXFLAGS_RELEASE += -O3 -fvisibility=hidden 11 | QMAKE_LIBDIR += /Users/jtalton/Projects/metropolis-procedural-modeling/Common/lib 12 | INCLUDEPATH += /usr/local/include /usr/include /opt/local/include 13 | LIBS += -lGLEW -L/usr/lib/ -L/usr/local/lib -L/opt/local/lib 14 | QMAKE_MACOSX_DEPLOYMENT_TARGET = 10.6 15 | CONFIG(debug, debug|release) { 16 | TARGET = $$join(TARGET,,,_d) 17 | LIBS += -lProcModel_d 18 | } 19 | CONFIG(release, debug|release) { LIBS += -lProcModel } 20 | DEPENDPATH += . . 21 | INCLUDEPATH += . 22 | 23 | # Input 24 | HEADERS += Arrays.hpp CSymbol.hpp FSymbol.hpp 25 | SOURCES += TABOPF124CS.cpp 26 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/Arrays.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _ARRAYS_HPP_ 6 | #define _ARRAYS_HPP_ 7 | 8 | namespace ProceduralModeling{ 9 | 10 | namespace Arrays{ 11 | 12 | 13 | 14 | //##################################################################### 15 | } // namespace Arrays 16 | 17 | //##################################################################### 18 | } // namespace ProceduralModeling 19 | 20 | #endif //_ARRAYS_HPP_ -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/BackSlash_0Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _BACKSLASH_0_SYMBOL_HPP_ 6 | #define _BACKSLASH_0_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "BackSlashSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class BackSlash_0Symbol 15 | //##################################################################### 16 | class BackSlash_0Symbol : public BackSlashSymbol 17 | { 18 | public: 19 | BackSlash_0Symbol(Symbol** symbolTable) 20 | :BackSlashSymbol(true,1,3,2,0,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | 137.5+Distributions::NormalSample(0.0,30.0,params[0],params[1])}; 27 | BackSlashSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=301; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*2); 34 | logProbability=0; 35 | return 3; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::NormalEval(0.0,30.0,params[0],params[1])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | BackSlashSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | 137.5+Distributions::NormalSample(0.0,30.0,params[0],params[1])}; 57 | BackSlashSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | 137.5+Distributions::NormalSample(0.0,30.0,params[0],params[1])}; 64 | BackSlashSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "BackSlash_0"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_BACKSLASH_0_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/BackSlash_10Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _BACKSLASH_10_SYMBOL_HPP_ 6 | #define _BACKSLASH_10_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "BackSlashSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class BackSlash_10Symbol 15 | //##################################################################### 16 | class BackSlash_10Symbol : public BackSlashSymbol 17 | { 18 | public: 19 | BackSlash_10Symbol(Symbol** symbolTable) 20 | :BackSlashSymbol(true,1,3,1,1,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | params[1]+Distributions::UniformSample(-45.0,45.0,params[0])}; 27 | BackSlashSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=339; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*2); 34 | logProbability=0; 35 | return 3; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(-45.0,45.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | BackSlashSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | params[1]+Distributions::UniformSample(-45.0,45.0,params[0])}; 57 | BackSlashSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | params[1]+Distributions::UniformSample(-45.0,45.0,params[0])}; 64 | BackSlashSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "BackSlash_10"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_BACKSLASH_10_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/BackSlash_11Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _BACKSLASH_11_SYMBOL_HPP_ 6 | #define _BACKSLASH_11_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "BackSlashSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class BackSlash_11Symbol 15 | //##################################################################### 16 | class BackSlash_11Symbol : public BackSlashSymbol 17 | { 18 | public: 19 | BackSlash_11Symbol(Symbol** symbolTable) 20 | :BackSlashSymbol(true,1,3,1,1,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | params[1]+Distributions::UniformSample(-45.0,45.0,params[0])}; 27 | BackSlashSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=343; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*2); 34 | logProbability=0; 35 | return 3; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(-45.0,45.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | BackSlashSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | params[1]+Distributions::UniformSample(-45.0,45.0,params[0])}; 57 | BackSlashSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | params[1]+Distributions::UniformSample(-45.0,45.0,params[0])}; 64 | BackSlashSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "BackSlash_11"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_BACKSLASH_11_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/BackSlash_12Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _BACKSLASH_12_SYMBOL_HPP_ 6 | #define _BACKSLASH_12_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "BackSlashSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class BackSlash_12Symbol 15 | //##################################################################### 16 | class BackSlash_12Symbol : public BackSlashSymbol 17 | { 18 | public: 19 | BackSlash_12Symbol(Symbol** symbolTable) 20 | :BackSlashSymbol(true,1,3,1,1,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | params[1]+Distributions::UniformSample(-45.0,45.0,params[0])}; 27 | BackSlashSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=347; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*2); 34 | logProbability=0; 35 | return 3; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(-45.0,45.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | BackSlashSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | params[1]+Distributions::UniformSample(-45.0,45.0,params[0])}; 57 | BackSlashSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | params[1]+Distributions::UniformSample(-45.0,45.0,params[0])}; 64 | BackSlashSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "BackSlash_12"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_BACKSLASH_12_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/BackSlash_13Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _BACKSLASH_13_SYMBOL_HPP_ 6 | #define _BACKSLASH_13_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "BackSlashSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class BackSlash_13Symbol 15 | //##################################################################### 16 | class BackSlash_13Symbol : public BackSlashSymbol 17 | { 18 | public: 19 | BackSlash_13Symbol(Symbol** symbolTable) 20 | :BackSlashSymbol(true,1,2,1,0,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | 137.5+Distributions::UniformSample(-45.0,45.0,params[0])}; 27 | BackSlashSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=352; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*1); 34 | logProbability=0; 35 | return 2; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(-45.0,45.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | BackSlashSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | 137.5+Distributions::UniformSample(-45.0,45.0,params[0])}; 57 | BackSlashSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | 137.5+Distributions::UniformSample(-45.0,45.0,params[0])}; 64 | BackSlashSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "BackSlash_13"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_BACKSLASH_13_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/BackSlash_14Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _BACKSLASH_14_SYMBOL_HPP_ 6 | #define _BACKSLASH_14_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "BackSlashSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class BackSlash_14Symbol 15 | //##################################################################### 16 | class BackSlash_14Symbol : public BackSlashSymbol 17 | { 18 | public: 19 | BackSlash_14Symbol(Symbol** symbolTable) 20 | :BackSlashSymbol(true,1,2,1,0,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | 137.5+Distributions::UniformSample(-45.0,45.0,params[0])}; 27 | BackSlashSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=353; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*1); 34 | logProbability=0; 35 | return 2; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(-45.0,45.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | BackSlashSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | 137.5+Distributions::UniformSample(-45.0,45.0,params[0])}; 57 | BackSlashSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | 137.5+Distributions::UniformSample(-45.0,45.0,params[0])}; 64 | BackSlashSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "BackSlash_14"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_BACKSLASH_14_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/BackSlash_15Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _BACKSLASH_15_SYMBOL_HPP_ 6 | #define _BACKSLASH_15_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "BackSlashSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class BackSlash_15Symbol 15 | //##################################################################### 16 | class BackSlash_15Symbol : public BackSlashSymbol 17 | { 18 | public: 19 | BackSlash_15Symbol(Symbol** symbolTable) 20 | :BackSlashSymbol(true,1,2,1,0,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | 137.5+Distributions::UniformSample(-45.0,45.0,params[0])}; 27 | BackSlashSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=354; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*1); 34 | logProbability=0; 35 | return 2; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(-45.0,45.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | BackSlashSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | 137.5+Distributions::UniformSample(-45.0,45.0,params[0])}; 57 | BackSlashSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | 137.5+Distributions::UniformSample(-45.0,45.0,params[0])}; 64 | BackSlashSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "BackSlash_15"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_BACKSLASH_15_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/BackSlash_16Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _BACKSLASH_16_SYMBOL_HPP_ 6 | #define _BACKSLASH_16_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "BackSlashSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class BackSlash_16Symbol 15 | //##################################################################### 16 | class BackSlash_16Symbol : public BackSlashSymbol 17 | { 18 | public: 19 | BackSlash_16Symbol(Symbol** symbolTable) 20 | :BackSlashSymbol(true,1,2,1,0,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | 137.5+Distributions::UniformSample(-45.0,45.0,params[0])}; 27 | BackSlashSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=355; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*1); 34 | logProbability=0; 35 | return 2; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(-45.0,45.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | BackSlashSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | 137.5+Distributions::UniformSample(-45.0,45.0,params[0])}; 57 | BackSlashSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | 137.5+Distributions::UniformSample(-45.0,45.0,params[0])}; 64 | BackSlashSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "BackSlash_16"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_BACKSLASH_16_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/BackSlash_17Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _BACKSLASH_17_SYMBOL_HPP_ 6 | #define _BACKSLASH_17_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "BackSlashSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class BackSlash_17Symbol 15 | //##################################################################### 16 | class BackSlash_17Symbol : public BackSlashSymbol 17 | { 18 | public: 19 | BackSlash_17Symbol(Symbol** symbolTable) 20 | :BackSlashSymbol(true,1,2,1,0,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | 137.5+Distributions::UniformSample(-45.0,45.0,params[0])}; 27 | BackSlashSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=356; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*1); 34 | logProbability=0; 35 | return 2; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(-45.0,45.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | BackSlashSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | 137.5+Distributions::UniformSample(-45.0,45.0,params[0])}; 57 | BackSlashSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | 137.5+Distributions::UniformSample(-45.0,45.0,params[0])}; 64 | BackSlashSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "BackSlash_17"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_BACKSLASH_17_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/BackSlash_18Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _BACKSLASH_18_SYMBOL_HPP_ 6 | #define _BACKSLASH_18_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "BackSlashSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class BackSlash_18Symbol 15 | //##################################################################### 16 | class BackSlash_18Symbol : public BackSlashSymbol 17 | { 18 | public: 19 | BackSlash_18Symbol(Symbol** symbolTable) 20 | :BackSlashSymbol(true,1,2,1,0,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | 137.5+Distributions::UniformSample(-45.0,45.0,params[0])}; 27 | BackSlashSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=357; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*1); 34 | logProbability=0; 35 | return 2; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(-45.0,45.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | BackSlashSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | 137.5+Distributions::UniformSample(-45.0,45.0,params[0])}; 57 | BackSlashSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | 137.5+Distributions::UniformSample(-45.0,45.0,params[0])}; 64 | BackSlashSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "BackSlash_18"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_BACKSLASH_18_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/BackSlash_19Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _BACKSLASH_19_SYMBOL_HPP_ 6 | #define _BACKSLASH_19_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "BackSlashSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class BackSlash_19Symbol 15 | //##################################################################### 16 | class BackSlash_19Symbol : public BackSlashSymbol 17 | { 18 | public: 19 | BackSlash_19Symbol(Symbol** symbolTable) 20 | :BackSlashSymbol(true,1,2,1,0,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | 137.5+Distributions::UniformSample(-45.0,45.0,params[0])}; 27 | BackSlashSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=358; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*1); 34 | logProbability=0; 35 | return 2; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(-45.0,45.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | BackSlashSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | 137.5+Distributions::UniformSample(-45.0,45.0,params[0])}; 57 | BackSlashSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | 137.5+Distributions::UniformSample(-45.0,45.0,params[0])}; 64 | BackSlashSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "BackSlash_19"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_BACKSLASH_19_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/BackSlash_1Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _BACKSLASH_1_SYMBOL_HPP_ 6 | #define _BACKSLASH_1_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "BackSlashSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class BackSlash_1Symbol 15 | //##################################################################### 16 | class BackSlash_1Symbol : public BackSlashSymbol 17 | { 18 | public: 19 | BackSlash_1Symbol(Symbol** symbolTable) 20 | :BackSlashSymbol(true,1,3,1,1,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | params[1]+Distributions::UniformSample(-45.0,45.0,params[0])}; 27 | BackSlashSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=304; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*2); 34 | logProbability=0; 35 | return 3; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(-45.0,45.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | BackSlashSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | params[1]+Distributions::UniformSample(-45.0,45.0,params[0])}; 57 | BackSlashSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | params[1]+Distributions::UniformSample(-45.0,45.0,params[0])}; 64 | BackSlashSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "BackSlash_1"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_BACKSLASH_1_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/BackSlash_2Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _BACKSLASH_2_SYMBOL_HPP_ 6 | #define _BACKSLASH_2_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "BackSlashSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class BackSlash_2Symbol 15 | //##################################################################### 16 | class BackSlash_2Symbol : public BackSlashSymbol 17 | { 18 | public: 19 | BackSlash_2Symbol(Symbol** symbolTable) 20 | :BackSlashSymbol(true,1,3,1,1,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | params[1]+Distributions::UniformSample(-45.0,45.0,params[0])}; 27 | BackSlashSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=308; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*2); 34 | logProbability=0; 35 | return 3; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(-45.0,45.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | BackSlashSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | params[1]+Distributions::UniformSample(-45.0,45.0,params[0])}; 57 | BackSlashSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | params[1]+Distributions::UniformSample(-45.0,45.0,params[0])}; 64 | BackSlashSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "BackSlash_2"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_BACKSLASH_2_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/BackSlash_3Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _BACKSLASH_3_SYMBOL_HPP_ 6 | #define _BACKSLASH_3_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "BackSlashSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class BackSlash_3Symbol 15 | //##################################################################### 16 | class BackSlash_3Symbol : public BackSlashSymbol 17 | { 18 | public: 19 | BackSlash_3Symbol(Symbol** symbolTable) 20 | :BackSlashSymbol(true,1,3,1,1,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | params[1]+Distributions::UniformSample(-45.0,45.0,params[0])}; 27 | BackSlashSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=312; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*2); 34 | logProbability=0; 35 | return 3; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(-45.0,45.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | BackSlashSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | params[1]+Distributions::UniformSample(-45.0,45.0,params[0])}; 57 | BackSlashSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | params[1]+Distributions::UniformSample(-45.0,45.0,params[0])}; 64 | BackSlashSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "BackSlash_3"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_BACKSLASH_3_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/BackSlash_4Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _BACKSLASH_4_SYMBOL_HPP_ 6 | #define _BACKSLASH_4_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "BackSlashSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class BackSlash_4Symbol 15 | //##################################################################### 16 | class BackSlash_4Symbol : public BackSlashSymbol 17 | { 18 | public: 19 | BackSlash_4Symbol(Symbol** symbolTable) 20 | :BackSlashSymbol(true,1,3,1,1,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | params[1]+Distributions::UniformSample(-45.0,45.0,params[0])}; 27 | BackSlashSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=316; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*2); 34 | logProbability=0; 35 | return 3; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(-45.0,45.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | BackSlashSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | params[1]+Distributions::UniformSample(-45.0,45.0,params[0])}; 57 | BackSlashSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | params[1]+Distributions::UniformSample(-45.0,45.0,params[0])}; 64 | BackSlashSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "BackSlash_4"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_BACKSLASH_4_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/BackSlash_5Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _BACKSLASH_5_SYMBOL_HPP_ 6 | #define _BACKSLASH_5_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "BackSlashSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class BackSlash_5Symbol 15 | //##################################################################### 16 | class BackSlash_5Symbol : public BackSlashSymbol 17 | { 18 | public: 19 | BackSlash_5Symbol(Symbol** symbolTable) 20 | :BackSlashSymbol(true,1,3,1,1,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | params[1]+Distributions::UniformSample(-45.0,45.0,params[0])}; 27 | BackSlashSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=320; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*2); 34 | logProbability=0; 35 | return 3; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(-45.0,45.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | BackSlashSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | params[1]+Distributions::UniformSample(-45.0,45.0,params[0])}; 57 | BackSlashSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | params[1]+Distributions::UniformSample(-45.0,45.0,params[0])}; 64 | BackSlashSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "BackSlash_5"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_BACKSLASH_5_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/BackSlash_6Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _BACKSLASH_6_SYMBOL_HPP_ 6 | #define _BACKSLASH_6_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "BackSlashSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class BackSlash_6Symbol 15 | //##################################################################### 16 | class BackSlash_6Symbol : public BackSlashSymbol 17 | { 18 | public: 19 | BackSlash_6Symbol(Symbol** symbolTable) 20 | :BackSlashSymbol(true,1,3,1,1,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | params[1]+Distributions::UniformSample(-45.0,45.0,params[0])}; 27 | BackSlashSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=324; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*2); 34 | logProbability=0; 35 | return 3; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(-45.0,45.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | BackSlashSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | params[1]+Distributions::UniformSample(-45.0,45.0,params[0])}; 57 | BackSlashSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | params[1]+Distributions::UniformSample(-45.0,45.0,params[0])}; 64 | BackSlashSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "BackSlash_6"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_BACKSLASH_6_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/BackSlash_7Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _BACKSLASH_7_SYMBOL_HPP_ 6 | #define _BACKSLASH_7_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "BackSlashSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class BackSlash_7Symbol 15 | //##################################################################### 16 | class BackSlash_7Symbol : public BackSlashSymbol 17 | { 18 | public: 19 | BackSlash_7Symbol(Symbol** symbolTable) 20 | :BackSlashSymbol(true,1,3,1,1,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | params[1]+Distributions::UniformSample(-45.0,45.0,params[0])}; 27 | BackSlashSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=327; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*2); 34 | logProbability=0; 35 | return 3; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(-45.0,45.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | BackSlashSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | params[1]+Distributions::UniformSample(-45.0,45.0,params[0])}; 57 | BackSlashSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | params[1]+Distributions::UniformSample(-45.0,45.0,params[0])}; 64 | BackSlashSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "BackSlash_7"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_BACKSLASH_7_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/BackSlash_8Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _BACKSLASH_8_SYMBOL_HPP_ 6 | #define _BACKSLASH_8_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "BackSlashSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class BackSlash_8Symbol 15 | //##################################################################### 16 | class BackSlash_8Symbol : public BackSlashSymbol 17 | { 18 | public: 19 | BackSlash_8Symbol(Symbol** symbolTable) 20 | :BackSlashSymbol(true,1,3,1,1,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | params[1]+Distributions::UniformSample(-45.0,45.0,params[0])}; 27 | BackSlashSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=331; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*2); 34 | logProbability=0; 35 | return 3; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(-45.0,45.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | BackSlashSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | params[1]+Distributions::UniformSample(-45.0,45.0,params[0])}; 57 | BackSlashSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | params[1]+Distributions::UniformSample(-45.0,45.0,params[0])}; 64 | BackSlashSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "BackSlash_8"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_BACKSLASH_8_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/BackSlash_9Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _BACKSLASH_9_SYMBOL_HPP_ 6 | #define _BACKSLASH_9_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "BackSlashSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class BackSlash_9Symbol 15 | //##################################################################### 16 | class BackSlash_9Symbol : public BackSlashSymbol 17 | { 18 | public: 19 | BackSlash_9Symbol(Symbol** symbolTable) 20 | :BackSlashSymbol(true,1,3,1,1,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | params[1]+Distributions::UniformSample(-45.0,45.0,params[0])}; 27 | BackSlashSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=335; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*2); 34 | logProbability=0; 35 | return 3; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(-45.0,45.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | BackSlashSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | params[1]+Distributions::UniformSample(-45.0,45.0,params[0])}; 57 | BackSlashSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | params[1]+Distributions::UniformSample(-45.0,45.0,params[0])}; 64 | BackSlashSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "BackSlash_9"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_BACKSLASH_9_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/ColorSymbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _COLOR_SYMBOL_HPP_ 6 | #define _COLOR_SYMBOL_HPP_ 7 | 8 | #include "Arrays.hpp" 9 | #include "Distributions.hpp" 10 | #include "Symbol.hpp" 11 | 12 | namespace ProceduralModeling{ 13 | 14 | //##################################################################### 15 | // Class ColorSymbol 16 | //##################################################################### 17 | class ColorSymbol : public Symbol 18 | { 19 | public: 20 | ColorSymbol(Symbol** symbolTable) 21 | :Symbol(true,1,4,0,3,symbolTable) 22 | {} 23 | 24 | ColorSymbol(const bool isTerminal,const uint maxNumSymbols,const uint maxNumSymbolEntries,const uint numDiffusionParams,const uint numFormalParams,Symbol** symbolTable) 25 | :Symbol(isTerminal,maxNumSymbols,maxNumSymbolEntries,numDiffusionParams,numFormalParams,symbolTable) 26 | {} 27 | 28 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 29 | { 30 | output[0].mID=200; 31 | memcpy(output+1,input,sizeof(SymbolEntry)*3); 32 | logProbability=0; 33 | return 4; 34 | } 35 | 36 | virtual ushort setFlags(const float* params) const 37 | { 38 | return SymbolEntry::DETERMINISTIC; 39 | } 40 | 41 | virtual void render(const float* params) const 42 | { 43 | glColor3f (params[0], params[1], params[2]); 44 | } 45 | 46 | virtual void initGraphics() 47 | { 48 | 49 | } 50 | 51 | virtual void saveToMesh(const float* params) const 52 | { 53 | 54 | } 55 | 56 | virtual void voxel(const float* params) const 57 | { 58 | 59 | } 60 | 61 | virtual const char* symbolName() const 62 | { return "Color"; } 63 | 64 | //##################################################################### 65 | }; 66 | 67 | //##################################################################### 68 | } // namespace ProceduralModeling 69 | 70 | #endif //_COLOR_SYMBOL_HPP_ 71 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/ESymbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _E_SYMBOL_HPP_ 6 | #define _E_SYMBOL_HPP_ 7 | 8 | #include "Arrays.hpp" 9 | #include "Distributions.hpp" 10 | #include "Symbol.hpp" 11 | 12 | namespace ProceduralModeling{ 13 | 14 | //##################################################################### 15 | // Class ESymbol 16 | //##################################################################### 17 | class ESymbol : public Symbol 18 | { 19 | public: 20 | ESymbol(Symbol** symbolTable) 21 | :Symbol(true,1,1,0,0,symbolTable) 22 | {} 23 | 24 | ESymbol(const bool isTerminal,const uint maxNumSymbols,const uint maxNumSymbolEntries,const uint numDiffusionParams,const uint numFormalParams,Symbol** symbolTable) 25 | :Symbol(isTerminal,maxNumSymbols,maxNumSymbolEntries,numDiffusionParams,numFormalParams,symbolTable) 26 | {} 27 | 28 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 29 | { 30 | output[0].mID=205; 31 | logProbability=0; 32 | return 1; 33 | } 34 | 35 | virtual ushort setFlags(const float* params) const 36 | { 37 | return SymbolEntry::DETERMINISTIC; 38 | } 39 | 40 | virtual void render(const float* params) const 41 | { 42 | 43 | } 44 | 45 | virtual void initGraphics() 46 | { 47 | 48 | } 49 | 50 | virtual void saveToMesh(const float* params) const 51 | { 52 | 53 | } 54 | 55 | virtual void voxel(const float* params) const 56 | { 57 | 58 | } 59 | 60 | virtual const char* symbolName() const 61 | { return "E"; } 62 | 63 | //##################################################################### 64 | }; 65 | 66 | //##################################################################### 67 | } // namespace ProceduralModeling 68 | 69 | #endif //_E_SYMBOL_HPP_ 70 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/EtrunkSymbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _ETRUNK_SYMBOL_HPP_ 6 | #define _ETRUNK_SYMBOL_HPP_ 7 | 8 | #include "Arrays.hpp" 9 | #include "Distributions.hpp" 10 | #include "Symbol.hpp" 11 | 12 | namespace ProceduralModeling{ 13 | 14 | //##################################################################### 15 | // Class EtrunkSymbol 16 | //##################################################################### 17 | class EtrunkSymbol : public Symbol 18 | { 19 | public: 20 | EtrunkSymbol(Symbol** symbolTable) 21 | :Symbol(true,1,1,0,0,symbolTable) 22 | {} 23 | 24 | EtrunkSymbol(const bool isTerminal,const uint maxNumSymbols,const uint maxNumSymbolEntries,const uint numDiffusionParams,const uint numFormalParams,Symbol** symbolTable) 25 | :Symbol(isTerminal,maxNumSymbols,maxNumSymbolEntries,numDiffusionParams,numFormalParams,symbolTable) 26 | {} 27 | 28 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 29 | { 30 | output[0].mID=203; 31 | logProbability=0; 32 | return 1; 33 | } 34 | 35 | virtual ushort setFlags(const float* params) const 36 | { 37 | return SymbolEntry::DETERMINISTIC; 38 | } 39 | 40 | virtual void render(const float* params) const 41 | { 42 | 43 | } 44 | 45 | virtual void initGraphics() 46 | { 47 | 48 | } 49 | 50 | virtual void saveToMesh(const float* params) const 51 | { 52 | 53 | } 54 | 55 | virtual void voxel(const float* params) const 56 | { 57 | 58 | } 59 | 60 | virtual const char* symbolName() const 61 | { return "Etrunk"; } 62 | 63 | //##################################################################### 64 | }; 65 | 66 | //##################################################################### 67 | } // namespace ProceduralModeling 68 | 69 | #endif //_ETRUNK_SYMBOL_HPP_ 70 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/LeafSymbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _LEAF_SYMBOL_HPP_ 6 | #define _LEAF_SYMBOL_HPP_ 7 | 8 | #include "Arrays.hpp" 9 | #include "Distributions.hpp" 10 | #include "Symbol.hpp" 11 | 12 | namespace ProceduralModeling{ 13 | 14 | //##################################################################### 15 | // Class LeafSymbol 16 | //##################################################################### 17 | class LeafSymbol : public Symbol 18 | { 19 | public: 20 | LeafSymbol(Symbol** symbolTable) 21 | :Symbol(true,1,3,0,2,symbolTable) 22 | {} 23 | 24 | LeafSymbol(const bool isTerminal,const uint maxNumSymbols,const uint maxNumSymbolEntries,const uint numDiffusionParams,const uint numFormalParams,Symbol** symbolTable) 25 | :Symbol(isTerminal,maxNumSymbols,maxNumSymbolEntries,numDiffusionParams,numFormalParams,symbolTable) 26 | {} 27 | 28 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 29 | { 30 | output[0].mID=211; 31 | memcpy(output+1,input,sizeof(SymbolEntry)*2); 32 | logProbability=0; 33 | return 3; 34 | } 35 | 36 | virtual ushort setFlags(const float* params) const 37 | { 38 | return SymbolEntry::DETERMINISTIC; 39 | } 40 | 41 | virtual void render(const float* params) const 42 | { 43 | mResourceHandler->bindShader(mShader); 44 | glBegin(GL_POLYGON); 45 | glNormal3f(0,0,1); 46 | float shift=.1*params[0],x=.5*params[0],y=params[1]; 47 | glVertex3f(-x,-shift,0); 48 | glVertex3f(x,-shift,0); 49 | glVertex3f(x,y-shift,0); 50 | glVertex3f(-x,y-shift,0); 51 | glEnd(); 52 | } 53 | 54 | virtual void initGraphics() 55 | { 56 | 57 | } 58 | 59 | virtual void saveToMesh(const float* params) const 60 | { 61 | 62 | } 63 | 64 | virtual void voxel(const float* params) const 65 | { 66 | 67 | } 68 | 69 | virtual const char* symbolName() const 70 | { return "Leaf"; } 71 | 72 | //##################################################################### 73 | }; 74 | 75 | //##################################################################### 76 | } // namespace ProceduralModeling 77 | 78 | #endif //_LEAF_SYMBOL_HPP_ 79 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/LeafconnectorSymbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _LEAFCONNECTOR_SYMBOL_HPP_ 6 | #define _LEAFCONNECTOR_SYMBOL_HPP_ 7 | 8 | #include "Arrays.hpp" 9 | #include "Distributions.hpp" 10 | #include "Symbol.hpp" 11 | 12 | namespace ProceduralModeling{ 13 | 14 | //##################################################################### 15 | // Class LeafconnectorSymbol 16 | //##################################################################### 17 | class LeafconnectorSymbol : public Symbol 18 | { 19 | public: 20 | LeafconnectorSymbol(Symbol** symbolTable) 21 | :Symbol(true,1,2,0,1,symbolTable) 22 | {} 23 | 24 | LeafconnectorSymbol(const bool isTerminal,const uint maxNumSymbols,const uint maxNumSymbolEntries,const uint numDiffusionParams,const uint numFormalParams,Symbol** symbolTable) 25 | :Symbol(isTerminal,maxNumSymbols,maxNumSymbolEntries,numDiffusionParams,numFormalParams,symbolTable) 26 | {} 27 | 28 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 29 | { 30 | output[0].mID=210; 31 | memcpy(output+1,input,sizeof(SymbolEntry)*1); 32 | logProbability=0; 33 | return 2; 34 | } 35 | 36 | virtual ushort setFlags(const float* params) const 37 | { 38 | return SymbolEntry::DETERMINISTIC; 39 | } 40 | 41 | virtual void render(const float* params) const 42 | { 43 | mResourceHandler->bindShader(mShader); 44 | glBegin(GL_LINES); glVertex3f(0,0,0); glVertex3f(0,params[0],0); glEnd(); glTranslatef(0,params[0],0); 45 | } 46 | 47 | virtual void initGraphics() 48 | { 49 | 50 | } 51 | 52 | virtual void saveToMesh(const float* params) const 53 | { 54 | 55 | } 56 | 57 | virtual void voxel(const float* params) const 58 | { 59 | 60 | } 61 | 62 | virtual const char* symbolName() const 63 | { return "Leafconnector"; } 64 | 65 | //##################################################################### 66 | }; 67 | 68 | //##################################################################### 69 | } // namespace ProceduralModeling 70 | 71 | #endif //_LEAFCONNECTOR_SYMBOL_HPP_ 72 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/Local/Width.cpp: -------------------------------------------------------------------------------- 1 | float width_parameter = 1; 2 | 3 | 4 | float getWidth () { return width_parameter; } 5 | void setWidth (float width) { width_parameter = width; } 6 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/Local/Width.hpp: -------------------------------------------------------------------------------- 1 | float getWidth (); 2 | void setWidth (float width); 3 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/Minus_0Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _MINUS_0_SYMBOL_HPP_ 6 | #define _MINUS_0_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "MinusSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class Minus_0Symbol 15 | //##################################################################### 16 | class Minus_0Symbol : public MinusSymbol 17 | { 18 | public: 19 | Minus_0Symbol(Symbol** symbolTable) 20 | :MinusSymbol(true,1,2,1,0,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | Distributions::UniformSample(60.0,90.0,params[0])}; 27 | MinusSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=302; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*1); 34 | logProbability=0; 35 | return 2; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(60.0,90.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | MinusSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | Distributions::UniformSample(60.0,90.0,params[0])}; 57 | MinusSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | Distributions::UniformSample(60.0,90.0,params[0])}; 64 | MinusSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "Minus_0"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_MINUS_0_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/Minus_10Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _MINUS_10_SYMBOL_HPP_ 6 | #define _MINUS_10_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "MinusSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class Minus_10Symbol 15 | //##################################################################### 16 | class Minus_10Symbol : public MinusSymbol 17 | { 18 | public: 19 | Minus_10Symbol(Symbol** symbolTable) 20 | :MinusSymbol(true,1,4,1,2,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 27 | MinusSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=345; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*3); 34 | logProbability=0; 35 | return 4; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(5.0,55.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | MinusSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 57 | MinusSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 64 | MinusSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "Minus_10"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_MINUS_10_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/Minus_1Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _MINUS_1_SYMBOL_HPP_ 6 | #define _MINUS_1_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "MinusSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class Minus_1Symbol 15 | //##################################################################### 16 | class Minus_1Symbol : public MinusSymbol 17 | { 18 | public: 19 | Minus_1Symbol(Symbol** symbolTable) 20 | :MinusSymbol(true,1,4,1,2,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 27 | MinusSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=306; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*3); 34 | logProbability=0; 35 | return 4; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(5.0,55.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | MinusSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 57 | MinusSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 64 | MinusSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "Minus_1"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_MINUS_1_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/Minus_2Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _MINUS_2_SYMBOL_HPP_ 6 | #define _MINUS_2_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "MinusSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class Minus_2Symbol 15 | //##################################################################### 16 | class Minus_2Symbol : public MinusSymbol 17 | { 18 | public: 19 | Minus_2Symbol(Symbol** symbolTable) 20 | :MinusSymbol(true,1,4,1,2,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 27 | MinusSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=310; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*3); 34 | logProbability=0; 35 | return 4; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(5.0,55.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | MinusSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 57 | MinusSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 64 | MinusSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "Minus_2"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_MINUS_2_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/Minus_3Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _MINUS_3_SYMBOL_HPP_ 6 | #define _MINUS_3_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "MinusSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class Minus_3Symbol 15 | //##################################################################### 16 | class Minus_3Symbol : public MinusSymbol 17 | { 18 | public: 19 | Minus_3Symbol(Symbol** symbolTable) 20 | :MinusSymbol(true,1,4,1,2,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 27 | MinusSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=314; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*3); 34 | logProbability=0; 35 | return 4; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(5.0,55.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | MinusSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 57 | MinusSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 64 | MinusSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "Minus_3"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_MINUS_3_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/Minus_4Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _MINUS_4_SYMBOL_HPP_ 6 | #define _MINUS_4_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "MinusSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class Minus_4Symbol 15 | //##################################################################### 16 | class Minus_4Symbol : public MinusSymbol 17 | { 18 | public: 19 | Minus_4Symbol(Symbol** symbolTable) 20 | :MinusSymbol(true,1,4,1,2,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 27 | MinusSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=318; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*3); 34 | logProbability=0; 35 | return 4; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(5.0,55.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | MinusSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 57 | MinusSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 64 | MinusSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "Minus_4"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_MINUS_4_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/Minus_5Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _MINUS_5_SYMBOL_HPP_ 6 | #define _MINUS_5_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "MinusSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class Minus_5Symbol 15 | //##################################################################### 16 | class Minus_5Symbol : public MinusSymbol 17 | { 18 | public: 19 | Minus_5Symbol(Symbol** symbolTable) 20 | :MinusSymbol(true,1,4,1,2,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 27 | MinusSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=322; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*3); 34 | logProbability=0; 35 | return 4; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(5.0,55.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | MinusSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 57 | MinusSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 64 | MinusSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "Minus_5"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_MINUS_5_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/Minus_6Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _MINUS_6_SYMBOL_HPP_ 6 | #define _MINUS_6_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "MinusSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class Minus_6Symbol 15 | //##################################################################### 16 | class Minus_6Symbol : public MinusSymbol 17 | { 18 | public: 19 | Minus_6Symbol(Symbol** symbolTable) 20 | :MinusSymbol(true,1,4,1,2,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 27 | MinusSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=329; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*3); 34 | logProbability=0; 35 | return 4; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(5.0,55.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | MinusSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 57 | MinusSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 64 | MinusSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "Minus_6"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_MINUS_6_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/Minus_7Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _MINUS_7_SYMBOL_HPP_ 6 | #define _MINUS_7_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "MinusSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class Minus_7Symbol 15 | //##################################################################### 16 | class Minus_7Symbol : public MinusSymbol 17 | { 18 | public: 19 | Minus_7Symbol(Symbol** symbolTable) 20 | :MinusSymbol(true,1,4,1,2,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 27 | MinusSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=333; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*3); 34 | logProbability=0; 35 | return 4; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(5.0,55.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | MinusSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 57 | MinusSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 64 | MinusSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "Minus_7"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_MINUS_7_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/Minus_8Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _MINUS_8_SYMBOL_HPP_ 6 | #define _MINUS_8_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "MinusSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class Minus_8Symbol 15 | //##################################################################### 16 | class Minus_8Symbol : public MinusSymbol 17 | { 18 | public: 19 | Minus_8Symbol(Symbol** symbolTable) 20 | :MinusSymbol(true,1,4,1,2,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 27 | MinusSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=337; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*3); 34 | logProbability=0; 35 | return 4; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(5.0,55.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | MinusSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 57 | MinusSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 64 | MinusSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "Minus_8"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_MINUS_8_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/Minus_9Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _MINUS_9_SYMBOL_HPP_ 6 | #define _MINUS_9_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "MinusSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class Minus_9Symbol 15 | //##################################################################### 16 | class Minus_9Symbol : public MinusSymbol 17 | { 18 | public: 19 | Minus_9Symbol(Symbol** symbolTable) 20 | :MinusSymbol(true,1,4,1,2,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 27 | MinusSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=341; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*3); 34 | logProbability=0; 35 | return 4; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(5.0,55.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | MinusSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 57 | MinusSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 64 | MinusSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "Minus_9"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_MINUS_9_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/Plus_0Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _PLUS_0_SYMBOL_HPP_ 6 | #define _PLUS_0_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "PlusSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class Plus_0Symbol 15 | //##################################################################### 16 | class Plus_0Symbol : public PlusSymbol 17 | { 18 | public: 19 | Plus_0Symbol(Symbol** symbolTable) 20 | :PlusSymbol(true,1,4,1,2,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 27 | PlusSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=307; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*3); 34 | logProbability=0; 35 | return 4; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(5.0,55.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | PlusSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 57 | PlusSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 64 | PlusSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "Plus_0"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_PLUS_0_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/Plus_10Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _PLUS_10_SYMBOL_HPP_ 6 | #define _PLUS_10_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "PlusSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class Plus_10Symbol 15 | //##################################################################### 16 | class Plus_10Symbol : public PlusSymbol 17 | { 18 | public: 19 | Plus_10Symbol(Symbol** symbolTable) 20 | :PlusSymbol(true,1,4,1,2,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 27 | PlusSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=346; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*3); 34 | logProbability=0; 35 | return 4; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(5.0,55.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | PlusSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 57 | PlusSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 64 | PlusSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "Plus_10"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_PLUS_10_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/Plus_11Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _PLUS_11_SYMBOL_HPP_ 6 | #define _PLUS_11_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "PlusSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class Plus_11Symbol 15 | //##################################################################### 16 | class Plus_11Symbol : public PlusSymbol 17 | { 18 | public: 19 | Plus_11Symbol(Symbol** symbolTable) 20 | :PlusSymbol(true,1,3,1,1,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])}; 27 | PlusSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=349; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*2); 34 | logProbability=0; 35 | return 3; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(5.0,55.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | PlusSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])}; 57 | PlusSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])}; 64 | PlusSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "Plus_11"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_PLUS_11_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/Plus_12Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _PLUS_12_SYMBOL_HPP_ 6 | #define _PLUS_12_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "PlusSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class Plus_12Symbol 15 | //##################################################################### 16 | class Plus_12Symbol : public PlusSymbol 17 | { 18 | public: 19 | Plus_12Symbol(Symbol** symbolTable) 20 | :PlusSymbol(true,1,2,1,0,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | Distributions::UniformSample(-60.0,60.0,params[0])}; 27 | PlusSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=350; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*1); 34 | logProbability=0; 35 | return 2; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(-60.0,60.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | PlusSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | Distributions::UniformSample(-60.0,60.0,params[0])}; 57 | PlusSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | Distributions::UniformSample(-60.0,60.0,params[0])}; 64 | PlusSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "Plus_12"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_PLUS_12_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/Plus_13Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _PLUS_13_SYMBOL_HPP_ 6 | #define _PLUS_13_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "PlusSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class Plus_13Symbol 15 | //##################################################################### 16 | class Plus_13Symbol : public PlusSymbol 17 | { 18 | public: 19 | Plus_13Symbol(Symbol** symbolTable) 20 | :PlusSymbol(true,1,2,1,0,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | Distributions::UniformSample(-60.0,60.0,params[0])}; 27 | PlusSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=351; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*1); 34 | logProbability=0; 35 | return 2; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(-60.0,60.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | PlusSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | Distributions::UniformSample(-60.0,60.0,params[0])}; 57 | PlusSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | Distributions::UniformSample(-60.0,60.0,params[0])}; 64 | PlusSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "Plus_13"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_PLUS_13_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/Plus_1Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _PLUS_1_SYMBOL_HPP_ 6 | #define _PLUS_1_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "PlusSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class Plus_1Symbol 15 | //##################################################################### 16 | class Plus_1Symbol : public PlusSymbol 17 | { 18 | public: 19 | Plus_1Symbol(Symbol** symbolTable) 20 | :PlusSymbol(true,1,4,1,2,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 27 | PlusSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=311; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*3); 34 | logProbability=0; 35 | return 4; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(5.0,55.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | PlusSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 57 | PlusSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 64 | PlusSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "Plus_1"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_PLUS_1_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/Plus_2Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _PLUS_2_SYMBOL_HPP_ 6 | #define _PLUS_2_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "PlusSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class Plus_2Symbol 15 | //##################################################################### 16 | class Plus_2Symbol : public PlusSymbol 17 | { 18 | public: 19 | Plus_2Symbol(Symbol** symbolTable) 20 | :PlusSymbol(true,1,4,1,2,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 27 | PlusSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=315; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*3); 34 | logProbability=0; 35 | return 4; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(5.0,55.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | PlusSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 57 | PlusSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 64 | PlusSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "Plus_2"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_PLUS_2_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/Plus_3Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _PLUS_3_SYMBOL_HPP_ 6 | #define _PLUS_3_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "PlusSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class Plus_3Symbol 15 | //##################################################################### 16 | class Plus_3Symbol : public PlusSymbol 17 | { 18 | public: 19 | Plus_3Symbol(Symbol** symbolTable) 20 | :PlusSymbol(true,1,4,1,2,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 27 | PlusSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=319; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*3); 34 | logProbability=0; 35 | return 4; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(5.0,55.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | PlusSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 57 | PlusSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 64 | PlusSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "Plus_3"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_PLUS_3_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/Plus_4Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _PLUS_4_SYMBOL_HPP_ 6 | #define _PLUS_4_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "PlusSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class Plus_4Symbol 15 | //##################################################################### 16 | class Plus_4Symbol : public PlusSymbol 17 | { 18 | public: 19 | Plus_4Symbol(Symbol** symbolTable) 20 | :PlusSymbol(true,1,4,1,2,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 27 | PlusSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=323; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*3); 34 | logProbability=0; 35 | return 4; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(5.0,55.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | PlusSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 57 | PlusSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 64 | PlusSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "Plus_4"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_PLUS_4_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/Plus_5Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _PLUS_5_SYMBOL_HPP_ 6 | #define _PLUS_5_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "PlusSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class Plus_5Symbol 15 | //##################################################################### 16 | class Plus_5Symbol : public PlusSymbol 17 | { 18 | public: 19 | Plus_5Symbol(Symbol** symbolTable) 20 | :PlusSymbol(true,1,3,1,1,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])}; 27 | PlusSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=326; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*2); 34 | logProbability=0; 35 | return 3; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(5.0,55.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | PlusSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])}; 57 | PlusSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])}; 64 | PlusSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "Plus_5"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_PLUS_5_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/Plus_6Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _PLUS_6_SYMBOL_HPP_ 6 | #define _PLUS_6_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "PlusSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class Plus_6Symbol 15 | //##################################################################### 16 | class Plus_6Symbol : public PlusSymbol 17 | { 18 | public: 19 | Plus_6Symbol(Symbol** symbolTable) 20 | :PlusSymbol(true,1,4,1,2,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 27 | PlusSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=330; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*3); 34 | logProbability=0; 35 | return 4; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(5.0,55.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | PlusSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 57 | PlusSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 64 | PlusSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "Plus_6"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_PLUS_6_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/Plus_7Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _PLUS_7_SYMBOL_HPP_ 6 | #define _PLUS_7_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "PlusSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class Plus_7Symbol 15 | //##################################################################### 16 | class Plus_7Symbol : public PlusSymbol 17 | { 18 | public: 19 | Plus_7Symbol(Symbol** symbolTable) 20 | :PlusSymbol(true,1,4,1,2,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 27 | PlusSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=334; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*3); 34 | logProbability=0; 35 | return 4; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(5.0,55.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | PlusSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 57 | PlusSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 64 | PlusSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "Plus_7"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_PLUS_7_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/Plus_8Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _PLUS_8_SYMBOL_HPP_ 6 | #define _PLUS_8_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "PlusSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class Plus_8Symbol 15 | //##################################################################### 16 | class Plus_8Symbol : public PlusSymbol 17 | { 18 | public: 19 | Plus_8Symbol(Symbol** symbolTable) 20 | :PlusSymbol(true,1,4,1,2,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 27 | PlusSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=338; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*3); 34 | logProbability=0; 35 | return 4; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(5.0,55.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | PlusSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 57 | PlusSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 64 | PlusSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "Plus_8"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_PLUS_8_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/Plus_9Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _PLUS_9_SYMBOL_HPP_ 6 | #define _PLUS_9_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "PlusSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class Plus_9Symbol 15 | //##################################################################### 16 | class Plus_9Symbol : public PlusSymbol 17 | { 18 | public: 19 | Plus_9Symbol(Symbol** symbolTable) 20 | :PlusSymbol(true,1,4,1,2,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[1]={ 26 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 27 | PlusSymbol::render(newParams); 28 | } 29 | 30 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 31 | { 32 | output[0].mID=342; 33 | memcpy(output+1,input,sizeof(SymbolEntry)*3); 34 | logProbability=0; 35 | return 4; 36 | } 37 | 38 | virtual ushort setFlags(const float* params) const 39 | { 40 | return SymbolEntry::DETERMINISTIC; 41 | } 42 | 43 | virtual float logDiffusionProbability(const float* params) const 44 | { 45 | return log(Distributions::UniformEval(5.0,55.0,params[0])); 46 | } 47 | 48 | virtual void initGraphics() 49 | { 50 | PlusSymbol::initGraphics(); 51 | } 52 | 53 | virtual void saveToMesh(const float* params) const 54 | { 55 | float newParams[1]={ 56 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 57 | PlusSymbol::saveToMesh(newParams); 58 | } 59 | 60 | virtual void voxel(const float* params) const 61 | { 62 | float newParams[1]={ 63 | 30.0+params[1]/12.0*Distributions::UniformSample(5.0,55.0,params[0])*params[2]}; 64 | PlusSymbol::voxel(newParams); 65 | } 66 | 67 | virtual const char* symbolName() const 68 | { return "Plus_9"; } 69 | 70 | //##################################################################### 71 | }; 72 | 73 | //##################################################################### 74 | } // namespace ProceduralModeling 75 | 76 | #endif //_PLUS_9_SYMBOL_HPP_ 77 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/PolygonSymbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _POLYGON_SYMBOL_HPP_ 6 | #define _POLYGON_SYMBOL_HPP_ 7 | 8 | #include "Arrays.hpp" 9 | #include "Distributions.hpp" 10 | #include "Symbol.hpp" 11 | 12 | namespace ProceduralModeling{ 13 | 14 | //##################################################################### 15 | // Class PolygonSymbol 16 | //##################################################################### 17 | class PolygonSymbol : public Symbol 18 | { 19 | public: 20 | PolygonSymbol(Symbol** symbolTable) 21 | :Symbol(true,1,4,0,3,symbolTable) 22 | {} 23 | 24 | PolygonSymbol(const bool isTerminal,const uint maxNumSymbols,const uint maxNumSymbolEntries,const uint numDiffusionParams,const uint numFormalParams,Symbol** symbolTable) 25 | :Symbol(isTerminal,maxNumSymbols,maxNumSymbolEntries,numDiffusionParams,numFormalParams,symbolTable) 26 | {} 27 | 28 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 29 | { 30 | output[0].mID=208; 31 | memcpy(output+1,input,sizeof(SymbolEntry)*3); 32 | logProbability=0; 33 | return 4; 34 | } 35 | 36 | virtual ushort setFlags(const float* params) const 37 | { 38 | return SymbolEntry::DETERMINISTIC; 39 | } 40 | 41 | virtual void render(const float* params) const 42 | { 43 | mResourceHandler->bindShader(mShader); 44 | float width_parameter = getWidth(); 45 | 46 | glBegin (GL_TRIANGLE_STRIP); 47 | 48 | glVertex3f (-0.5*width_parameter*2, 0.0, 0); 49 | glVertex3f (-0.5*width_parameter*2, params[0], 0); 50 | glVertex3f (0.5*width_parameter*2, 0.0, 0); 51 | glVertex3f (0.5*width_parameter*2, params[0], 0); 52 | 53 | glEnd(); 54 | glTranslatef(0,params[0],0); 55 | } 56 | 57 | virtual void initGraphics() 58 | { 59 | 60 | } 61 | 62 | virtual void saveToMesh(const float* params) const 63 | { 64 | 65 | } 66 | 67 | virtual void voxel(const float* params) const 68 | { 69 | 70 | } 71 | 72 | virtual const char* symbolName() const 73 | { return "Polygon"; } 74 | 75 | //##################################################################### 76 | }; 77 | 78 | //##################################################################### 79 | } // namespace ProceduralModeling 80 | 81 | #endif //_POLYGON_SYMBOL_HPP_ 82 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/Stem_0Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _STEM_0_SYMBOL_HPP_ 6 | #define _STEM_0_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "StemSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class Stem_0Symbol 15 | //##################################################################### 16 | class Stem_0Symbol : public StemSymbol 17 | { 18 | public: 19 | Stem_0Symbol(Symbol** symbolTable) 20 | :StemSymbol(true,1,2,1,0,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[4]={ 26 | Distributions::UniformSample(1.0*0.6,1.0,params[0]), 27 | 0.0, 28 | 12.0, 29 | 1.0}; 30 | StemSymbol::render(newParams); 31 | } 32 | 33 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 34 | { 35 | output[0].mID=300; 36 | memcpy(output+1,input,sizeof(SymbolEntry)*1); 37 | logProbability=0; 38 | return 2; 39 | } 40 | 41 | virtual ushort setFlags(const float* params) const 42 | { 43 | return SymbolEntry::DETERMINISTIC; 44 | } 45 | 46 | virtual float logDiffusionProbability(const float* params) const 47 | { 48 | return log(Distributions::UniformEval(1.0*0.6,1.0,params[0])); 49 | } 50 | 51 | virtual void initGraphics() 52 | { 53 | StemSymbol::initGraphics(); 54 | } 55 | 56 | virtual void saveToMesh(const float* params) const 57 | { 58 | float newParams[4]={ 59 | Distributions::UniformSample(1.0*0.6,1.0,params[0]), 60 | 0.0, 61 | 12.0, 62 | 1.0}; 63 | StemSymbol::saveToMesh(newParams); 64 | } 65 | 66 | virtual void voxel(const float* params) const 67 | { 68 | float newParams[4]={ 69 | Distributions::UniformSample(1.0*0.6,1.0,params[0]), 70 | 0.0, 71 | 12.0, 72 | 1.0}; 73 | StemSymbol::voxel(newParams); 74 | } 75 | 76 | virtual const char* symbolName() const 77 | { return "Stem_0"; } 78 | 79 | //##################################################################### 80 | }; 81 | 82 | //##################################################################### 83 | } // namespace ProceduralModeling 84 | 85 | #endif //_STEM_0_SYMBOL_HPP_ 86 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/Stem_10Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _STEM_10_SYMBOL_HPP_ 6 | #define _STEM_10_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "StemSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class Stem_10Symbol 15 | //##################################################################### 16 | class Stem_10Symbol : public StemSymbol 17 | { 18 | public: 19 | Stem_10Symbol(Symbol** symbolTable) 20 | :StemSymbol(true,1,4,1,2,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[4]={ 26 | Distributions::UniformSample(params[2]*0.6,params[2],params[0]), 27 | 1.2, 28 | params[1], 29 | 2.0}; 30 | StemSymbol::render(newParams); 31 | } 32 | 33 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 34 | { 35 | output[0].mID=336; 36 | memcpy(output+1,input,sizeof(SymbolEntry)*3); 37 | logProbability=0; 38 | return 4; 39 | } 40 | 41 | virtual ushort setFlags(const float* params) const 42 | { 43 | return SymbolEntry::DETERMINISTIC; 44 | } 45 | 46 | virtual float logDiffusionProbability(const float* params) const 47 | { 48 | return log(Distributions::UniformEval(params[2]*0.6,params[2],params[0])); 49 | } 50 | 51 | virtual void initGraphics() 52 | { 53 | StemSymbol::initGraphics(); 54 | } 55 | 56 | virtual void saveToMesh(const float* params) const 57 | { 58 | float newParams[4]={ 59 | Distributions::UniformSample(params[2]*0.6,params[2],params[0]), 60 | 1.2, 61 | params[1], 62 | 2.0}; 63 | StemSymbol::saveToMesh(newParams); 64 | } 65 | 66 | virtual void voxel(const float* params) const 67 | { 68 | float newParams[4]={ 69 | Distributions::UniformSample(params[2]*0.6,params[2],params[0]), 70 | 1.2, 71 | params[1], 72 | 2.0}; 73 | StemSymbol::voxel(newParams); 74 | } 75 | 76 | virtual const char* symbolName() const 77 | { return "Stem_10"; } 78 | 79 | //##################################################################### 80 | }; 81 | 82 | //##################################################################### 83 | } // namespace ProceduralModeling 84 | 85 | #endif //_STEM_10_SYMBOL_HPP_ 86 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/Stem_11Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _STEM_11_SYMBOL_HPP_ 6 | #define _STEM_11_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "StemSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class Stem_11Symbol 15 | //##################################################################### 16 | class Stem_11Symbol : public StemSymbol 17 | { 18 | public: 19 | Stem_11Symbol(Symbol** symbolTable) 20 | :StemSymbol(true,1,4,1,2,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[4]={ 26 | Distributions::UniformSample(params[2]*0.6,params[2],params[0]), 27 | 1.2, 28 | params[1], 29 | 2.0}; 30 | StemSymbol::render(newParams); 31 | } 32 | 33 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 34 | { 35 | output[0].mID=340; 36 | memcpy(output+1,input,sizeof(SymbolEntry)*3); 37 | logProbability=0; 38 | return 4; 39 | } 40 | 41 | virtual ushort setFlags(const float* params) const 42 | { 43 | return SymbolEntry::DETERMINISTIC; 44 | } 45 | 46 | virtual float logDiffusionProbability(const float* params) const 47 | { 48 | return log(Distributions::UniformEval(params[2]*0.6,params[2],params[0])); 49 | } 50 | 51 | virtual void initGraphics() 52 | { 53 | StemSymbol::initGraphics(); 54 | } 55 | 56 | virtual void saveToMesh(const float* params) const 57 | { 58 | float newParams[4]={ 59 | Distributions::UniformSample(params[2]*0.6,params[2],params[0]), 60 | 1.2, 61 | params[1], 62 | 2.0}; 63 | StemSymbol::saveToMesh(newParams); 64 | } 65 | 66 | virtual void voxel(const float* params) const 67 | { 68 | float newParams[4]={ 69 | Distributions::UniformSample(params[2]*0.6,params[2],params[0]), 70 | 1.2, 71 | params[1], 72 | 2.0}; 73 | StemSymbol::voxel(newParams); 74 | } 75 | 76 | virtual const char* symbolName() const 77 | { return "Stem_11"; } 78 | 79 | //##################################################################### 80 | }; 81 | 82 | //##################################################################### 83 | } // namespace ProceduralModeling 84 | 85 | #endif //_STEM_11_SYMBOL_HPP_ 86 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/Stem_12Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _STEM_12_SYMBOL_HPP_ 6 | #define _STEM_12_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "StemSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class Stem_12Symbol 15 | //##################################################################### 16 | class Stem_12Symbol : public StemSymbol 17 | { 18 | public: 19 | Stem_12Symbol(Symbol** symbolTable) 20 | :StemSymbol(true,1,4,1,2,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[4]={ 26 | Distributions::UniformSample(params[2]*0.6,params[2],params[0]), 27 | 1.2, 28 | params[1], 29 | 2.0}; 30 | StemSymbol::render(newParams); 31 | } 32 | 33 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 34 | { 35 | output[0].mID=344; 36 | memcpy(output+1,input,sizeof(SymbolEntry)*3); 37 | logProbability=0; 38 | return 4; 39 | } 40 | 41 | virtual ushort setFlags(const float* params) const 42 | { 43 | return SymbolEntry::DETERMINISTIC; 44 | } 45 | 46 | virtual float logDiffusionProbability(const float* params) const 47 | { 48 | return log(Distributions::UniformEval(params[2]*0.6,params[2],params[0])); 49 | } 50 | 51 | virtual void initGraphics() 52 | { 53 | StemSymbol::initGraphics(); 54 | } 55 | 56 | virtual void saveToMesh(const float* params) const 57 | { 58 | float newParams[4]={ 59 | Distributions::UniformSample(params[2]*0.6,params[2],params[0]), 60 | 1.2, 61 | params[1], 62 | 2.0}; 63 | StemSymbol::saveToMesh(newParams); 64 | } 65 | 66 | virtual void voxel(const float* params) const 67 | { 68 | float newParams[4]={ 69 | Distributions::UniformSample(params[2]*0.6,params[2],params[0]), 70 | 1.2, 71 | params[1], 72 | 2.0}; 73 | StemSymbol::voxel(newParams); 74 | } 75 | 76 | virtual const char* symbolName() const 77 | { return "Stem_12"; } 78 | 79 | //##################################################################### 80 | }; 81 | 82 | //##################################################################### 83 | } // namespace ProceduralModeling 84 | 85 | #endif //_STEM_12_SYMBOL_HPP_ 86 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/Stem_13Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _STEM_13_SYMBOL_HPP_ 6 | #define _STEM_13_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "StemSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class Stem_13Symbol 15 | //##################################################################### 16 | class Stem_13Symbol : public StemSymbol 17 | { 18 | public: 19 | Stem_13Symbol(Symbol** symbolTable) 20 | :StemSymbol(true,1,4,1,2,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[4]={ 26 | Distributions::UniformSample(params[2]*0.6,params[2],params[0]), 27 | 1.2, 28 | params[1], 29 | 1.0}; 30 | StemSymbol::render(newParams); 31 | } 32 | 33 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 34 | { 35 | output[0].mID=348; 36 | memcpy(output+1,input,sizeof(SymbolEntry)*3); 37 | logProbability=0; 38 | return 4; 39 | } 40 | 41 | virtual ushort setFlags(const float* params) const 42 | { 43 | return SymbolEntry::DETERMINISTIC; 44 | } 45 | 46 | virtual float logDiffusionProbability(const float* params) const 47 | { 48 | return log(Distributions::UniformEval(params[2]*0.6,params[2],params[0])); 49 | } 50 | 51 | virtual void initGraphics() 52 | { 53 | StemSymbol::initGraphics(); 54 | } 55 | 56 | virtual void saveToMesh(const float* params) const 57 | { 58 | float newParams[4]={ 59 | Distributions::UniformSample(params[2]*0.6,params[2],params[0]), 60 | 1.2, 61 | params[1], 62 | 1.0}; 63 | StemSymbol::saveToMesh(newParams); 64 | } 65 | 66 | virtual void voxel(const float* params) const 67 | { 68 | float newParams[4]={ 69 | Distributions::UniformSample(params[2]*0.6,params[2],params[0]), 70 | 1.2, 71 | params[1], 72 | 1.0}; 73 | StemSymbol::voxel(newParams); 74 | } 75 | 76 | virtual const char* symbolName() const 77 | { return "Stem_13"; } 78 | 79 | //##################################################################### 80 | }; 81 | 82 | //##################################################################### 83 | } // namespace ProceduralModeling 84 | 85 | #endif //_STEM_13_SYMBOL_HPP_ 86 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/Stem_1Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _STEM_1_SYMBOL_HPP_ 6 | #define _STEM_1_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "StemSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class Stem_1Symbol 15 | //##################################################################### 16 | class Stem_1Symbol : public StemSymbol 17 | { 18 | public: 19 | Stem_1Symbol(Symbol** symbolTable) 20 | :StemSymbol(true,1,4,1,2,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[4]={ 26 | Distributions::UniformSample(params[2]*0.5*0.6,params[2]*0.5,params[0]), 27 | 1.2, 28 | params[1], 29 | 1.0}; 30 | StemSymbol::render(newParams); 31 | } 32 | 33 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 34 | { 35 | output[0].mID=303; 36 | memcpy(output+1,input,sizeof(SymbolEntry)*3); 37 | logProbability=0; 38 | return 4; 39 | } 40 | 41 | virtual ushort setFlags(const float* params) const 42 | { 43 | return SymbolEntry::DETERMINISTIC; 44 | } 45 | 46 | virtual float logDiffusionProbability(const float* params) const 47 | { 48 | return log(Distributions::UniformEval(params[2]*0.5*0.6,params[2]*0.5,params[0])); 49 | } 50 | 51 | virtual void initGraphics() 52 | { 53 | StemSymbol::initGraphics(); 54 | } 55 | 56 | virtual void saveToMesh(const float* params) const 57 | { 58 | float newParams[4]={ 59 | Distributions::UniformSample(params[2]*0.5*0.6,params[2]*0.5,params[0]), 60 | 1.2, 61 | params[1], 62 | 1.0}; 63 | StemSymbol::saveToMesh(newParams); 64 | } 65 | 66 | virtual void voxel(const float* params) const 67 | { 68 | float newParams[4]={ 69 | Distributions::UniformSample(params[2]*0.5*0.6,params[2]*0.5,params[0]), 70 | 1.2, 71 | params[1], 72 | 1.0}; 73 | StemSymbol::voxel(newParams); 74 | } 75 | 76 | virtual const char* symbolName() const 77 | { return "Stem_1"; } 78 | 79 | //##################################################################### 80 | }; 81 | 82 | //##################################################################### 83 | } // namespace ProceduralModeling 84 | 85 | #endif //_STEM_1_SYMBOL_HPP_ 86 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/Stem_2Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _STEM_2_SYMBOL_HPP_ 6 | #define _STEM_2_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "StemSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class Stem_2Symbol 15 | //##################################################################### 16 | class Stem_2Symbol : public StemSymbol 17 | { 18 | public: 19 | Stem_2Symbol(Symbol** symbolTable) 20 | :StemSymbol(true,1,4,1,2,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[4]={ 26 | Distributions::UniformSample(params[2]*1.5*0.6,params[2]*1.5,params[0]), 27 | 1.2, 28 | params[1], 29 | 2.0}; 30 | StemSymbol::render(newParams); 31 | } 32 | 33 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 34 | { 35 | output[0].mID=305; 36 | memcpy(output+1,input,sizeof(SymbolEntry)*3); 37 | logProbability=0; 38 | return 4; 39 | } 40 | 41 | virtual ushort setFlags(const float* params) const 42 | { 43 | return SymbolEntry::DETERMINISTIC; 44 | } 45 | 46 | virtual float logDiffusionProbability(const float* params) const 47 | { 48 | return log(Distributions::UniformEval(params[2]*1.5*0.6,params[2]*1.5,params[0])); 49 | } 50 | 51 | virtual void initGraphics() 52 | { 53 | StemSymbol::initGraphics(); 54 | } 55 | 56 | virtual void saveToMesh(const float* params) const 57 | { 58 | float newParams[4]={ 59 | Distributions::UniformSample(params[2]*1.5*0.6,params[2]*1.5,params[0]), 60 | 1.2, 61 | params[1], 62 | 2.0}; 63 | StemSymbol::saveToMesh(newParams); 64 | } 65 | 66 | virtual void voxel(const float* params) const 67 | { 68 | float newParams[4]={ 69 | Distributions::UniformSample(params[2]*1.5*0.6,params[2]*1.5,params[0]), 70 | 1.2, 71 | params[1], 72 | 2.0}; 73 | StemSymbol::voxel(newParams); 74 | } 75 | 76 | virtual const char* symbolName() const 77 | { return "Stem_2"; } 78 | 79 | //##################################################################### 80 | }; 81 | 82 | //##################################################################### 83 | } // namespace ProceduralModeling 84 | 85 | #endif //_STEM_2_SYMBOL_HPP_ 86 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/Stem_3Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _STEM_3_SYMBOL_HPP_ 6 | #define _STEM_3_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "StemSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class Stem_3Symbol 15 | //##################################################################### 16 | class Stem_3Symbol : public StemSymbol 17 | { 18 | public: 19 | Stem_3Symbol(Symbol** symbolTable) 20 | :StemSymbol(true,1,4,1,2,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[4]={ 26 | Distributions::UniformSample(params[2]*1.5*0.6,params[2]*1.5,params[0]), 27 | 1.2, 28 | params[1], 29 | 2.0}; 30 | StemSymbol::render(newParams); 31 | } 32 | 33 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 34 | { 35 | output[0].mID=309; 36 | memcpy(output+1,input,sizeof(SymbolEntry)*3); 37 | logProbability=0; 38 | return 4; 39 | } 40 | 41 | virtual ushort setFlags(const float* params) const 42 | { 43 | return SymbolEntry::DETERMINISTIC; 44 | } 45 | 46 | virtual float logDiffusionProbability(const float* params) const 47 | { 48 | return log(Distributions::UniformEval(params[2]*1.5*0.6,params[2]*1.5,params[0])); 49 | } 50 | 51 | virtual void initGraphics() 52 | { 53 | StemSymbol::initGraphics(); 54 | } 55 | 56 | virtual void saveToMesh(const float* params) const 57 | { 58 | float newParams[4]={ 59 | Distributions::UniformSample(params[2]*1.5*0.6,params[2]*1.5,params[0]), 60 | 1.2, 61 | params[1], 62 | 2.0}; 63 | StemSymbol::saveToMesh(newParams); 64 | } 65 | 66 | virtual void voxel(const float* params) const 67 | { 68 | float newParams[4]={ 69 | Distributions::UniformSample(params[2]*1.5*0.6,params[2]*1.5,params[0]), 70 | 1.2, 71 | params[1], 72 | 2.0}; 73 | StemSymbol::voxel(newParams); 74 | } 75 | 76 | virtual const char* symbolName() const 77 | { return "Stem_3"; } 78 | 79 | //##################################################################### 80 | }; 81 | 82 | //##################################################################### 83 | } // namespace ProceduralModeling 84 | 85 | #endif //_STEM_3_SYMBOL_HPP_ 86 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/Stem_4Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _STEM_4_SYMBOL_HPP_ 6 | #define _STEM_4_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "StemSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class Stem_4Symbol 15 | //##################################################################### 16 | class Stem_4Symbol : public StemSymbol 17 | { 18 | public: 19 | Stem_4Symbol(Symbol** symbolTable) 20 | :StemSymbol(true,1,4,1,2,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[4]={ 26 | Distributions::UniformSample(params[2]*1.5*0.6,params[2]*1.5,params[0]), 27 | 1.2, 28 | params[1], 29 | 2.0}; 30 | StemSymbol::render(newParams); 31 | } 32 | 33 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 34 | { 35 | output[0].mID=313; 36 | memcpy(output+1,input,sizeof(SymbolEntry)*3); 37 | logProbability=0; 38 | return 4; 39 | } 40 | 41 | virtual ushort setFlags(const float* params) const 42 | { 43 | return SymbolEntry::DETERMINISTIC; 44 | } 45 | 46 | virtual float logDiffusionProbability(const float* params) const 47 | { 48 | return log(Distributions::UniformEval(params[2]*1.5*0.6,params[2]*1.5,params[0])); 49 | } 50 | 51 | virtual void initGraphics() 52 | { 53 | StemSymbol::initGraphics(); 54 | } 55 | 56 | virtual void saveToMesh(const float* params) const 57 | { 58 | float newParams[4]={ 59 | Distributions::UniformSample(params[2]*1.5*0.6,params[2]*1.5,params[0]), 60 | 1.2, 61 | params[1], 62 | 2.0}; 63 | StemSymbol::saveToMesh(newParams); 64 | } 65 | 66 | virtual void voxel(const float* params) const 67 | { 68 | float newParams[4]={ 69 | Distributions::UniformSample(params[2]*1.5*0.6,params[2]*1.5,params[0]), 70 | 1.2, 71 | params[1], 72 | 2.0}; 73 | StemSymbol::voxel(newParams); 74 | } 75 | 76 | virtual const char* symbolName() const 77 | { return "Stem_4"; } 78 | 79 | //##################################################################### 80 | }; 81 | 82 | //##################################################################### 83 | } // namespace ProceduralModeling 84 | 85 | #endif //_STEM_4_SYMBOL_HPP_ 86 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/Stem_8Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _STEM_8_SYMBOL_HPP_ 6 | #define _STEM_8_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "StemSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class Stem_8Symbol 15 | //##################################################################### 16 | class Stem_8Symbol : public StemSymbol 17 | { 18 | public: 19 | Stem_8Symbol(Symbol** symbolTable) 20 | :StemSymbol(true,1,4,1,2,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[4]={ 26 | Distributions::UniformSample(params[2]*0.6,params[2],params[0]), 27 | 1.2, 28 | params[1], 29 | 2.0}; 30 | StemSymbol::render(newParams); 31 | } 32 | 33 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 34 | { 35 | output[0].mID=328; 36 | memcpy(output+1,input,sizeof(SymbolEntry)*3); 37 | logProbability=0; 38 | return 4; 39 | } 40 | 41 | virtual ushort setFlags(const float* params) const 42 | { 43 | return SymbolEntry::DETERMINISTIC; 44 | } 45 | 46 | virtual float logDiffusionProbability(const float* params) const 47 | { 48 | return log(Distributions::UniformEval(params[2]*0.6,params[2],params[0])); 49 | } 50 | 51 | virtual void initGraphics() 52 | { 53 | StemSymbol::initGraphics(); 54 | } 55 | 56 | virtual void saveToMesh(const float* params) const 57 | { 58 | float newParams[4]={ 59 | Distributions::UniformSample(params[2]*0.6,params[2],params[0]), 60 | 1.2, 61 | params[1], 62 | 2.0}; 63 | StemSymbol::saveToMesh(newParams); 64 | } 65 | 66 | virtual void voxel(const float* params) const 67 | { 68 | float newParams[4]={ 69 | Distributions::UniformSample(params[2]*0.6,params[2],params[0]), 70 | 1.2, 71 | params[1], 72 | 2.0}; 73 | StemSymbol::voxel(newParams); 74 | } 75 | 76 | virtual const char* symbolName() const 77 | { return "Stem_8"; } 78 | 79 | //##################################################################### 80 | }; 81 | 82 | //##################################################################### 83 | } // namespace ProceduralModeling 84 | 85 | #endif //_STEM_8_SYMBOL_HPP_ 86 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/Stem_9Symbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _STEM_9_SYMBOL_HPP_ 6 | #define _STEM_9_SYMBOL_HPP_ 7 | 8 | #include "Distributions.hpp" 9 | #include "StemSymbol.hpp" 10 | 11 | namespace ProceduralModeling{ 12 | 13 | //##################################################################### 14 | // Class Stem_9Symbol 15 | //##################################################################### 16 | class Stem_9Symbol : public StemSymbol 17 | { 18 | public: 19 | Stem_9Symbol(Symbol** symbolTable) 20 | :StemSymbol(true,1,4,1,2,symbolTable) 21 | {} 22 | 23 | virtual void render(const float* params) const 24 | { 25 | float newParams[4]={ 26 | Distributions::UniformSample(params[2]*0.6,params[2],params[0]), 27 | 1.2, 28 | params[1], 29 | 2.0}; 30 | StemSymbol::render(newParams); 31 | } 32 | 33 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 34 | { 35 | output[0].mID=332; 36 | memcpy(output+1,input,sizeof(SymbolEntry)*3); 37 | logProbability=0; 38 | return 4; 39 | } 40 | 41 | virtual ushort setFlags(const float* params) const 42 | { 43 | return SymbolEntry::DETERMINISTIC; 44 | } 45 | 46 | virtual float logDiffusionProbability(const float* params) const 47 | { 48 | return log(Distributions::UniformEval(params[2]*0.6,params[2],params[0])); 49 | } 50 | 51 | virtual void initGraphics() 52 | { 53 | StemSymbol::initGraphics(); 54 | } 55 | 56 | virtual void saveToMesh(const float* params) const 57 | { 58 | float newParams[4]={ 59 | Distributions::UniformSample(params[2]*0.6,params[2],params[0]), 60 | 1.2, 61 | params[1], 62 | 2.0}; 63 | StemSymbol::saveToMesh(newParams); 64 | } 65 | 66 | virtual void voxel(const float* params) const 67 | { 68 | float newParams[4]={ 69 | Distributions::UniformSample(params[2]*0.6,params[2],params[0]), 70 | 1.2, 71 | params[1], 72 | 2.0}; 73 | StemSymbol::voxel(newParams); 74 | } 75 | 76 | virtual const char* symbolName() const 77 | { return "Stem_9"; } 78 | 79 | //##################################################################### 80 | }; 81 | 82 | //##################################################################### 83 | } // namespace ProceduralModeling 84 | 85 | #endif //_STEM_9_SYMBOL_HPP_ 86 | -------------------------------------------------------------------------------- /GrammarGen/Source/Willow/WidthSymbol.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _WIDTH_SYMBOL_HPP_ 6 | #define _WIDTH_SYMBOL_HPP_ 7 | 8 | #include "Arrays.hpp" 9 | #include "Distributions.hpp" 10 | #include "Symbol.hpp" 11 | #include "Width.hpp" 12 | 13 | namespace ProceduralModeling{ 14 | 15 | //##################################################################### 16 | // Class WidthSymbol 17 | //##################################################################### 18 | class WidthSymbol : public Symbol 19 | { 20 | public: 21 | WidthSymbol(Symbol** symbolTable) 22 | :Symbol(true,1,2,0,1,symbolTable) 23 | {} 24 | 25 | WidthSymbol(const bool isTerminal,const uint maxNumSymbols,const uint maxNumSymbolEntries,const uint numDiffusionParams,const uint numFormalParams,Symbol** symbolTable) 26 | :Symbol(isTerminal,maxNumSymbols,maxNumSymbolEntries,numDiffusionParams,numFormalParams,symbolTable) 27 | {} 28 | 29 | virtual uint produce(const SymbolEntry* input,SymbolEntry* output,float& logProbability) const 30 | { 31 | output[0].mID=201; 32 | memcpy(output+1,input,sizeof(SymbolEntry)*1); 33 | logProbability=0; 34 | return 2; 35 | } 36 | 37 | virtual ushort setFlags(const float* params) const 38 | { 39 | return SymbolEntry::DETERMINISTIC; 40 | } 41 | 42 | virtual void render(const float* params) const 43 | { 44 | setWidth(params[0]); 45 | } 46 | 47 | virtual void initGraphics() 48 | { 49 | 50 | } 51 | 52 | virtual void saveToMesh(const float* params) const 53 | { 54 | 55 | } 56 | 57 | virtual void voxel(const float* params) const 58 | { 59 | 60 | } 61 | 62 | virtual const char* symbolName() const 63 | { return "Width"; } 64 | 65 | //##################################################################### 66 | }; 67 | 68 | //##################################################################### 69 | } // namespace ProceduralModeling 70 | 71 | #endif //_WIDTH_SYMBOL_HPP_ 72 | -------------------------------------------------------------------------------- /ProcModeler/src/Main.cpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | 6 | #include 7 | #include 8 | #include 9 | #include "Common.hpp" 10 | #include "ModelWindow.hpp" 11 | 12 | //#################################################################### 13 | // Entry point 14 | //##################################################################### 15 | int main(int argc,char** argv) 16 | { 17 | QApplication application(argc,argv); 18 | QStringList args=application.arguments(); 19 | WidgetType widgetType=IMAGE; 20 | 21 | bool validArgs=true; 22 | 23 | if(args.size()==1) widgetType=IMAGE; 24 | else if(args.size()==2) 25 | { 26 | if(args.at(1)=="-image" || args.at(1)=="-i") widgetType=IMAGE; 27 | else validArgs=false; 28 | } 29 | else validArgs=false; 30 | 31 | if(!validArgs){ std::cout<<"Usage: ./ProcModeler [-image (-i) | -voxel (-v)]"< 8 | #include 9 | #include 10 | 11 | class ModelRenderWidget; 12 | 13 | //#################################################################### 14 | // Class ModelSimulation 15 | //#################################################################### 16 | class ModelSimulation 17 | { 18 | 19 | protected: 20 | QString mName,mLibraryName,mPathName; 21 | unsigned long mNumIterations; 22 | ModelRenderWidget* mModelWidget; 23 | static QDir mBaseDir; 24 | 25 | public: 26 | QString pathName() const 27 | { return QString(mPathName); } 28 | 29 | QString libraryPath() const 30 | { return mPathName+"/"+mLibraryName; } 31 | 32 | QString modelPath() const 33 | { return mPathName+"/"+"siggraph_s"+QString::number(mNumIterations)+".psim"; } 34 | 35 | static QString getBasePath() 36 | { return QString(getenv("PROC_MOD_BASE_DIR"))+"/Simulations/"; } 37 | 38 | QString name() const 39 | { return QString(mName); } 40 | 41 | unsigned long getNumIterations() const 42 | { return mNumIterations; } 43 | 44 | public: 45 | ModelSimulation(QString name,QString libraryName,QString pathName,unsigned long numIterations,ModelRenderWidget* modelWidget); 46 | ~ModelSimulation(); 47 | 48 | static ModelSimulation* newSimulation(QString name,QDir dir,QFile& library,ModelRenderWidget* modelWidget); 49 | static ModelSimulation* loadSimulation(QFile& simFile,ModelRenderWidget* modelWidget); 50 | 51 | void save(); 52 | void update(const unsigned long& numIterations); 53 | //#################################################################### 54 | }; 55 | 56 | #endif //__MODEL_SIMULATION__ 57 | -------------------------------------------------------------------------------- /ProcModeler/src/SketchBasedProceduralModel.cpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | //##################################################################### 4 | #include 5 | #include 6 | #include "SketchBasedProceduralModel.hpp" 7 | using ProceduralModeling::ProductionList; 8 | using ProceduralModeling::Math::sqr; 9 | 10 | //##################################################################### 11 | // Function likelihood 12 | //##################################################################### 13 | float SketchBasedProceduralModel::logLikelihood(const ProductionList& model) const 14 | { 15 | const QImage& sketchImage=mSketchingWidget.image(); 16 | QImage renderedImage=static_cast(mRenderWidget)->getModelImage(model); 17 | 18 | float logProb=0; 19 | 20 | uint width=sketchImage.width(),height=sketchImage.height(); 21 | 22 | float multiplierSum=mFalseNegativeMultiplier+mFalsePositiveMultiplier; 23 | float falseNegMultiplier=mFalseNegativeMultiplier/multiplierSum; float falsePosMultiplier=mFalsePositiveMultiplier/multiplierSum; 24 | float finalLikelihoodMultiplier=mLikelihoodMultiplier*(-50.f)/sqrtf((float)(width*height)); 25 | 26 | if(mIgnoreColor) 27 | { 28 | for(uint j=0;jmValueThreshold) logProb+=falsePosMultiplier; 32 | if(targetVal>mValueThreshold && sampleVal 13 | #include 14 | #include 15 | 16 | using std::bitset; 17 | 18 | namespace ProceduralModeling{ 19 | 20 | //#################################################################### 21 | // Class BBoxHelper 22 | //#################################################################### 23 | class PROCEDURAL_EXPORT BBoxHelper 24 | { 25 | public: 26 | int mWidth,mHeight; 27 | float mMinX,mMinY,mMinZ; 28 | float mRangeX,mRangeY,mRangeZ; 29 | bitset** mBBoxInfo; 30 | QMatrix4x4 mTransformMatrix; 31 | QStack mStack; 32 | 33 | public: 34 | BBoxHelper(int w,int h,float x1,float x2,float y1,float y2,float z1,float z2); 35 | ~BBoxHelper(); 36 | void saveToBBoxInfo(float x1,float x2,float y1,float y2,float z1,float z2); 37 | void saveToMesh(); 38 | void saveToFile(const QString& path); 39 | void reset(); 40 | //#################################################################### 41 | }; 42 | 43 | //#################################################################### 44 | } // namespace ProceduralModeling 45 | 46 | #endif // __BOUNDINGBOX_HELPER__ 47 | -------------------------------------------------------------------------------- /libProcModel/src/Math.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | // This software is governed by the license contained in LICENSE. 4 | //##################################################################### 5 | #ifndef _MATH_HPP_ 6 | #define _MATH_HPP_ 7 | 8 | #include 9 | #include 10 | #include 11 | 12 | #define PI_OVER_TWO (1.57079633) 13 | #define TWO_PI (6.28318531) 14 | #define HALF_LOG_TWO_PI (0.399089934) 15 | #define SQRT_TWO_PI (2.50662827) 16 | 17 | namespace ProceduralModeling{ 18 | 19 | namespace Math{ 20 | 21 | template 22 | inline bool isNan(const T x) 23 | { return x!=x; } 24 | 25 | template 26 | inline T min(const T a,const T b) 27 | {return a < b ? a : b;} 28 | 29 | template 30 | inline T min(const T a,const T b,const T c) 31 | {return min(a,min(b,c));} 32 | 33 | template 34 | inline T max(const T a,const T b) 35 | {return a > b ? a : b;} 36 | 37 | template 38 | inline T max(const T a,const T b,const T c) 39 | {return max(a,max(b,c));} 40 | 41 | template 42 | inline int round(const T x) 43 | { return int(x+.5f); } 44 | 45 | inline float sqr(const float x) 46 | { return x*x; } 47 | 48 | inline float uniformZeroToOne() 49 | { return (float)rand()/((float)RAND_MAX+1.f); } 50 | 51 | inline int uniformInRange(const int min,const int max) 52 | { return min+int((max-min+1)*uniformZeroToOne()); } 53 | 54 | inline float clampNonNegative(const float x) 55 | { return x>0?x:0; } 56 | 57 | //##################################################################### 58 | } // namespace Math 59 | 60 | //##################################################################### 61 | } // namespace ProceduralModeling 62 | 63 | #endif //_MATH_HPP_ 64 | -------------------------------------------------------------------------------- /libProcModel/src/SymbolEntry.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright 2009, Jerry Talton. 3 | //##################################################################### 4 | #ifndef __SYMBOL_ENTRY_HPP__ 5 | #define __SYMBOL_ENTRY_HPP__ 6 | 7 | #include 8 | 9 | namespace ProceduralModeling{ 10 | 11 | //##################################################################### 12 | // Union SymbolEntry 13 | //##################################################################### 14 | union SymbolEntry 15 | { 16 | enum FLAGS {CLEAR=0x0,INVALID=0x1,DETERMINISTIC=0x2}; 17 | 18 | public: 19 | uint mID; 20 | ushort mFlags; 21 | float mParam; 22 | 23 | public: 24 | bool isJumpable() const 25 | { return !(mFlags & (INVALID | DETERMINISTIC)); } 26 | 27 | bool isInvalid() const 28 | { return mFlags & INVALID; } 29 | 30 | bool isDeterministic() const 31 | { return mFlags & DETERMINISTIC; } 32 | 33 | //##################################################################### 34 | }; 35 | 36 | typedef QVector SymbolEntryList; 37 | 38 | //#################################################################### 39 | } // namespace ProceduralModeling 40 | 41 | inline QDataStream& operator<<(QDataStream& out,const ProceduralModeling::SymbolEntry& entry) 42 | { return out<>(QDataStream& in,ProceduralModeling::SymbolEntry& entry) 45 | { return in>>entry.mParam; } 46 | 47 | #endif // __SYMBOL_ENTRY__ 48 | --------------------------------------------------------------------------------