---

r_landscape.cpp

Go to the documentation of this file.

// OMICRON ENGINE HEADER FILE
//
// --------------------------------------------------------------------------
// Copyright (C) 2001-2002 by Bjoern Paetzel <kolrabi@gmx.de>
//
// This file is part of the Omicron Engine.
//
// The Omicron Engine 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.
//
// The Omicron Engine  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 The Omicron Engine;  if not,  write to the  Free Software Foundation,
// Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
//
// --------------------------------------------------------------------------
// Last modified:       $Date: 2002/12/07 19:02:05 $
// By           :       $Author: kolrabi $
// $Id: r_landscape.cpp,v 1.1.1.1 2002/12/07 19:02:05 kolrabi Exp $ 

/*

  $Log: r_landscape.cpp,v $
  Revision 1.1.1.1  2002/12/07 19:02:05  kolrabi
  initial release


*/

#include            <string.h>
#include            "omicron/internal.h"

#include            "omicron/render.h"
#include            "omicron/landscape.h"
#include            "omicron/array.h"
#include            "omicron/image.h"
#include            "omicron/texture.h"

/****************************************************************************
 ****************************************************************************
 * LANDSCAPE CLASS **********************************************************
 ****************************************************************************
 ****************************************************************************/

landscape_c::landscape_c()
{
    nodes   = NULL;
    shaders = NULL;
    deinit();
}

landscape_c::~landscape_c()
{
    AssertThis;

    deinit();
}

void landscape_c::deinit()
{
    SafeArrayDelete(nodes);
    SafeDelete(shaders);

    width   = 
    height  = 0;
    shaders = NULL;
    nodes   = NULL;
    init    = false;

    pos.set     ( 0, 0, 0 );
    scale.set   ( 1, 1, 1 );
}
 
/**************************************************************************** 
 * landscape_create                           creates a new flat landscape * 
 ****************************************************************************/ 
void landscape_c::create 
( 
    ulong       _width,                 
    ulong       _height                 
) 
{ 
    // deinit just to be safe
    deinit();
 
    // set dimensions
    width  = _width; 
    height = _height; 

    // create nodes
    nodes  = new node_s[width*height]; 
 
    // initialize first node
    nodes[0].value = 0; 

    ulong i;

    for (i=0; i<4; i++)
    {
        vec3_c(0,0,1).copy(nodes[0].verts[i].normal);
        nodes[0].verts[i].diffuse = 0xFFFFFFFF; 
        nodes[0].shader = 0;
    }

    nodes[0].flags = 0;

    // copy first node to all other nodes
    for (i=1; i<width*height; i++)
        nodes[i] = nodes[0];
 
    // unifor scale
    scale.set(1,1,1); 

    // every node can have its own shader so create an array
    shaders = new array_c<shader_t>;

    // initialization done
    init  = true;
    update_verts();
} 
 
 
 
/**************************************************************************** 
 * landscape_from_tex               creates a new landscape from a texture * 
 ****************************************************************************/ 
void landscape_c::create_from_texture
( 
    sshort      tex                     
) 
{ 
    image_c         *img;

    // safety first
    deinit();

    // try to get the image information
    img = gv.texman->get_image(tex);

    create_from_image(img);

    SafeDelete(img);

    update_verts();
} 
 
/**************************************************************************** 
 * landscape_from_tex               creates a new landscape from a texture * 
 ****************************************************************************/ 
void landscape_c::create_from_image
( 
    image_c     *img                    
) 
{ 
    ulong           x,y; 

    // safety first
    AssertReturn2(img, img->get_pixels());
    deinit();

    create(img->get_width(), img->get_height());
 
    AssertReturn1(init);

    const char *buf = img->get_pixels();

    for (x=0; x<width; x++) 
        for (y=0; y<height; y++) 
        { 
            nodes[x+y*width].value =  
              (uchar)buf[4*(x+y*width)]; 
            nodes[x+y*width].flags = 0;
        } 
 
    normalize(); 
    create_normals(); 
    scale.set(1,1,1); 

    update_verts();
} 

 
/**************************************************************************** 
 * landscape_from_raw          creates a new landscape from raw 8 bit data * 
 ****************************************************************************/ 
