* Adaptation to new classes Rule, RuleSet

[lsystem3d.git] / src / lindenmayersystem.cpp

// Copyright (C) 2006 Erik Dahlberg
// 
// This file is part of LSystem3D.
// 
// LSystem3D is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
// 
// LSystem3D is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with LSystem3D; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA




#include <cmath>

#include <string>

#include "lindenmayersystem.h"
#include "model.h"
#include "rule.h"
#include "ruleset.h"
#include "turtle.h"

using namespace std;



/**
 * Constructor
 * @param model empty model
 */
LindenmayerSystem::LindenmayerSystem(Model *model)
{
    _model = model;
    _turtle = new Turtle(model);
    
    clear();
}



/**
 * Destructor
 */
LindenmayerSystem::~LindenmayerSystem()
{
    delete _turtle;
}



/**
 * Clear all parameters
 */
void LindenmayerSystem::clear()
{
    _axiom.clear();
    _rules.clear();
    _turtle->setAngle(0.0);
    _depth = 0;
    
    _turtle->reset();
    _model->clear();
}



/**
 * Generate L-system data
 */
void LindenmayerSystem::generate()
{
    // model session
    _model->begin();
        _model->setColorIndex(0);
        recursiveWalk(_axiom.getPreprocessedContent(), _depth);
    _model->end();
}



/**
 * Set the initial rule (the axiom)
 * @param axiom the axiom
 */
void LindenmayerSystem::setAxiom(Rule axiom)
{
    _axiom = axiom;
}



/**
 * Set one rule
 * @param rule the rule
 */
void LindenmayerSystem::setRule(Rule rule)
{
    _rules.addRule(rule);
}



/**
 * Set the turn/pitch/roll angle
 * @param degrees the angle, in degrees
 */
void LindenmayerSystem::setAngle(double degrees)
{
    // convert from degrees to radians
    double radians = (degrees / 360.0) * (2.0 * M_PIl);
    
    _turtle->setAngle(radians);
}



/**
 * Set depth of recursion
 * @param depth depth of recursion
 */
void LindenmayerSystem::setDepth(int depth)
{
    _depth = depth;
}



/**
 * Set diameter of segment
 * @param diameter the diameter
 */
void LindenmayerSystem::setDiameter(double diameter)
{
    _model->setDiameter(diameter);
}



/**
 * Set diameter factor
 * @param diameterFactor the diameter factor
 */
void LindenmayerSystem::setDiameterFactor(double diameterFactor)
{
    _model->setDiameterFactor(diameterFactor);
}



/**
 * Get the initial rule (the axiom)
 * @return the axiom
 */
Rule LindenmayerSystem::getAxiom()
{
    return _axiom;
}



/**
 * Get all rules
 * @return the rules
 */
RuleSet LindenmayerSystem::getRules()
{
    return _rules;
}



/**
 * Get the turn/pitch/roll angle
 * @return the angle, in degrees
 */
double LindenmayerSystem::getAngle()
{
    double radians = _turtle->getAngle();
    
    // convert from radians to degrees
    double degrees = 360.0 * (radians / (2.0 * M_PIl));
    
    return degrees;
}



/**
 * Get depth of recursion
 * @return depth of recursion
 */
int LindenmayerSystem::getDepth()
{
    return _depth;
}



/**
 * Get the generated model
 * @return generated model
 */
Model *LindenmayerSystem::getModel()
{
    return _model;
}



/**
 * Recursively apply the replacement rules
 * @param rule rule
 * @param level recursion level
 */
void LindenmayerSystem::recursiveWalk(string rule, int level)
{
    // process every element in the rule string
    for (int i = 0; i < rule.size(); i++)
    {
        switch (rule[i])
        {
            // rule
            case '@':

                // ignore marker, i.e. the "@"
                i++;
                
                // recursion
                if (level > 0)
                {
                    string name = rule.substr(i, 1);
                    recursiveWalk(_rules.findRule(name).getPreprocessedContent(), level - 1);
                }
                    
                break;
                
                
            // walk / rule
            case 'F':
                
                {
                    // replacement rule for 'F'?
                    Rule rule = _rules.findRule("F");
                    if (rule.getProbability() != 0.0 && level > 0)
                    {
                        recursiveWalk(rule.getPreprocessedContent(), level - 1);
                    }
                    else
                    {
                        // no rule for "F"
                        _turtle->walk();
                    }
                }      
                                     
                break;
                
                
            // turn left
            case '+':
                
                _turtle->turnLeft();
                break;
                
                
            // turn right
            case '-':
                
                _turtle->turnRight();
                break;
                
                
            // pitch down
            case '&':
            
                _turtle->pitchDown();
                break;
                
                
            // pitch up
            case '^':
                
                _turtle->pitchUp();
                break;
                
                
            // roll left
            case '\\':
                
                _turtle->rollLeft();
                break;
                
                
            // roll right
            case '/':
                    
                _turtle->rollRight();
                break;
                
                
            // turn around 180 degrees
            case '|':
                
                _turtle->turnAround();
                break;
                
                
            // save state to stack
            case '[':
                
                _turtle->push();
                break;
                
                
            // load state from stack
            case ']':
                
                _turtle->pop();
                break;
                
                
            // create a filled surface
            case '{':
                
                _model->fillBegin();
                break;
                
                
            // close a filled surface
            case '}':
                
                _model->fillEnd();
                break;
                
                
            // one vertex in a filled surface
            case 'f':
                
                _turtle->fillWalk();
                break;
                
                
            // decrement diameter of segment
            case '!':
                
                _model->decrementDiameter();
                break;
                
                
            // increment current index to color table
            case '\'':
                
                _model->nextColor();
                break;
                
                
            // decrement current index to color table
            case ',':
                
                _model->prevColor();
                break;
        }
    }
}