LandPatch.cpp

#include "LandPatch.h"


LandPatch::LandPatch (float * height_field, int size_x, int size_y, int offset_x, int offset_y, int total_x, int total_y, float stride, int xy_jump)
{
        int x, y;
        int additional_vertex_space;                    // additional space used to cover one level above
        int additional_index_space;                             // additional space used to cover one level above
        int offset;

        // if xy_jump equals one, there is no level above
        if (xy_jump > 1)
        {
                additional_vertex_space = 3 * (2*(size_x-1) + 2*(size_y-1));
                additional_index_space = 3 * (2*(size_x-1) + 2*(size_y-1));
        }
        else
        {
                additional_vertex_space = 0;
                additional_index_space = 0;
        }

        // allocate space
        data = new float[3*size_x*size_y + additional_vertex_space];
        indices = new GLuint[(size_x-1)*(size_y-1) * 2 * 3 + additional_index_space];

        // fill regular grid data
        for (y = 0; y < size_y; y++)
        {
                for (x = 0; x < size_x; x++)
                {
                        data [3*(x + y*size_x)] = x * stride * xy_jump;
                        data [3*(x + y*size_x) + 1] = y * stride * xy_jump; 
                        data [3*(x + y*size_x) + 2] = height_field [(x*xy_jump + offset_x) + ((y*xy_jump + offset_y) * total_x)]; 
                }
        }

        // fill regular grid indices
        for (y = 0; y < size_y - 1; y++)
        {
                for (x = 0; x < size_x - 1; x++)
                {
                        indices [6*(x + y*(size_x-1))+0] = x + y * size_x;
                        indices [6*(x + y*(size_x-1))+1] = (x+1) + (y+1) * size_x;
                        indices [6*(x + y*(size_x-1))+2] = (x) + (y+1) * size_x;
                        indices [6*(x + y*(size_x-1))+3] = x + y * size_x;
                        indices [6*(x + y*(size_x-1))+4] = (x+1) + y * size_x;
                        indices [6*(x + y*(size_x-1))+5] = (x+1) + (y+1) * size_x;
                }
        }

        if (xy_jump > 1)
        {
                // generate data and indices to cover one level above...
                offset = 3 * size_x * size_y;
                for (x = 0; x < size_x - 1; x++)
                {
                        data [3*x + offset] = x * stride * xy_jump + stride * xy_jump / 2;
                        data [3*x + 1 + offset] = 0.0f;
                        data [3*x + 2 + offset] = height_field [(x*xy_jump + offset_x + xy_jump/2) + offset_y * total_x]; 
                }
                offset += 3 * (size_x - 1);
                for (x = 0; x < size_x - 1; x++)
                {
                        data [3*x + offset] = x * stride * xy_jump + stride * xy_jump / 2;
                        data [3*x + 1 + offset] = (size_y-1) * stride * xy_jump;
                        data [3*x + 2 + offset] = height_field [(x*xy_jump + offset_x + xy_jump/2) + (((size_y-1)*xy_jump + offset_y) * total_x)]; 
                }
                offset += 3 * (size_x - 1);
                for (y = 0; y < size_y - 1; y++)
                {
                        data [3*y + offset] = 0.0f;
                        data [3*y + 1 + offset] = y * stride * xy_jump + stride * xy_jump / 2;
                        data [3*y + 2 + offset] = height_field [offset_x + (y*xy_jump + offset_y + xy_jump/2) * total_x];
                }
                offset += 3 * (size_y - 1);
                for (y = 0; y < size_y - 1; y++)
                {
                        data [3*y + offset] = (size_x-1) * stride * xy_jump;
                        data [3*y + 1 + offset] = y * stride * xy_jump + stride * xy_jump / 2;;
                        data [3*y + 2 + offset] = height_field [(size_x-1)*xy_jump + offset_x + (y*xy_jump + offset_y + xy_jump/2) * total_x];
                }

                offset = (size_x-1)*(size_y-1) * 2 * 3;
                for (x = 0; x < size_x - 1; x++)
                {
                        indices [3*x + offset] = x + 1;
                        indices [3*x + 1 + offset] = x;
                        indices [3*x + 2 + offset] = size_x * size_y + x;
                }
                offset += 3 * (size_x - 1);
                for (x = 0; x < size_x - 1; x++)
                {
                        indices [3*x + offset] = x + (size_y-1)*size_x;
                        indices [3*x + 1 + offset] = x + 1 + (size_y-1)*size_x;
                        indices [3*x + 2 + offset] = size_x * size_y + (size_x - 1) + x;
                }
                offset += 3 * (size_x - 1);
                for (y = 0; y < size_y - 1; y++)
                {
                        indices [3*y + offset] = (y) * size_x;
                        indices [3*y + 1 + offset] = (y+1) * size_x;
                        indices [3*y + 2 + offset] =  size_x * size_y + 2 * (size_x - 1) + y;
                }
                offset += 3 * (size_y - 1);
                for (y = 0; y < size_y - 1; y++)
                {
                        indices [3*y + offset] = (size_x-1) + (y+1) * size_x;
                        indices [3*y + 1 + offset] = (size_x-1) + (y) * size_x;
                        indices [3*y + 2 + offset] = size_x * size_y + 2 * (size_x - 1) + (size_y - 1) + y;
                }
        }


        // set up object with the data.
        SetVertexData (data, size_x * size_y + additional_vertex_space / 3);
        SetVertexIndices (indices, (size_x-1)*(size_y-1)*2 + additional_index_space / 3);

        ComputeNormals (false);
}

LandPatch::~LandPatch ()
{
        // nothing to do
}

---