void landscape_c::create_from_raw
( 
    uchar       *raw,                   
    ulong       width,                  
    ulong       height                  
) 
{ 
    ulong           x,y; 
 
    AssertReturn1(raw);

    create(width, height); 
 
    AssertReturn1(init);
    
    for (x=0; x<width; x++) 
        for (y=0; y<height; y++) 
        { 
            nodes[x+y*width].value = raw[(x+y*width)]; 
            nodes[x+y*width].flags = 0;
        } 
 
    normalize(); 
    create_normals(); 
    scale.set(1,1,1); 
} 
 

/**************************************************************************** 
 * landscape_c::prelight                        apply lighting using light * 
 ****************************************************************************/ 
void landscape_c::prelight()
{
    ulong   x, y, idx, i;
    vec3_c  p;
    float   l;

    for (x=0; x<width; x++) 
        for (y=0; y<height; y++) 
        { 
            vec4_c  col;
            idx = x+y*width;

            col.clear();

            for (i = 0; i<gv.lightcount; i++)
            {
                vec4_t colvec;

                color_to_vec(gv.lights[i].color, colvec);

                p = vec3_c(gv.lights[i].pos).normalize();

                l = p.dot(nodes[idx].verts[0].normal);
                if (l<0) l = 0;

                col = col.ma(l, colvec);
            }
            
            nodes[idx].verts[0].diffuse = color_from_floats(V3TOFS(col), 1); 
        } 

    update_verts();
}


/**************************************************************************** 
 * landscape_draw                                        draws a landscape * 
 ****************************************************************************/ 
void landscape_c::draw()
{ 
    ulong   x,y; 
    shader_t    *shad = NULL;
    
    gv.renderer->set_blending(BT_OPAQUE);
    
    for (y=0; y<height; y++) 
    { 
        for (x=0; x<width; x++) 
        { 
            if (!is_node_visible(x,y))
                continue;

            drawntiles++;

            int idx = x+y*width;

            vertex_t *verts = nodes[idx].verts;

            shad = shaders->get(nodes[idx].shader);

            gv.renderer->use_shader(shad);
            gv.renderer->render_verts(verts,4,PT_QUADS);

            /*
            gv.renderer->use_vertices(verts,4);
            gv.texman->set(shad->passes[0].texture);
            gv.renderer->push_vertices(PT_QUADS, 4);
            */
        } 
    } 
} 
 
 
 
/**************************************************************************** 
 * landscape_create_normals       creates lighting normals for a landscape * 
 ****************************************************************************/ 
void landscape_c::create_normals()
{ 
    plane_t     p;
 
    ulong       x,y,i; 
 
    for (i=0; i<width*height; ++i) 
        vec3_c(0,0,0).copy(nodes[i].verts[0].normal); 
 
    for (x=0; x<width; x++) 
        for (y=0; y<height; y++) 
        { 
            ulong   idx[4]; 
            vec3_c  v[4]; 
 
            idx[0] = x+y*width; 
            idx[1] = (x+1)%width+y*width; 
            idx[2] = (x+1)%width+((y+1)%height)*width; 
            idx[3] = x+((y+1)%height)*width; 
 
            for (i=0; i<4; ++i) 
                v[i].set( (x+((i+3)%4)/2)*scale[0], 
                          (y+ (i/2)     )*scale[1],
                          nodes[idx[i]].value*scale[2]); 
 
            for (i=0; i<4; ++i) 
            { 
                p = plane_frompoints(v[i+0], v[(i+1)%4], v[(i+3)%4]); 
 
                // ((vec3_c(nodes[idx[i]].normal)+p.n).normalize()).copy(nodes[idx[i]].normal); 
                (vec3_c(nodes[idx[i]].verts[0].normal)+p.n).copy(nodes[idx[i]].verts[0].normal); 
            } 
        } 
 
    for (i=0; i<width*height; ++i) 
    {
        ((vec3_c(nodes[i].verts[0].normal)).normalize()).copy(nodes[i].verts[0].normal);
        nodes[i].verts[0].normal[2] *= -1;
    }

    update_verts();
} 
 
 
 
/**************************************************************************** 
 * landscape_getheight           gets the height of a landscape at a point * 
 ****************************************************************************/ 
