L_System.cpp

Go to the documentation of this file.

#include "L_System.h"
L_System::L_System(int w, int h, std::string t)
{
    //set parameter
    width = w; height = h;
    segmentcount = 0;
    type = t;

    initCurve(width, height); //initialize the standart curve

    // initialize the indivitual curveparameters
    if(strcmp(type.c_str(),"hilbert")==0)
    {
        initHilbert();
    }
    if(strcmp(type.c_str(),"gosper")==0)
    {
        initGosper();
    }

    // initialize the needed buffers
    GLuint posbuf;
    glGenBuffers(1, &posbuf);
    glBindBuffer(GL_ARRAY_BUFFER, posbuf);
    glBufferData(GL_ARRAY_BUFFER, positioncount[0] * sizeof(float), &points[0][0], GL_STATIC_DRAW); 
    glBindBuffer(GL_ARRAY_BUFFER, 0);

    GLuint vaobuf;
    glGenVertexArrays(1,&vaobuf);
    glBindVertexArray(vaobuf);

    glBindBuffer(GL_ARRAY_BUFFER, posbuf);
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
    positionBuffer.push_back(posbuf);
    vao.push_back(vaobuf);

    glBindVertexArray(0);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
}

void L_System::initCurve(int width, int height)
{
        distance = std::min(width,height);  //set length for the curvesegments
        double poscount = 4 * 3;            //set the positioncount
        positioncount.push_back(poscount);
        iteration = 1;                      //initialize the current maximum order
        drawingIteration = iteration - 1;   //initialize the current order, whitch will be drawend

        //initialize a curve for order 0
        glm::vec3 point;                
        std::vector<glm::vec3> pos;
        point = glm::vec3(-0.9f,-0.9f,0.0f);
        pos.push_back(point);
        point = glm::vec3(-0.9f,0.9f,0.0f);
        pos.push_back(point);
        point = glm::vec3(0.9f,0.9f,0.0f);
        pos.push_back(point);
        point = glm::vec3(0.9f,-0.9f,0.0f);
        pos.push_back(point);

        points.push_back(pos);
}
void L_System::initHilbert()
{
    rules.clear();                      //clear rules
    delta = 90;                         //90 degrees
    //set up the rules for the hilbert curve
    currentString = "L";    
    std::string rule1 = "L->+RF-LFL-FR+";
    rules.push_back(rule1);
    std::string rule2 = "R->-LF+RFR+FL-";
    rules.push_back(rule2);

    iterate();  //make an initial iteration
}
void L_System::initGosper()
{
    rules.clear();                      //clear rules
    delta = 60;                         //60 degrees
    //set up the rules for the gosper curve
    currentString = "RF";
    //std::string rule1 = "L->LF-RF--RF+LF++LFLF+RF-";
    std::string rule1 = "L->L+RF++RF-FL--FLFL-RF+";
    rules.push_back(rule1);
    //std::string rule2 = "R->+LF-RFRF--RF-LF++LF+RF";
    std::string rule2 = "R->-FL+RFRF++RF+FL--FL-R";
    rules.push_back(rule2);

    iterate();  //make an initial iteration
}

std::string L_System::getRule(char var)
{
    for (int i = 0; i < rules.size(); i++)  //searching for a rule of char
    {
        std::string rule = rules[i];
        if (rule[0] == var)                 //if a rule exists. return it 
            return rules[i].substr(3,rules[i].length());
    }
    return std::string(&var);               //otherwise return the char
}

L_System::~L_System(void)
{
    for(int i = 0; i < positionBuffer.size();i++) //free the space of the buffers
    {
        glDeleteBuffers(1, &positionBuffer[i]);
        glDeleteVertexArrays(1, &vao[i]);
    }
}

