Minor cleanup.

[lsystem3d.git] / src / turtle.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 <stack>

#include "coordinate.h"
#include "model.h"
#include "turtle.h"
#include "vector.h"

using namespace std;



/**
 * Constructor
 * @param model create this model
 */
Turtle::Turtle(Model *model)
{
    _model = model;
    
    // initial position and orientation
    reset();

    // 90 degrees
    _angle = M_PIl / 2.0;
}



/**
 * Destructor
 */
Turtle::~Turtle()
{
}



/**
 * Reset to default state
 */
void Turtle::reset()
{   
    // put turtle at (0,0,0), head upwards, back towards camera
    
    _position.setXYZ(0.0, 0.0, 0.0);
    
    _heading.setXYZ(0.0, 1.0, 0.0);
    _left.setXYZ(1.0, 0.0, 0.0);
    _up.setXYZ(0.0, 0.0, 1.0);
    
    
    // empty the stacks
    _positionStack = stack<Coordinate>();
    _headingStack = stack<Vector>();
    _leftStack = stack<Vector>();
    _upStack = stack<Vector>();
    _diameterStack = stack<double>();
    _colorIndexStack = stack<int>();
}



/**
 * Turn left
 */
void Turtle::turnLeft()
{
    // rotate around "up vector"
    _heading.rotate(-_angle, _up);
    _left.rotate(-_angle, _up);
}



/**
 * Turn right
 */
void Turtle::turnRight()
{
    // rotate around "up vector"
    _heading.rotate(_angle, _up);
    _left.rotate(_angle, _up);
}



/**
 * Pitch down
 */
void Turtle::pitchDown()
{
    // rotate around "left vector"
    _heading.rotate(-_angle, _left);
    _up.rotate(-_angle, _left);
}



/**
 * Pitch up
 */
void Turtle::pitchUp()
{
    // rotate around "left vector"
    _heading.rotate(_angle, _left);
    _up.rotate(_angle, _left);
}



/**
 * Roll left
 */
void Turtle::rollLeft()
{
    // rotate around "heading vector"
    _left.rotate(_angle, _heading);
    _up.rotate(_angle, _heading);
}



/**
 * Roll right
 */
void Turtle::rollRight()
{
    // rotate around "heading vector"
    _left.rotate(-_angle, _heading);
    _up.rotate(-_angle, _heading);
}



/**
 * Turn around
 */
void Turtle::turnAround()
{
    // rotate 180 degrees around "up vector"
    _heading.rotate(M_PIl, _up);
    _left.rotate(M_PIl, _up);
}



/**
 * Walk forward
 */
void Turtle::walk()
{
    // start point
    double startX = _position.getX();
    double startY = _position.getY();
    double startZ = _position.getZ();
    
    // end point
    double endX = startX + _heading.getX();
    double endY = startY + _heading.getY();
    double endZ = startZ + _heading.getZ();
    
    
    // move turtle to new position
    _position.setXYZ(endX, endY, endZ);
    
    // connect start and end point
    _model->segment(startX, startY, startZ,
                    endX,   endY,   endZ);
}



/**
 * Walk forward, creating a filled surface
 * TODO: merge with walk() ?
 */
void Turtle::fillWalk()
{
    // end point
    double destinationX = _position.getX() + _heading.getX();
    double destinationY = _position.getY() + _heading.getY();
    double destinationZ = _position.getZ() + _heading.getZ();
    
    _model->normal(_up.getX(), _up.getY(), _up.getZ());
    
    // move turtle to new position
    _position.setXYZ(destinationX, destinationY, destinationZ);
    
    // part of a filled polygon
    _model->vertex(destinationX, destinationY, destinationZ);
}



/**
 * Save current state to stack
 */
void Turtle::push()
{
    // position
    _positionStack.push(_position);
    
    // orientation
    _headingStack.push(_heading);
    _leftStack.push(_left);
    _upStack.push(_up);
    
    // diameter
    double diameter = _model->getDiameter();
    _diameterStack.push(diameter);
    
    // color index
    int colorIndex = _model->getColorIndex();
    _colorIndexStack.push(colorIndex);
}



/**
 * Restore old state from stack
 */
void Turtle::pop()
{
    // position
    _position = _positionStack.top();           _positionStack.pop();

    // orientation
    _heading = _headingStack.top();             _headingStack.pop();
    _left = _leftStack.top();                   _leftStack.pop();
    _up = _upStack.top();                       _upStack.pop();
    
    // diameter
    double diameter = _diameterStack.top();        _diameterStack.pop();
    _model->setDiameter(diameter);
    
    // color index
    int colorIndex = _colorIndexStack.top();    _colorIndexStack.pop();
    _model->setColorIndex(colorIndex);
}



/**
 * Set turn/pitch/roll angle
 * @param angle the angle, in radians
 */
void Turtle::setAngle(double radians)
{
    _angle = radians;
}



/**
 * Get turn/pitch/roll angle
 * @return the angle, in radians
 */
double Turtle::getAngle()
{
    return _angle;
}