float landscape_c::get_height
( 
    float       x,
    float       y
) 
{ 
//    float h = 0; 
    ulong   xx = (ulong)((x-pos[0])/scale[0]); 
    ulong   yy = (ulong)((y-pos[1])/scale[1]); 
    ulong   side = 0; 
 
    float rx = (x-pos[0])/scale[0]-xx; 
    float ry = (y-pos[1])/scale[0]-yy; 
 
    if (rx<ry) 
        side = 1; 
 
    float hh[4]; 
    ulong idx[4]; 
 
    idx[0] = xx%width+(yy%height)*width; 
    idx[1] = (xx+1)%width+(yy%height)*width; 
    idx[2] = (xx+1)%width+((yy+1)%height)*width; 
    idx[3] = xx+((yy+1)%height)*width; 
 
    for (ulong i=0; i<4; i++) 
        hh[i] = nodes[idx[i]].value; 
 
    float hpx, hpy; 
 
    if (!side) 
    { 
        hpx = hh[1]-hh[0]; 
        hpy = hh[2]-hh[1]; 
    } 
    else 
    { 
        hpx = hh[2]-hh[3]; 
        hpy = hh[3]-hh[0]; 
    } 
 
    return (hh[0]+hpx*rx+hpy*ry)*scale[2]+pos[2]; 
} 


/**************************************************************************** 
 * landscape_c::setheight                        sets the height of a tile *
 ****************************************************************************/ 
void landscape_c::set_height(ulong x, ulong y, float value)
{
    if (x<0 || x>=width || y<0 || y>=height)
        return;

    nodes[x+y*width].value = value;
    update_verts();
}


/**************************************************************************** 
 * landscape_c::setuv                         set uv coordinates of a tile * 
 ****************************************************************************/ 
void landscape_c::set_uv(ulong x, ulong y, ushort corner, float u, float v)
{
    if (x<0 || x>=width || y<0 || y>=height)
        return;

    vec2_c(u,v).copy(nodes[x+y*width].verts[corner].uv[0]);
    update_verts();
}

 
/**************************************************************************** 
 * landscape_getslope                                           get slopes * 
 ****************************************************************************/ 
void landscape_c::get_slope
( 
    float       x,
    float       y,
    vec2_t      out 
) 
{ 
//    float h = 0; 
    ulong xx = (ulong)(x/scale[0]); 
    ulong yy = (ulong)(y/scale[2]); 
    ulong side = 0; 
 
    float rx = x/scale[0]-xx; 
    float ry = y/scale[0]-yy; 
 
    if (rx<ry) 
        side = 1; 
 
    float hh[4]; 
    ulong     idx[4]; 
 
    idx[0] = xx%width+(yy%height)*width; 
    idx[1] = (xx+1)%width+(yy%height)*width; 
    idx[2] = (xx+1)%width+((yy+1)%height)*width; 
    idx[3] = xx+((yy+1)%height)*width; 
 
    for (ulong i=0; i<4; i++) 
        hh[i] = nodes[idx[i]].value; 
 
    if (!side) 
    { 
        out[0] = hh[1]-hh[0]; 
        out[1] = hh[2]-hh[1]; 
    } 
    else 
    { 
        out[0] = hh[2]-hh[3]; 
        out[1] = hh[3]-hh[0]; 
    } 
} 
 
 
 
/**************************************************************************** 
 * landscape_normalize                               normalize a landscape * 
 ****************************************************************************/ 
void landscape_c::normalize()
{ 
    float highest = 0; 
    float lowest  = 0; 
    ulong x; 
 
    for (x=0; x<width*height; x++) 
        if (nodes[x].value<lowest) 
            lowest = nodes[x].value; 
 
    for (x=0; x<width*height; x++) 
        nodes[x].value -= lowest; 
 
    for (x=0; x<width*height; x++) 
        if (nodes[x].value>highest) 
            highest = nodes[x].value; 
 
    if (highest)
    for (x=0; x<width*height; x++) 
        nodes[x].value /= highest; 

    update_verts();
} 
 
 
 
/**************************************************************************** 
 * landscape_cirlce                 apply circles algorithm to a landscape * 
 ****************************************************************************/ 