void L_System::draw(GLuint shader)
{   
    //set the color for the curve in the shader
    auto baseColor_location = glGetUniformLocation(shader, "color"); 
    glUniform4f(baseColor_location, 0.0f, 0.5f, 0.0f, 1.0f);

    //draw the curve with linewidth 2.0
    glLineWidth(2.0);
    glBindVertexArray(vao[drawingIteration]);
    glDrawArrays(GL_LINE_STRIP,0, positioncount[drawingIteration]/3);
    glBindVertexArray(0);
    glLineWidth(1.0);   
}
double L_System::degToRad(double angle)
{
    return (M_PI * angle) / 180;
}
int L_System::getSegmentCount()
{
    return segmentcount;
}
int L_System::getIteration()
{
    return iteration-1;
}
int L_System::getDrawingIteration()
{
    return drawingIteration;
}
void L_System::setDrawingIteration(int order)
{
    if(order < iteration-1)
    {
        drawingIteration = order+1;
    }
}
std::string L_System::getType()
{
    return type;
}
void L_System::increaseDrawingIteration()
{
    if(drawingIteration == (iteration-1))   //if the current drawing order equal the current maximum order, calculate the points for the new maximal order
    {
        iterate();
    }else{
        drawingIteration++;                 //otherwise increase the drawing order by one
    }
}
void L_System::decreaseDrawingIteration()
{
    if (drawingIteration > 1) //if the current drawing order grater than 1, decrease the order by one
    {
        drawingIteration--;
    }
}
std::vector<glm::vec3> L_System::getPoints(int order)
{
    if((order+1) >= iteration)          //if order is grater than the current maximum order. Calculate all orders up to the given order
    {
        for(int i = 0; i < ((order+2) - iteration);i++)
        {
            iterate();
        }
    }
    return points[order+1];             //return the points
}
void L_System::iterate()
{
    iteration++;                        //increase the current maximum order
    drawingIteration = iteration - 1;   //update the current drawing order
    //set up the length of the curve segments, dependent on the curve type
    // It would be better to get the maximum and minimum position of the Curve and map them into the rigth space. But i have no time for this. Maybe in the next version
    if(iteration > 0)   
    {
        if(strcmp(type.c_str(),"hilbert")==0)
        {
            double nenner = std::pow(2,(iteration+1));
            distance = (1.8/(nenner-1)) * 8;
        }
        if(strcmp(type.c_str(),"gosper")==0)
        {
            double nenner = std::pow(2.7,(iteration+1));
            distance = (1.8/(nenner-1)) * 16;
        }
    }

    //set up a new state and outstring
    std::string tmp = "" ;
    state dummystate(-0.9f,-0.9f,0);
    std::vector<glm::vec3> dummypoints;

    //set up the individual starting points
    if(strcmp(type.c_str(),"hilbert")==0)
    {
        segmentcount = pow(4,(iteration-1))-1;
        dummystate.x = -0.9f;
        dummystate.y = -0.9f;
    }
    if(strcmp(type.c_str(),"gosper")==0)
    {
        segmentcount = (int)pow(7,(iteration-1));
        dummystate.x = -0.7f + (float)(iteration - 3)/25;
        dummystate.y = 0.0f - (float)(iteration - 3)/5;
    }

    glm::vec3 dummypoint;
    dummypoint = glm::vec3(dummystate.x, dummystate.y, 0.0f);
    dummypoints.push_back(dummypoint);

    for (int i = 0; i < currentString.length(); i++) //iterate threw the current string
    {
        switch (currentString[i])
        {
            case 'F':   //F means draw a Curve segment. In this project, there is no need to check if F has a rule. Would only need time.
            {
                    /*int index = existRule(text[i]);
                    if (index > -1)
                    {
                        tmp += rules[index];
                    }
                    else
                    {*/
                        //
                        dummystate.x += distance * std::cos(degToRad(dummystate.angle));
                        dummystate.y += distance * std::sin(degToRad(dummystate.angle));
                        tmp += 'F';

                        glm::vec3 dummypoint;
                        dummypoint = glm::vec3(dummystate.x, dummystate.y, 0.0f);
                        dummypoints.push_back(dummypoint);
                     //}

                    break;
           }
            /*case 'f': //f means go further in the curve without drawing. Until there are no holes in the space filling curves, there is no need to check for this
           {
                    dummy.x += distance * Math.Cos(degToRad(dummy.angle));
                    dummy.y += distance * Math.Sin(degToRad(dummy.angle));

                    int index = existRule(text[i]);
                    if (index > -1)
                    {
                        tmp += rules[index];
                    }
                    else
                    {
                        tmp += 'f';
                    }
                    break;
            }*/
            case '+': //+ means rotate the angle for the next line segment
            {
                    dummystate.angle += delta;
                    tmp += '+';
                    break;
            }
            case '-': //- means rotate the angle for the next line segment
            {
                    dummystate.angle -= delta;
                    tmp += '-';
                    break;
            }
            /*
            // [,] are operators to split the curves in subcurves an go threw every subcurve in each iterations. Space filling curves doesnt have this, so check this only needs time for nothing
            case '[':
            {
                    //statestack.Push(dummy);
                    tmp += '[';
                    break;
                    }
            case ']':
            {
                    //dummy = statestack.Pop();
                    tmp += ']';
                    break;
            }
            */
            default: //check if the churrent char is a rule
            {
                char isrule = currentString[i];
                tmp += getRule(isrule);
                break;
           }
       }
    }
    //push back the new points
    points.push_back(dummypoints);
    currentString = tmp;    
    //set the positioncount for this iteration order
    int poscount = points[iteration-1].size() * 3;
    positioncount.push_back(poscount);

    //set all the buffers for this iteration order
    GLuint posbuf;
    glGenBuffers(1, &posbuf);
    glBindBuffer(GL_ARRAY_BUFFER, posbuf);
    glBufferData(GL_ARRAY_BUFFER, poscount/*Anzahl Knoten*/  * sizeof(float), &points[iteration-1][0], GL_STATIC_DRAW); 
    glBindBuffer(GL_ARRAY_BUFFER, 0);

    GLuint vaobuf;
    glGenVertexArrays(1, &vaobuf);
    glBindVertexArray(vaobuf);

    glBindBuffer(GL_ARRAY_BUFFER, posbuf);
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
    positionBuffer.push_back(posbuf);
    vao.push_back(vaobuf);

    glBindVertexArray(0);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
}