grid.cpp

Go to the documentation of this file.

/*
    RenderStack  Support library for OpenGL 3+
    Copyright (C) 2010  Timo Suoranta

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library 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
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "renderstack/buffer.hpp"
#include "renderstack/mesh.hpp"
#include "renderstack/rs_gl.h"
#include "renderstack/grid.hpp"

namespace renderstack {

grid::grid(float cell_width, int positive_cell_count)
{
    /*    2   9  11  13   3    0.. 3  corners              */ 
    /*                         2.. 7  min_x...max_x lines  */ 
    /*    6   .   .   .   7    8..13  min_z..,max_z lines  */ 
    /*                                                     */ 
    /*    4   .   x   .   5    positive_cell_count = 2     */ 
    /*                                                     */ 
    /*    2   .   .   .   3                                */ 
    /*                                                     */ 
    /*    0   8  10  12   1                                */ 

    /*  Setup vertex format  */ 
    vertex_attribute position(vertex_attribute_usage_position, GL_FLOAT, 0, 3);
    vertex_buffer()->vertex_format().append(position);

    /*  Initialize buffers  */ 
    buffer *vertex_buffer = mesh::vertex_buffer();
    buffer *index_buffer = mesh::find_or_create_index_buffer(
        mesh_mode_edge_lines,
        GL_ELEMENT_ARRAY_BUFFER, 
        GL_STATIC_DRAW, 
        GL_UNSIGNED_INT, 
        GL_LINES
    );

    /*  Prepare writing to buffers  */ 
    int vertex_index  = 0;
    int index         = 0;

    vertex_buffer->begin_edit();
    index_buffer->begin_edit();

    float extreme = (float)(positive_cell_count) * cell_width;

    /*  Corner vertices  */ 
    {
        vertex_buffer->set_index(index++); vertex_buffer->put_position(-extreme, -extreme, 0.0f);
        vertex_buffer->set_index(index++); vertex_buffer->put_position( extreme, -extreme, 0.0f);
        vertex_buffer->set_index(index++); vertex_buffer->put_position(-extreme,  extreme, 0.0f);
        vertex_buffer->set_index(index++); vertex_buffer->put_position( extreme,  extreme, 0.0f);
    }

    /*  min x...max x vertices  */ 
    {
        /*  min z :  min_x...max_x  */ 
        {
            index_buffer->set_index(vertex_index);
            index_buffer->line(0, 1);
            vertex_index += 2;
        }
        {
            int z;
            int range = (positive_cell_count - 1);

            for(z = -range; z <= range; ++z)
            {
                float   z_position = (float)(z) * cell_width;
                int     v0 = index++;
                int     v1 = index++;
                vertex_buffer->set_index(v0); vertex_buffer->put_position(-extreme, z_position, 0.0f);
                vertex_buffer->set_index(v1); vertex_buffer->put_position( extreme, z_position, 0.0f);
                index_buffer->set_index(vertex_index);
                index_buffer->line(v0, v1);
                vertex_index += 2;
            }
        }

        /*  max z :  min_x...max_x  */ 
        {
            index_buffer->set_index(vertex_index);
            index_buffer->line(2, 3);
            vertex_index += 2;
        }
    }

    /*  min z...max z vertices  */ 
    {
        /*  min x :  min_z...max_z  */ 
        {
            index_buffer->set_index(vertex_index);
            index_buffer->line(0, 2);
            vertex_index += 2;
        }

        {
            int x;
            int range = (positive_cell_count - 1);

            for(x = -range; x <= range; ++x)
            {
                float   x_position = (float)(x) * cell_width;
                int     v0 = index++;
                int     v1 = index++;
                vertex_buffer->set_index(v0); vertex_buffer->put_position(x_position, -extreme, 0.0f);
                vertex_buffer->set_index(v1); vertex_buffer->put_position(x_position,  extreme, 0.0f);
                index_buffer->set_index(vertex_index);
                index_buffer->line(v0, v1);
                vertex_index += 2;
            }
        }

        /*  max x :  min_z...max_z  */ 
        {
            index_buffer->set_index(vertex_index);
            index_buffer->line(1, 3);
            vertex_index += 2;
        }
    }

    /*  Done  */ 
    vertex_buffer->end_edit(index);
    index_buffer->end_edit(vertex_index);
}

}