void landscape_c::circles
(
    ulong       iter
)
{ 
    for (ulong i=0; i<iter; i++) 
    { 
        float xx = (rand()%100)*0.01f*width; 
        float yy = (rand()%100)*0.01f*height; 
 
        for (slong x=(slong)(xx-64); x<(slong)(xx+64); x++)
        {
            if (x<0 || x>=width) continue;
            for (slong y=(slong)(yy-64); y<(slong)(yy+64); y++)
            { 
                if (y<0 || y>=height) continue;

                float dx = (xx-x);
                float dy = (yy-y);
                float d  = dx*dx+dy*dy;

                if (d<100)
                    nodes[x+y*width].value += 1-(d/100);
            } 
        } 
    } 

    update_verts();
} 

/**************************************************************************** 
 * landscape_c::erode                                      erode landscape * 
 ****************************************************************************/ 
void landscape_c::erode
(
    float power
)
{
    for (ulong i=0; i<width*height; i++)
    {
        nodes[i].value = (float)pow(nodes[i].value, power);
    }

    update_verts();
}

/**************************************************************************** 
 * landscape_c::tileshader                            apply shader (tiled) * 
 ****************************************************************************/ 
void landscape_c::tile_shader(shader_t *shader)
{ 
    if (!shaders)
        return;

    long num;

    if ((num = shaders->find(shader)) == INVALID_INDEX)
        num = shaders->add(shader);

    ulong i; 
 
    for (i=0; i<width*height; ++i) 
    {
        nodes[i].shader = num;
        vec2_c(0,0).copy(nodes[i].verts[0].uv[0]);
        vec2_c(1,0).copy(nodes[i].verts[1].uv[0]);
        vec2_c(1,1).copy(nodes[i].verts[2].uv[0]);
        vec2_c(0,1).copy(nodes[i].verts[3].uv[0]);
    }
    update_verts();
}

/**************************************************************************** 
 * landscape_c::stretchshader                      apply shader (streched) * 
 ****************************************************************************/ 
void landscape_c::stretch_shader(shader_t *shader)
{ 
    if (!shaders)
        return;

    slong num;

    if ((num = shaders->find(shader)) == INVALID_INDEX)
        num = shaders->add(shader);

    ulong   i,x,y; 
    float   upx,vpy;

    upx = 1/(float)width;
    vpy = 1/(float)height;
 
    for (i=0; i<width*height; ++i) 
    {
        x = i%width;
        y = i/width;

        // nodes[i].shader = num;

        vec2_c(upx*x,       vpy*y    ).copy(nodes[i].verts[0].uv[0]);
        vec2_c(upx*(x+1),   vpy*y    ).copy(nodes[i].verts[1].uv[0]);
        vec2_c(upx*(x+1),   vpy*(y+1)).copy(nodes[i].verts[2].uv[0]);
        vec2_c(upx*x,       vpy*(y+1)).copy(nodes[i].verts[3].uv[0]);
    }

    update_verts();
}


/**************************************************************************** 
 * landscape_c::setshader                           apply shader to a tile * 
 ****************************************************************************/ 
void landscape_c::set_shader(shader_t *shader, ulong x, ulong y, bool setuv)
{ 
    if (!shaders)
        return;

    if (x<0 || x>=width || y<0 || y>=height)
        return;

    slong num;

    if ((num = shaders->find(shader)) == INVALID_INDEX)
        num = shaders->add(shader);

    ulong   i; 
    float   upx,vpy;

    upx = 1/(float)width;
    vpy = 1/(float)height;

    i = x+y*width;

    nodes[i].shader = num;

    if (setuv)
    {
        vec2_c(upx*x,       vpy*y    ).copy(nodes[i].verts[0].uv[0]);
        vec2_c(upx*(x+1),   vpy*y    ).copy(nodes[i].verts[1].uv[0]);
        vec2_c(upx*(x+1),   vpy*(y+1)).copy(nodes[i].verts[2].uv[0]);
        vec2_c(upx*x,       vpy*(y+1)).copy(nodes[i].verts[3].uv[0]);
    }

    update_verts();
}

/**************************************************************************** 
 * landscape_c::tilevisible                      test visibility of a tile * 
 ****************************************************************************/ 
