---

ATerrain.cpp

Go to the documentation of this file.

/*
CS Senior Project 2003
Team : Leftfield
Project : ModernWarfare
Members :
- Russ Christensen              <rchriste@cs.utah.edu>
- Todd Smith                    <tcsmith@cs.utah.edu>
- Usit Duongsaa                 <duongsaa@cs.utah.edu>

Copyright 2003 Russ Christensen, Usit Duongsaa, and Todd Smith. All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 
THIS SOFTWARE IS PROVIDED BY RUSS CHRISTENSEN, USIT DUONGSAA, AND TODD SMITH ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL RUSS, USIT, TODD OR OTHER CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#include "AEngine.h"
#include "AState.h"
#include "AUtil.h"
#include "ATGAImage.h"

//------------------------------------------------------------------------------------
void createZMap(TerrainEntry &e, UBYTE *pImg)
{
        for( int j=0; j<TERR_ROWS; j++ )                        // get height from channel R
                for( int i=0; i<TERR_COLS; i++ )
                        e.zMap[j][i] = e.sizeZ * pImg[ (j*TERR_COLS+i)*3 ] / 255.0f + e.offsetZ;


        // blur Z
        FLOAT sum[TERR_ROWS][TERR_COLS];
        int   count[TERR_ROWS][TERR_COLS];

#define ADD( x, y, value )   if( x>=0 && y>=0 && x<TERR_COLS && y<TERR_ROWS ) { sum[y][x]+=value; count[y][x]++; }

        for( int blurCount=0; blurCount<2; blurCount++ )
        {
                ZeroMemory( sum, sizeof(sum) );
                ZeroMemory( count, sizeof(count) );
                for( int j=0; j<TERR_ROWS; j++ )
                        for( int i=0; i<TERR_COLS; i++ )
                        {
                                FLOAT value = e.zMap[j][i];
                                ADD( i-1, j-1, value )
                                ADD( i  , j-1, value )
                                ADD( i+1, j-1, value )
                                ADD( i-1, j  , value )
                                ADD( i+1, j  , value )
                                ADD( i-1, j+1, value )
                                ADD( i  , j+1, value )
                                ADD( i+1, j+1, value )
                        }

                for( int j=0; j<TERR_ROWS; j++ )
                        for( int i=0; i<TERR_COLS; i++ )
                                e.zMap[j][i] = sum[j][i] / count[j][i];
        }
}
//------------------------------------------------------------------------------------
void createNMap(TerrainEntry &e)
{
        // 2x distance between 2 adjacent tiles
        FLOAT deltaX = 2.0f/TERR_COLS * e.sizeX;
        FLOAT deltaY = 2.0f/TERR_ROWS * e.sizeY;                

        for( int j=0; j<TERR_ROWS; j++ )
                for( int i=0; i<TERR_COLS; i++ )
                {
                        if( i==0 || i==TERR_COLS-1 || j==0 || j==TERR_ROWS-1 )          // if border case, normal points up
                        {
                                e.NMap[j][i] = Vec3D( 0.0f, 0.0f, 1.0f );
                        }
                        else
                        {
                                FLOAT dzdx = e.zMap[j-1][i+1] + e.zMap[j  ][i+1] + e.zMap[j+1][i+1]
                                                   - e.zMap[j-1][i-1] - e.zMap[j  ][i-1] - e.zMap[j+1][i-1];
                                FLOAT dzdy = e.zMap[j+1][i-1] + e.zMap[j+1][i  ] + e.zMap[j+1][i+1]
                                                   - e.zMap[j-1][i-1] - e.zMap[j-1][i  ] - e.zMap[j-1][i+1];
                                
                           dzdx *= 1.0f / 3.0f / deltaX;
                           dzdy *= 1.0f / 3.0f / deltaY;
                           FLOAT denom = 1.0f / sqrtf( dzdx*dzdx + dzdy*dzdy + 1.0f );          // normalize it
                           e.NMap[j][i] = Vec3D( dzdx*denom, dzdy*denom, denom );
                        }
                }
}
//------------------------------------------------------------------------------------
void createBMap(TerrainEntry &e, UBYTE *pImg)
{
        for( int j=0; j<TERR_ROWS; j++ )                        // get blend factor from channel G
                for( int i=0; i<TERR_COLS; i++ )
                        e.BMap[j][i] = pImg[ (j*TERR_COLS+i)*3 +1] / 255.0f;
}
//------------------------------------------------------------------------------------
void createVIB(TerrainEntry &e)
{
        int vbByteSize = TERR_ROWS * TERR_COLS * sizeof(ColoredTerrainVertex);
        int ibByteSize = ((TERR_ROWS-1)*2*TERR_COLS + (TERR_ROWS-2)*2) * sizeof(USHORT);
        ColoredTerrainVertex *pVertex;
        USHORT                           *pIndex;

        AS.pDevice->CreateVertexBuffer( vbByteSize, D3DUSAGE_WRITEONLY, 0, D3DPOOL_MANAGED, &e.vb );
        AS.pDevice->CreateIndexBuffer(  ibByteSize, D3DUSAGE_WRITEONLY, D3DFMT_INDEX16, D3DPOOL_MANAGED, &e.ib );
        if( FAILED( e.vb->Lock(0,0, (BYTE**)&pVertex, 0) )) throw Error("Can't Lock terrVB");
        if( FAILED( e.ib->Lock(0,0, (BYTE**)&pIndex,  0) )) throw Error("Can't Lock terrIB");

        int writeIndex = 0;
        for( int j=0; j<TERR_ROWS; j++ )
                for( int i=0; i<TERR_COLS; i++ )
                {
                        pVertex[writeIndex].pos = Vec3D( e.sizeX * (i*1.0f/TERR_COLS -0.5f),
                                                                                         e.sizeY * (j*1.0f/TERR_ROWS -0.5f),
                                                                                         e.zMap[j][i] );
                        pVertex[writeIndex].normal = e.NMap[j][i];
                        pVertex[writeIndex].blendFactor = e.BMap[j][i];                 
                        writeIndex++;
                }

        writeIndex = 0;
        for( int j=0; j<TERR_ROWS-1; j++ )                              // fill indices
        {
                for( int i=0; i<TERR_COLS; i++ )                                                // create tri strips
                {
                        pIndex[writeIndex++] = j*TERR_COLS +i;
                        pIndex[writeIndex++] = (j+1)*TERR_COLS +i;
                }
                if( j<TERR_ROWS-2 )                                                                     // join strips
                {
                        pIndex[writeIndex++] = (j+2)*TERR_COLS -1;
                        pIndex[writeIndex++] = (j+1)*TERR_COLS;
                }
        }

    e.vb->Unlock();
        e.ib->Unlock();
}
//------------------------------------------------------------------------------------
ATerrain terrain_create( string filename, FLOAT sizeX, FLOAT sizeY, FLOAT sizeZ, FLOAT offsetZ )
{
        CImage img;
        img.LoadTga(filename);
        assert(img.GetWidth()==TERR_COLS && img.GetHeight()==TERR_ROWS);
        UBYTE *imgData  = img.GetImageData();

        TerrainEntry e;
        e.doRender = false;
        e.texLow    = (DWORD) -1;
        e.texHigh   = (DWORD) -1;
        e.texNormal = (DWORD) -1;
        e.sizeX = sizeX;
        e.sizeY = sizeY;
        e.sizeZ = sizeZ;
        e.offsetZ = offsetZ;

        createZMap(e,imgData);
        createNMap(e);
        createBMap(e,imgData);
        createVIB(e);

        AS.res_terrains.push_back(e);

        // create V&P shaders
        if(AS.vshader_terrain==0)
        {
                AS.vshader_terrain = util_loadVertexShader( "shaders\\terrain.vso", dwColoredTerrainVertexDecl );
                AS.pshader_terrain = util_loadPixelShader(  "shaders\\terrain.pso" );   
        }
        
        return (ATerrain)AS.res_terrains.size()-1;
}
//------------------------------------------------------------------------------------
void terrain_render( ATerrain terrain, ATexture texLow, ATexture texHigh, ATexture texNormal )
{
        assert(terrain>=0 && terrain<(int)AS.res_terrains.size());
        AS.res_terrains[terrain].doRender = true;
        AS.res_terrains[terrain].texLow    = texLow;
        AS.res_terrains[terrain].texHigh   = texHigh;
        AS.res_terrains[terrain].texNormal = texNormal;
}
//------------------------------------------------------------------------------------
void terrain_flush()
{
        for( UINT i=0; i<AS.res_terrains.size(); i++ )
                AS.res_terrains[i].doRender = false;
}
//------------------------------------------------------------------------------------
void terrain_processRenderRequest()
{       
        UINT i;
        for( i=0; i<AS.res_terrains.size(); i++ )               // find the one that needs rendering, if any
                if( AS.res_terrains[i].doRender ) break;
        if( i>=AS.res_terrains.size() ) return;
        TerrainEntry &e = AS.res_terrains[i];   

        device_setVertexShader( AS.vshader_terrain );
        device_setPixelShader(  AS.pshader_terrain );

        device_setTexture( 0, AS.res_textures[e.texLow] );
        device_setTexture( 1, AS.res_textures[e.texHigh] );
        device_setTexture( 2, AS.res_textures[e.texNormal] );

        device_setStreamSource( 0, e.vb, sizeof(ColoredTerrainVertex) );
        device_setIndexSource( e.ib );

        // rendering flags
        device_setRenderState( D3DRS_ZENABLE,  TRUE );
        device_setRenderState( D3DRS_ZWRITEENABLE,  TRUE );
        for( DWORD stage=0; stage<4; stage++ )
        {
                device_setTextureStageState( stage, D3DTSS_MAGFILTER, D3DTEXF_LINEAR );
                device_setTextureStageState( stage, D3DTSS_MINFILTER, D3DTEXF_LINEAR );
                device_setTextureStageState( stage, D3DTSS_MIPFILTER, D3DTEXF_LINEAR );
        }       
        device_setRenderState( D3DRS_CULLMODE, D3DCULL_CW );
        device_setRenderStateBlendMode( BlendModes::NONE );
        device_setRenderState( D3DRS_SPECULARENABLE, TRUE );

        // set projXview matrix
        Matx mat;       
        D3DXMatrixTranspose( &mat, &AS.camera_world2projMatrix);
        AS.pDevice->SetVertexShaderConstant( 0, &mat, 4 );

        // set UV const
        FLOAT uvScale[4] = { 10.0f/e.sizeX, 10.0f/e.sizeY, 0.0f, 0.0f };
        FLOAT uvShift[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
        FLOAT nScale[4]  = { 25.0f/e.sizeX, 25.0f/e.sizeY, 0.0f, 0.0f };
        AS.pDevice->SetVertexShaderConstant( 4, &uvScale, 1 );
        AS.pDevice->SetVertexShaderConstant( 5, &uvShift, 1 );
        AS.pDevice->SetVertexShaderConstant( 8, &nScale, 1 );

        // set ATM const
        FLOAT lightVec[4] = { 0.5882f, 0.1961f, 0.7843f, 0.0f };  //lightVec = c6
        FLOAT lightAmbient[4] = { 0.24f, 0.24f, 0.2f };
        AS.pDevice->SetVertexShaderConstant( 6, &lightVec, 1 );
        AS.pDevice->SetVertexShaderConstant( 7, &lightAmbient, 1 );
        
        FLOAT normalVec[4] = { 0.3882f, 0.1961f, 0.1843f, 0.0f };  // PS c0
        FLOAT atmColor[4]  = { 0.6f, 0.8f, 1.0f, 0.0f };
        FLOAT zScale[4]    = { 0.0025f };
        AS.pDevice->SetPixelShaderConstant( 0, &normalVec, 1 );         // PS c1 = atm color
        AS.pDevice->SetPixelShaderConstant( 1, &atmColor, 1 );
        AS.pDevice->SetVertexShaderConstant( 9, &zScale, 1 );
        
        // render strip
        int numVertex = TERR_ROWS * TERR_COLS;
        int primCount = (TERR_ROWS-1)*2*TERR_COLS + (TERR_ROWS-2)*2 - 2;
        AS.pDevice->DrawIndexedPrimitive( D3DPT_TRIANGLESTRIP, 0, numVertex, 0, primCount );
}
//------------------------------------------------------------------------------------
FLOAT triArea( Vec2D &p0, Vec2D &p1, Vec2D &p2 )
{
        Vec2D side1 = p0 - p2;
        Vec2D side2 = p1 - p2;
        FLOAT area = D3DXVec2CCW( &side1, &side2) / 2.0f;               // size of the cross product/2
        if( area>0 ) return  area;
                else     return -area;
}
//------------------------------------------------------------------------------------
FLOAT terrain_getHeight( ATerrain terrain, FLOAT x, FLOAT y )
{
        // idea : return the weighted average height of the closest 4 pts
        // weight = area of triangle formed
        assert(terrain>=0 && terrain<(int)AS.res_terrains.size());
        TerrainEntry &t = AS.res_terrains[terrain];

        FLOAT gridSizeX = t.sizeX / (TERR_COLS);
        FLOAT gridSizeY = t.sizeY / (TERR_ROWS);
        int i = (int)( (x+t.sizeX/2) / gridSizeX );
        int j = (int)( (y+t.sizeY/2) / gridSizeY );
        if( !(i>=0 && j>=0 && i<TERR_COLS-1 && j<TERR_ROWS-1) )
        {
                sys_console() << "Warning : terrain_getHeight out of terrain area" << endl;
                return 0;
        }

        Vec2D pMid(x,y);
        Vec2D p0( t.sizeX*(    i*1.0f/TERR_COLS -0.5f), t.sizeY*(    j*1.0f/TERR_ROWS -0.5f) );
        Vec2D p1( t.sizeX*((i+1)*1.0f/TERR_COLS -0.5f), t.sizeY*(    j*1.0f/TERR_ROWS -0.5f) );
        Vec2D p2( t.sizeX*((i+1)*1.0f/TERR_COLS -0.5f), t.sizeY*((j+1)*1.0f/TERR_ROWS -0.5f) );
        Vec2D p3( t.sizeX*(    i*1.0f/TERR_COLS -0.5f), t.sizeY*((j+1)*1.0f/TERR_ROWS -0.5f) );

        FLOAT tri0 = triArea( p0, p1, pMid );
        FLOAT tri1 = triArea( p1, p2, pMid );
        FLOAT tri2 = triArea( p2, p3, pMid );
        FLOAT tri3 = triArea( p3, p0, pMid );

        FLOAT weight0 = tri1*tri2,              weight1=tri2*tri3,
                  weight2 = tri3*tri0,          weight3=tri0*tri1;
        FLOAT sum = t.zMap[j][i]    *weight0 + t.zMap[j][i+1]*weight1
                      + t.zMap[j+1][i+1]*weight2 + t.zMap[j+1][i]*weight3;
        FLOAT height = sum/(weight0+weight1+weight2+weight3);   
        //return ((int)(height*10))/10.0f;
        return height;
}
//------------------------------------------------------------------------------------

---