---

AOverlay.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 "ADevice.h"
#include "AConstants.h"
#include "AVertexTypes.h"


//------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------
const int MAX_POINT = 96/3;             

namespace OpType
{
        const int OP_INVALID            =  -1;
        const int OP_IMAGE                      =       0;
        const int OP_FILLED_RECT        =       1;
        const int OP_EMPTY_RECT         =       2;
        const int OP_LINE                       =       3;
        const int OP_POINT                      =       4;
        const int OP_TEXT                       =       5;
}
//------------------------------------------------------------------------------------
class OverlayEntryComparer      
{
public:
        bool operator()(const OverlayEntry &L, const OverlayEntry &R )
        {
                return (L.op*100+L.blendMode)+L.priority*1000 < (R.op*100+R.blendMode)+R.priority*1000;
        }
};
//------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------
// convert a point in (0..1)^2 to (-1..+1)^2
// note that the y-axis is flipped
void convertToScreenCoord( Vec2D &pt )
{
        pt[0] = pt[0]*2.0f - 1.0f;
        pt[1] = (1.0f-pt[1])*2.0f - 1.0f;
}
//------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------
void overlay_init()
{
        // create vertex buffer
        int byteSize = sizeof(OverlayVertex) * MAX_POINT;
        AS.pDevice->CreateVertexBuffer( byteSize, D3DUSAGE_WRITEONLY, 0, D3DPOOL_MANAGED, &AS.overlay_pVB );
        
        // put in index to constant registers
        OverlayVertex *access;
        if( FAILED( AS.overlay_pVB->Lock(0,0, (BYTE**)&access, 0) )) throw Error("Can't Lock Overlay VB");
        for( int i=0; i<MAX_POINT; i++ )        
                access[i].cIndex = i*3.0f;
        AS.overlay_pVB->Unlock();

        // load default font
        AS.res_fonts.push_back( util_loadFont("Arial","",18) );

        // load V&P Shader
        AS.vshader_overlay = util_loadVertexShader( "shaders\\overlay.vso", dwOverlayVertexDecl );
        AS.pshader_overlay = util_loadPixelShader(  "shaders\\overlay.pso" );
        AS.pshader_textureConstAlpha = util_loadPixelShader(  "shaders\\textureConstAlpha.pso" );
        AS.pshader_texturePixelAlpha = util_loadPixelShader(  "shaders\\texturePixelAlpha.pso" );

        AS.overlay_pTextStream = new ostringstream();
}
//------------------------------------------------------------------------------------
void overlay_flush()
{
        AS.overlay_entries.resize(0);
        delete AS.overlay_pTextStream;
        AS.overlay_pTextStream = new ostringstream();   
}
//------------------------------------------------------------------------------------
inline void useOverlayShaders()
{
        device_setTextureStageState( 0, D3DTSS_MAGFILTER, D3DTEXF_LINEAR );
        device_setTextureStageState( 0, D3DTSS_MINFILTER, D3DTEXF_LINEAR );
        device_setTextureStageState( 0, D3DTSS_MIPFILTER, D3DTEXF_POINT );
        device_setVertexShader( AS.vshader_overlay );   
        device_setStreamSource( 0, AS.overlay_pVB, sizeof(OverlayVertex) );
        device_setRenderState( D3DRS_ZENABLE, FALSE );
        device_setRenderState( D3DRS_SPECULARENABLE, FALSE );
        device_setRenderState( D3DRS_CULLMODE, D3DCULL_CCW );
}
//------------------------------------------------------------------------------------
void overlay_render()
{
        sort(AS.overlay_entries.begin(), AS.overlay_entries.end(), OverlayEntryComparer());
        useOverlayShaders();

        D3DLINEPATTERN linePattern;

        int last = (int)AS.overlay_entries.size();
        for( int i=0; i<last; i++ )
        {
                OverlayEntry &e = AS.overlay_entries[i];
                device_setRenderStateBlendMode(e.blendMode);
                convertToScreenCoord(e.pt1);            
                FLOAT x1, x2, y1, y2;

                if(e.op==OpType::OP_IMAGE)              // for image, pt2 is used for size
                {                       
                        e.pt1 = e.pt1 - e.pt2;
                        e.pt2 = 2.0f*e.pt2 + e.pt1;
                }
                else
                {
                        convertToScreenCoord(e.pt2);
                }
                x1 =  min( e.pt1[0], e.pt2[0] );
                x2 =  max( e.pt1[0], e.pt2[0] );
                y1 =  min( e.pt1[1], e.pt2[1] );
                y2 =  max( e.pt1[1], e.pt2[1] );
                FLOAT dataA[12] = { x1,y1,0.0f, 10.0f, e.color[0], e.color[1], e.color[2], e.alpha, 0.0f, 1.0f };
                FLOAT dataB[12] = { x2,y1,0.0f, 10.0f, e.color[0], e.color[1], e.color[2], e.alpha, 1.0f, 1.0f };
                FLOAT dataC[12] = { x2,y2,0.0f, 10.0f, e.color[0], e.color[1], e.color[2], e.alpha, 1.0f, 0.0f };
                FLOAT dataD[12] = { x1,y2,0.0f, 10.0f, e.color[0], e.color[1], e.color[2], e.alpha, 0.0f, 0.0f };

                switch(e.op)
                {
                        case OpType::OP_IMAGE:
                                {
                                        useOverlayShaders();
                                        if(e.blendMode==BlendModes::KEY)
                                                device_setPixelShader(  AS.pshader_texturePixelAlpha );
                                        else
                                                device_setPixelShader(  AS.pshader_textureConstAlpha );
                                        device_setTexture(0, AS.res_textures.at(e.resource) );
                                        AS.pDevice->SetVertexShaderConstant( 0, dataD, 3 );
                                        AS.pDevice->SetVertexShaderConstant( 3, dataC, 3 );
                                        AS.pDevice->SetVertexShaderConstant( 6, dataB, 3 );
                                        AS.pDevice->SetVertexShaderConstant( 9, dataA, 3 );
                                        AS.pDevice->DrawPrimitive( D3DPT_TRIANGLEFAN, 0, 2 );
                                        break;
                                }

                        case OpType::OP_POINT:
                                {
                                        useOverlayShaders();
                                        device_setPixelShader(  AS.pshader_overlay );
                                        dataA[0]=e.pt1[0];              dataA[1]=e.pt1[1];              dataA[2]=0.0f;                  dataA[3]=e.size*4.0f;
                                        dataA[4]=e.color[0];    dataA[5]=e.color[1];    dataA[6]=e.color[2];    dataA[7]=e.alpha;
                                        AS.pDevice->SetVertexShaderConstant( 0, dataA, 2 );
                                        AS.pDevice->DrawPrimitive( D3DPT_POINTLIST, 0, 1 );
                                        break;
                                }
                                
                        case OpType::OP_LINE:
                                {
                                        useOverlayShaders();
                                        int intPattern = *(int*)(&e.size);
                                        WORD patterns[3] = { 0xffff, 0x3333, 0x5555 };
                                        linePattern.wRepeatFactor = 1;
                                        linePattern.wLinePattern = patterns[ intPattern ];
                                        DWORD dwPattern = *(DWORD*)(&linePattern);
                                        //device_setRenderState( D3DRS_LINEPATTERN, dwPattern );

                                        device_setPixelShader(  AS.pshader_overlay );
                                        // send first point to GPU
                                        dataA[0]=e.pt1[0];              dataA[1]=e.pt1[1];              dataA[2]=0.0f;                  dataA[3]=10.0f;
                                        dataA[4]=e.color[0];    dataA[5]=e.color[1];    dataA[6]=e.color[2];    dataA[7]=e.alpha;
                                        AS.pDevice->SetVertexShaderConstant( 0, dataA, 2 );
                                
                                        // second point
                                        dataA[0]=e.pt2[0];                      dataA[1]=e.pt2[1];
                                        AS.pDevice->SetVertexShaderConstant( 3, dataA, 2 );
        
                                        AS.pDevice->DrawPrimitive( D3DPT_LINELIST, 0, 1 );
                                        break;
                                }
                                

                        case OpType::OP_EMPTY_RECT:
                                {
                                        useOverlayShaders();
                                        device_setPixelShader(  AS.pshader_overlay );
                                        AS.pDevice->SetVertexShaderConstant( 0, dataA, 2 );
                                        AS.pDevice->SetVertexShaderConstant( 3, dataB, 2 );
                                        AS.pDevice->SetVertexShaderConstant( 6, dataC, 2 );
                                        AS.pDevice->SetVertexShaderConstant( 9, dataD, 2 );
                                        AS.pDevice->SetVertexShaderConstant(12, dataA, 2 );
                                        AS.pDevice->DrawPrimitive( D3DPT_LINESTRIP, 0, 4 );
                                        break;
                                }                       

                        case OpType::OP_FILLED_RECT:
                                {
                                        useOverlayShaders();
                                        device_setPixelShader(  AS.pshader_overlay );
                                        AS.pDevice->SetVertexShaderConstant( 0, dataD, 2 );
                                        AS.pDevice->SetVertexShaderConstant( 3, dataC, 2 );
                                        AS.pDevice->SetVertexShaderConstant( 6, dataB, 2 );
                                        AS.pDevice->SetVertexShaderConstant( 9, dataA, 2 );
                                        AS.pDevice->DrawPrimitive( D3DPT_TRIANGLEFAN, 0, 2 );
                                        break;
                                }
                                
                        case OpType::OP_TEXT:
                                {                                       
                                        DWORD color = D3DXCOLOR( e.color[0], e.color[1], e.color[2], e.alpha );
                                        FLOAT scale = e.size * 0.025f;
                                        TCHAR *tStr = util_stringToTChar(e.s);
                                        AS.res_fonts.at(e.resource)->DrawTextScaled( e.pt1[0], -e.pt1[1], 0.0f,
                                                                                                                     scale, scale, color, tStr, 0 );
                                        device_flushSettings();
                                        break;
                                }

                        default:
                                assert(false && "Invalid OpCode in Overlay pipeline");
                }
        }

        AS.overlay_entries.resize(0);
}
//------------------------------------------------------------------------------------
void overlay_point( const Vec2D pt, const FLOAT size, const Vec3D rgb, const int blendMode,
                                    const FLOAT alpha, const int priority )
{
        AS.overlay_entries.push_back( OverlayEntry(OpType::OP_POINT, blendMode,
                                                                  pt, pt, rgb, alpha, size, "", NULL,priority)  );
}
//------------------------------------------------------------------------------------
void overlay_line(  const Vec2D pt1, const Vec2D pt2, const Vec3D rgb, const int blendMode,
                                        const FLOAT alpha, const int priority, const int pattern )
{
        FLOAT floatPattern = *(FLOAT*)(&pattern);
        AS.overlay_entries.push_back( OverlayEntry(OpType::OP_LINE, blendMode,
                                                                  pt1, pt2, rgb, alpha, floatPattern, "", NULL,priority)  );
}
//------------------------------------------------------------------------------------
void overlay_rect(  const Vec2D pt1, const Vec2D pt2, const bool fill, const Vec3D rgb,
                                    const int blendMode, const FLOAT alpha, const int priority )
{
        if(fill)
                AS.overlay_entries.push_back( OverlayEntry(OpType::OP_FILLED_RECT, 
                                                                          blendMode, pt1, pt2, rgb, alpha, 1.0f, "", NULL,priority)  );
        else
                AS.overlay_entries.push_back( OverlayEntry(OpType::OP_EMPTY_RECT, 
                                                                          blendMode, pt1, pt2, rgb, alpha, 1.0f, "", NULL,priority)  );
}
//------------------------------------------------------------------------------------
ostream& overlay_text()
{
        return *(AS.overlay_pTextStream);
}
//------------------------------------------------------------------------------------
void overlay_textOut( const Vec2D pos, const FLOAT scale, const Vec3D rgb, const AFont font, int priority )
{
        AS.overlay_entries.push_back( OverlayEntry(OpType::OP_TEXT,     BlendModes::NONE,
                                                                  pos, pos, rgb, 1.0f, scale, AS.overlay_pTextStream->str(), font,priority)  );
        overlay_clearText();
}
//------------------------------------------------------------------------------------
void overlay_clearText()
{
        delete AS.overlay_pTextStream;
        AS.overlay_pTextStream = new ostringstream();
}
//------------------------------------------------------------------------------------
void overlay_image( const ATexture image, const Vec2D center, const Vec2D size,
                                    const int blendMode, const FLOAT alpha, const int priority )
{
        AS.overlay_entries.push_back( OverlayEntry(OpType::OP_IMAGE, blendMode, center, size,
                                                                                           Colors::white, alpha, 0.0f, "", image,priority) );
}
//------------------------------------------------------------------------------------

---