bool landscape_c::is_node_visible(ulong x, ulong y)
{
    int     i,j;

    // check if actually part of the landscape ;)
    if (x<0 || x>=width-1)
        return false;

    if (y<0 || y>=height-1)
        return false;

    ulong idx[4];

    // get indices for node and neighbours    
    for (j=0; j<4; j++)
        idx[j] = ((int)NQUADVERTX(j)+x)%width+((y+(int)NQUADVERTY(j))%height)*width;

    // if node is marked as invisible ...
    if (nodes[idx[0]].flags & LSNFLAG_INVISIBLE)
        return false;

    vec3_c  v[4];
    bool    allhidden;

    allhidden = true;

    for (i=0; i<4; i++)
    {
        v[i].set(   (float)(x+NQUADVERTX(i))*scale[0], 
                    (float)(y+NQUADVERTY(i))*scale[1], 
                    (float)(nodes[idx[i]].value)*scale[2]);

        v[i] = v[i] + pos;
    }

//    if (allhidden)
//        return false;

    const plane_t *frust = gv.renderer->get_viewfrustum();

    for (i=0; i<6; i++)
    {
        allhidden=true;

        for (int j=0; j<4; j++)
        {
            if (plane_pointside(v[j], &frust[i])>0)
            {
                allhidden = false;
                break;
            }
        }

        if (allhidden)
            return false;
    }

    return true;
}

void landscape_c::update_verts()
{
    ulong   x,y; 
    ulong   idx[4];

    for (y=0; y<height; y++) 
    { 
        for (x=0; x<width; x++) 
        { 
            idx[0] = (x%width)+(y%height)*width; 
            idx[1] = ((x+1)%width)+(y%height)*width; 
            idx[2] = ((x+1)%width)+((y+1)%height)*width; 
            idx[3] = (x%width)+((y+1)%height)*width; 

            vertex_t *verts = nodes[idx[0]].verts;

            vertex_set(&verts[0], 
                        x                   *scale[0]+pos[0], 
                        y                   *scale[1]+pos[1], 
                        nodes[idx[0]].value *scale[2]+pos[2], 
                        nodes[idx[0]].verts[0].uv[0][0], nodes[idx[0]].verts[0].uv[0][1]); 

            vertex_set(&verts[1], 
                        (x+1)               *scale[0]+pos[0], 
                        (y+0)               *scale[1]+pos[1], 
                        nodes[idx[1]].value *scale[2]+pos[2], 
                        nodes[idx[0]].verts[1].uv[0][0], nodes[idx[0]].verts[1].uv[0][1]); 
            
            vertex_set(&verts[2], 
                        (x+1)               *scale[0]+pos[0], 
                        (y+1)               *scale[1]+pos[1], 
                        nodes[idx[2]].value *scale[2]+pos[2], 
                        nodes[idx[0]].verts[2].uv[0][0], nodes[idx[0]].verts[2].uv[0][1]); 

            vertex_set(&verts[3], 
                        (x+0)               *scale[0]+pos[0], 
                        (y+1)               *scale[1]+pos[1], 
                        nodes[idx[3]].value *scale[2]+pos[2], 
                        nodes[idx[0]].verts[3].uv[0][0], nodes[idx[0]].verts[3].uv[0][1]); 

            nodes[idx[0]].verts[0].diffuse = nodes[idx[0]].verts[0].diffuse;
            nodes[idx[0]].verts[1].diffuse = nodes[idx[1]].verts[0].diffuse;
            nodes[idx[0]].verts[2].diffuse = nodes[idx[2]].verts[0].diffuse;
            nodes[idx[0]].verts[3].diffuse = nodes[idx[3]].verts[0].diffuse;

            (vec3_c(nodes[idx[0]].verts[0].normal)).copy(nodes[idx[0]].verts[0].normal); 
            (vec3_c(nodes[idx[1]].verts[0].normal)).copy(nodes[idx[0]].verts[1].normal); 
            (vec3_c(nodes[idx[2]].verts[0].normal)).copy(nodes[idx[0]].verts[2].normal); 
            (vec3_c(nodes[idx[3]].verts[0].normal)).copy(nodes[idx[0]].verts[3].normal); 
 
            if (!nodes[idx[0]].displist)
            {
                nodes[idx[0]].displist = glGenLists(1);
            }

            glNewList(nodes[idx[0]].displist, GL_COMPILE);

            gv.renderer->use_shader(shaders->get(nodes[idx[0]].shader));
//            if (shaders->get(nodes[idx[0]].shader))
//                gv.texman->set((shaders->get(nodes[idx[0]].shader))->passes[0].texture);

            gv.renderer->render_quad(nodes[idx[0]].verts);

            glEndList();
        } 
    } 
}

---