MercuryDisplaySoftwareC.cpp

Go to the documentation of this file.

#include "MercuryDisplaySoftwareC.h"
#include "MercuryLog.h"

int MercuryDisplaySoftwareC::m_bypp;
int MercuryDisplaySoftwareC::m_height;
int MercuryDisplaySoftwareC::m_width;
bool MercuryDisplaySoftwareC::m_zBufferWrite;
unsigned char * MercuryDisplaySoftwareC::m_cBuffer;
unsigned int * MercuryDisplaySoftwareC::m_zBuffer;

MercuryDisplaySoftwareC::MercuryDisplaySoftwareC()
{
    bDepthTest = false;
    m_InternalTextures.resize(1);
    m_pCurTexture = &m_InternalTextures[0];
    m_pCurTexture->m_isMaterial = false;
    m_pCurTexture->m_isInUse = false;
}
/*
void MercuryDisplaySoftwareC::Init()
{
    MercuryDisplay::Init();
}
*/
bool MercuryDisplaySoftwareC::EndFrame()
{
    m_window->SwapBuffers();
    memset( m_cBuffer, 0, m_width * m_height * m_bypp );
    ClearZBuffer();
    m_cBuffer = m_window->GetBackDirectBuffer();
    ToggleZBufferWrite( true );
    ++m_framesDrawn;

    return true;
}

bool MercuryDisplaySoftwareC::MakeWindow(const char* title, int width, int height, int bits, bool fullscreenflag)
{
    m_width = width;
    m_height = height;
    m_bypp = bits/8;

    m_VPx = 0;
    m_VPy = 0;
    m_VPwidth = width;
    m_VPheight = height;

    if (m_window == NULL)
        return false;

    if (!m_window->MakeRender(title,width,height,bits,fullscreenflag,RT_SW))
    {
        m_window->DestroyWindowAndRender();
        return false;
    }

    MercuryDisplay::MakeWindow(title, width, height, bits, fullscreenflag);

    m_cBuffer = m_window->GetBackDirectBuffer();
    m_zBuffer = new unsigned int[width*height];

    return true;
}

void MercuryDisplaySoftwareC::DeleteTextures( int n, unsigned int *textureNames )
{
    m_InternalTextures[*textureNames].m_isInUse = false;
    SAFE_DELETE( m_InternalTextures[*textureNames].m_data );
}

void MercuryDisplaySoftwareC::DrawMesh(const MercuryMesh& mesh)
{
    static int iPointsPerPoly;
    static InternalPoint Points[4];
    static MercuryVertex* V;
    static InternalPoint NewPoints[20000];
    static const unsigned int* I;

    switch(mesh.GetDrawType())
    {
    case MGL_TRIANGLE:  iPointsPerPoly = 3; break;
    case MGL_QUAD:      iPointsPerPoly = 4; break;
    case MGL_POINT:     iPointsPerPoly = 1; break;
    default: return;
    };

    V = (MercuryVertex*)mesh.GetVerticePtr();

    m_verticesDrawn += mesh.NumIndices();
    I = mesh.GetIndicesPtr();

    for( unsigned i = 0; i < mesh.NumVertices(); i++ )
    {
        InternalPipelinePoint( V[i].GetPointHandle(), NewPoints[i] );
        V[i].GetUV( &NewPoints[i].u );
    }

    for( unsigned j = 0; j < mesh.NumIndices(); j+=iPointsPerPoly )
    {
        Points[0] = NewPoints[I[j]];
        Points[1] = NewPoints[I[j+1]];
        Points[2] = NewPoints[I[j+2]];
        InternalDrawPoly( &Points[0], iPointsPerPoly );
    }
}

void MercuryDisplaySoftwareC::SetMaterial(const MercuryMaterial* material)
{
    m_pCurMaterial.m_alpha = material->m_alpha;
    m_pCurMaterial.m_ambient = material->m_ambient;
    m_pCurMaterial.m_diffuse = material->m_diffuse;
    m_pCurMaterial.m_emissive = material->m_emissive;
}

void MercuryDisplaySoftwareC::ClearZBuffer() 
{
    memset( m_zBuffer, 0x00, m_width * m_height * 4 );
}

void MercuryDisplaySoftwareC::UpdateTextureData(MercuryTexture* texture, unsigned int& ID)
{
//  memcpy( m_InternalTextures[ID].m_data, texture->GetRaw(), texture->GetWidth() * texture->GetHeight() * ColorBytesToSize( texture->GetColorByteType() ) );
}

void MercuryDisplaySoftwareC::CreateCache(MercuryTexture* texture, unsigned int& ID)
{
    for( ID = 1; ID < m_InternalTextures.size(); ID++ )
        if( !m_InternalTextures[ID].m_isInUse )
            break;
    
    if( ID >= m_InternalTextures.size() )
    {
        m_InternalTextures.resize( ID+1 );
        m_InternalTextures[ID].m_isInUse = false;
    }
    if( m_InternalTextures[ID].m_isInUse )
        SAFE_DELETE( m_InternalTextures[ID].m_data );
    int bypp = ColorBytesToSize( texture->GetColorByteType() );
    m_InternalTextures[ID].m_data = new unsigned char[texture->GetWidth() * texture->GetHeight() * bypp];
//  memcpy( m_InternalTextures[ID].m_data, texture->GetRaw(), texture->GetWidth() * texture->GetHeight() * bypp );
    m_InternalTextures[ID].m_height = texture->GetHeight();
    m_InternalTextures[ID].m_width = texture->GetWidth();
    m_InternalTextures[ID].m_isInUse = true;
    m_InternalTextures[ID].m_isMaterial = true;
    m_InternalTextures[ID].m_type = texture->GetColorByteType();
//  m_InternalTextures[ID].m_TexMat = texture->GetFinalMatrix();
}

void MercuryDisplaySoftwareC::CreateCache(RawImageData* data, unsigned int& ID)
{
    for( ID = 0; ID+1 < m_InternalTextures.size(); ID++ )
        if( !m_InternalTextures[ID+1].m_isInUse )
            break;
    
    if( ID+1 >= m_InternalTextures.size() )
    {
        m_InternalTextures.resize( ID+2 );
        m_InternalTextures[ID+1].m_isInUse = false;
    }
    if( m_InternalTextures[ID+1].m_isInUse )
        SAFE_DELETE( m_InternalTextures[ID+1].m_data );
    int bypp = ColorBytesToSize( data->attrs.m_ColorByteType );
    m_InternalTextures[ID+1].m_data = new unsigned char[data->attrs.m_height * data->attrs.m_width * bypp];
    memcpy( m_InternalTextures[ID+1].m_data, data->data, data->attrs.m_height * data->attrs.m_width * bypp );
    m_InternalTextures[ID+1].m_height = data->attrs.m_height;
    m_InternalTextures[ID+1].m_width = data->attrs.m_width;
    m_InternalTextures[ID+1].m_isInUse = true;
    m_InternalTextures[ID+1].m_isMaterial = true;
    m_InternalTextures[ID+1].m_type = data->attrs.m_ColorByteType;
    ID++;
}

void MercuryDisplaySoftwareC::EnableTextures(MercuryMaterial* material)
{
    int iTextureID = 0;
    if( material->NumTextures() != 0 )
    {
        m_pCurMercuryTexture = material->GetTexture(0);
        iTextureID = m_pCurMercuryTexture->GetID();
    }

    m_pCurTexture = &m_InternalTextures[ iTextureID ];

    if( material->NumTextures() != 0 )
    {
        material->EditTexture(0)->Prerender();
        m_pCurTexture->m_TexMat = material->EditTexture(0)->GetFinalMatrix();
    }
}

void MercuryDisplaySoftwareC::ReadFrameBuffer(RawImageData& image)
{
    image.attrs.m_ColorByteType = RGB;
    image.attrs.m_dpi_x = 72;
    image.attrs.m_dpi_y = 72;
    image.attrs.m_height = m_window->GetHeight();
    image.attrs.m_width = m_window->GetWidth();
    image.data = new unsigned char[m_window->GetHeight() * m_window->GetWidth() * 3];
    for( int x = 0; x < m_window->GetWidth(); x++ )
        for( int y = 0; y < m_window->GetHeight(); y++ )
        {
            image.data[(x + (m_window->GetHeight()-1-y) * m_window->GetWidth())*3 + 2] = m_cBuffer[(x + y * m_window->GetWidth())*m_bypp + 0];
            image.data[(x + (m_window->GetHeight()-1-y) * m_window->GetWidth())*3 + 1] = m_cBuffer[(x + y * m_window->GetWidth())*m_bypp + 1];
            image.data[(x + (m_window->GetHeight()-1-y) * m_window->GetWidth())*3 + 0] = m_cBuffer[(x + y * m_window->GetWidth())*m_bypp + 2];
        }
}

void SWCVectorMultiply( MercuryMatrix &m, float *p, float *out )
{
    out[0] = p[0] * m[0][0] + p[1] * m[1][0] + p[2] * m[2][0] + p[3] * m[3][0];
    out[1] = p[0] * m[0][1] + p[1] * m[1][1] + p[2] * m[2][1] + p[3] * m[3][1];
    out[2] = p[0] * m[0][2] + p[1] * m[1][2] + p[2] * m[2][2] + p[3] * m[3][2];
    out[3] = p[0] * m[0][3] + p[1] * m[1][3] + p[2] * m[2][3] + p[3] * m[3][3];
}

void MercuryDisplaySoftwareC::InternalPipelinePoint( const MercuryPoint &pIn, InternalPoint &pOut )
{
    //PRE-VERTEX-SHADER
    static float fi[4];
    static float fj[4];
    fi[0] = pIn.x;
    fi[1] = pIn.y;
    fi[2] = pIn.z;
    fi[3] = 1;
    SWCVectorMultiply( mFinal, fi, fj );

    //Divide-by-perspective step
    pOut.w = fj[3];
    pOut.x = fj[0]/pOut.w;
    pOut.y = fj[1]/pOut.w;
    pOut.z = fj[2]/pOut.w;

    //viewport transform.
    pOut.x *= (m_VPwidth - m_VPx)/(2);
    pOut.x += (m_VPwidth)/2;
    pOut.y *= (m_VPy - m_VPheight)/(2);
    pOut.y += (m_VPheight)/2;
}


#define PLOT( p , c )\
        if ( p.w < 0 )\
            continue;\
        if( p.x < m_width && p.y <= m_height && p.x >= 0 && p.y >= 0)\
            m_cBuffer[ (int( p.x ) + int( p.y )* m_width ) * m_bypp + c] = char(255);

#define FASTCROSSCHECK( x,y, p1x, p1y, p2x, p2y )  ( ( (p1x-x)*(p2y-y) - (p2x-x)*(p1y-y) ) > 0 )

//These two functions operate on a matrix of the form x,y,1,(NC),z,w,u,v  (we're trying to keep alignment)
static void TexmapAddRows( float * fRowWork, float * fRowMultiply, float fQuantity )
{
    fRowWork[0] += fRowMultiply[0] * fQuantity;
    fRowWork[1] += fRowMultiply[1] * fQuantity;
    fRowWork[2] += fRowMultiply[2] * fQuantity;
    fRowWork[3] += fRowMultiply[3] * fQuantity;
    fRowWork[4] += fRowMultiply[4] * fQuantity;
    fRowWork[5] += fRowMultiply[5] * fQuantity;
    fRowWork[6] += fRowMultiply[6] * fQuantity;
    fRowWork[7] += fRowMultiply[7] * fQuantity;
}

static void TexmapScaleRow( float * fRowWork, float fQuantity )
{
    fRowWork[0] *= fQuantity;
    fRowWork[1] *= fQuantity;
    fRowWork[2] *= fQuantity;
    fRowWork[3] *= fQuantity;
    fRowWork[4] *= fQuantity;
    fRowWork[5] *= fQuantity;
    fRowWork[6] *= fQuantity;
    fRowWork[7] *= fQuantity;
}

const static int iRowWidth = 8;
const static int iRowWidth2 = 16;
static float fTMMatrix[24] M_ALIGN(128);    //For SSE2 or SSE

static void TexmapSolutionMatrix( )
{
    //Step0: Prevent inaccuracies
    if( fTMMatrix[0] < 0.001f ) //We'll lose accuracy.
        if( fTMMatrix[iRowWidth] > fTMMatrix[iRowWidth2] )  //So fix it.
            TexmapAddRows( &fTMMatrix[0], &fTMMatrix[iRowWidth], 1 );
        else
            TexmapAddRows( &fTMMatrix[0], &fTMMatrix[iRowWidth2], 1 );

    if( fTMMatrix[iRowWidth + 1] < 0.001f ) //We'll lose accuracy @ (2,2)
        if( fTMMatrix[1] > fTMMatrix[iRowWidth2+1] )    
            TexmapAddRows( &fTMMatrix[iRowWidth], &fTMMatrix[0], 1 );
        else
            TexmapAddRows( &fTMMatrix[iRowWidth], &fTMMatrix[iRowWidth2], 1 );
    
    if( fTMMatrix[iRowWidth2 + 2] < 0.001f )    //We'll lose accuracy @ (3,3)
        if( fTMMatrix[2] > fTMMatrix[iRowWidth+2] ) 
            TexmapAddRows( &fTMMatrix[iRowWidth2], &fTMMatrix[0], 1 );
        else
            TexmapAddRows( &fTMMatrix[iRowWidth2], &fTMMatrix[iRowWidth], 1 );

    //Step1, the first column.
    TexmapScaleRow( &fTMMatrix[0], 1/fTMMatrix[0] );    //(1,1) is now 1.
    TexmapAddRows( &fTMMatrix[iRowWidth], &fTMMatrix[0], -fTMMatrix[iRowWidth]/fTMMatrix[0] );
    TexmapAddRows( &fTMMatrix[iRowWidth2], &fTMMatrix[0], -fTMMatrix[iRowWidth2]/fTMMatrix[0] );

    //Step2, the second column.
    TexmapScaleRow( &fTMMatrix[iRowWidth], 1/fTMMatrix[iRowWidth+1] );
    TexmapAddRows( &fTMMatrix[0], &fTMMatrix[iRowWidth], -fTMMatrix[1]/fTMMatrix[iRowWidth+1] );
    TexmapAddRows( &fTMMatrix[iRowWidth2], &fTMMatrix[iRowWidth], -fTMMatrix[iRowWidth2+1]/fTMMatrix[iRowWidth+1] );

    //Step3, the third column.  
    TexmapScaleRow( &fTMMatrix[iRowWidth2], 1/fTMMatrix[iRowWidth2+2] );
    TexmapAddRows( &fTMMatrix[0], &fTMMatrix[iRowWidth2], -fTMMatrix[2]/fTMMatrix[iRowWidth2+2] );
    TexmapAddRows( &fTMMatrix[iRowWidth], &fTMMatrix[iRowWidth2], -fTMMatrix[iRowWidth+2]/fTMMatrix[iRowWidth2+2] );

    //OK, we should be solved!  Here would be a good place to check to make sure
}

void MercuryDisplaySoftwareC::InternalDrawPoly( const InternalPoint * points, int verts, int mode )
{
    int minX = (int)points[0].x, maxX = (int)points[0].x;
    int minY = (int)points[0].y, maxY = (int)points[0].y;
    int x = (int)points[0].x;
    int y = (int)points[0].y;
    static int i, loc;
    static int j;

    static float iCurrentX[5];
    static float iCurrentY[5];

    //Lines!
    float fLineXSlopes[4];
    float iLineRanges[4][2];        //[ymin] -> [ymax]

    //GEOMETRY SHADER

    for( i = 0; i < verts; i++ )
    {
        iCurrentX[i] = points[i].x;
        iCurrentY[i] = points[i].y;
    }

    //Tricky!  When deciding if we want to render a point, we have to use the pre-existing function
    //however, when deciding if we are going to render a polygon -- we have to be more than strict!
    if( (iCurrentX[1]-iCurrentX[0])*(iCurrentY[2]-iCurrentY[0]) - 
        (iCurrentX[2]-iCurrentX[0])*(iCurrentY[1]-iCurrentY[0]) > -1 )
        return;

    int wfails = 0;
    if( points[0].w < 0 )
        wfails++;


    for( i = 1; i < verts; i++ )
    {
        if( points[i].w < 0 )
            wfails++;
        x = int(points[i].x); y = int(points[i].y);
        if( x < minX ) minX = x;
        else if( x > maxX ) maxX = x;
        if( y < minY ) minY = y;
        else if( y > maxY ) maxY = y;
    }

    if( wfails >= 1 )
        return;

    if( minX >= m_width ) return;
    if( minY >= m_height ) return;
    if( maxX < 0 ) return;
    if( maxY < 0 ) return;
    if( minX < 0 ) minX = 0;
    if( minY < 0 ) minY = 0;
    if( maxX >= m_width ) maxX = m_width-1;
    if( maxY >= m_height ) maxY = m_height-1;

    for( i = 0; i < verts; i++ )
    {
        static float aX,aY,bX,bY; 
        aX = points[i].x;
        aY = points[i].y;
        bX = points[(i+1)%verts].x;
        bY = points[(i+1)%verts].y;

        iLineRanges[i][0] = (aY<bY)?aY:bY;
        iLineRanges[i][1] = (aY>bY)?aY:bY;

        fLineXSlopes[i] = (aX-bX)/(aY-bY);
    }

    bool bHasATexture = m_pCurTexture->m_isMaterial;
    static float iFinalSolutionMatrix[12];

    //Construct the TMMatrix
    for( i = 0; i < 3; i++ )
    {
        //VERTEX SHADER, Part II
        loc = i%verts;
        fTMMatrix[i*iRowWidth+0] = points[i].x;
        fTMMatrix[i*iRowWidth+1] = points[i].y;
        fTMMatrix[i*iRowWidth+2] = 1;
        fTMMatrix[i*iRowWidth+3] = 1; //NOT USED
        fTMMatrix[i*iRowWidth+4] = points[i].z/points[i].w;
        fTMMatrix[i*iRowWidth+5] = 1/points[i].w;
        if( bHasATexture)
        {
            static float fThisU;
            fThisU = points[i].u;
            static float fThisV;
            fThisV = points[i].v;

            fThisU = m_pCurTexture->m_TexMat[0][0] * fThisU + m_pCurTexture->m_TexMat[0][1] * fThisV + m_pCurTexture->m_TexMat[0][3];
            fThisV = m_pCurTexture->m_TexMat[1][0] * fThisU + m_pCurTexture->m_TexMat[1][1] * fThisV + m_pCurTexture->m_TexMat[1][3];
            //Perfrom texture matrix calculations here.
            fTMMatrix[i*iRowWidth+6] = fThisU/points[i].w;// * m_pCurTexture->m_width;
            fTMMatrix[i*iRowWidth+7] = fThisV/points[i].w;// * m_pCurTexture->m_height;
        }
        else
        {
            fTMMatrix[i*iRowWidth+6] = 0;
            fTMMatrix[i*iRowWidth+7] = 0;
        }
    }

    TexmapSolutionMatrix();

    for( i = 0; i < 3; i++ )
    {
        iFinalSolutionMatrix[i*4+0] = (fTMMatrix[i*iRowWidth+4]);
        iFinalSolutionMatrix[i*4+1] = (fTMMatrix[i*iRowWidth+5]);
        iFinalSolutionMatrix[i*4+2] = (fTMMatrix[i*iRowWidth+6]);
        iFinalSolutionMatrix[i*4+3] = (fTMMatrix[i*iRowWidth+7]);
    }

    static unsigned int TAlpha;
    static unsigned int TR;
    static unsigned int TG;
    static unsigned int TB;
    static unsigned int TNAlpha;
    static unsigned int ALPHA;
    static unsigned int NEGALPHA;
    static unsigned int LUMINENCE;
    static unsigned int fBuf;

    static float tf;

    TAlpha = (unsigned int)(m_pCurMaterial.m_diffuse.GetA() * 255.0f);
    TR = (unsigned int)(m_pCurMaterial.m_diffuse.GetR()*TAlpha);
    TG = (unsigned int)(m_pCurMaterial.m_diffuse.GetG()*TAlpha);
    TB = (unsigned int)(m_pCurMaterial.m_diffuse.GetB()*TAlpha);
    TNAlpha = 255-TAlpha;

    bool bNotFullAlpha = ( TAlpha != 255 || TR != 255 || TG != 255 || TB != 255 );

    if( TAlpha == 0 )
        return;

    for( y = minY; y <= maxY; ++y )
    {
        maxX = -1;
        minX = m_width + 1;
        for( i = 0; i < verts; i++ )
            if( iLineRanges[i][0] <= y && iLineRanges[i][1] >= y )
            {
                tf = points[i].x + (y-points[i].y) * fLineXSlopes[i];

                //These first two cases can happen when fLineXSlopes[i] is an incredibly large number.
                if( tf < points[i].x && tf < points[(i+1)%verts].x )
                    tf = (points[i].x<points[(i+1)%verts].x)?points[i].x:points[(i+1)%verts].x;
                if( tf > points[i].x && j > points[(i+1)%verts].x )
                    tf = (points[i].x>points[(i+1)%verts].x)?points[i].x:points[(i+1)%verts].x;

                //These can happen if the line extends off of the screen
                if( j < 0 ) 
                    j = 0;
                else if( j >= m_width )
                    j = m_width-1;

                if( maxX < j ) maxX = j;
                if( minX > j ) minX = j;
            }


        for( x = minX; x<= maxX; ++x )
        {
            //This code runs for EVERY PIXEL, so keep it tight!
            //FRAGMENT SHADER
            static float w;
            w = (iFinalSolutionMatrix[1] * x + iFinalSolutionMatrix[5] * y + iFinalSolutionMatrix[9]);
            static float z;
            z = (iFinalSolutionMatrix[0] * x + iFinalSolutionMatrix[4] * y + iFinalSolutionMatrix[8])*20000;
            
            if( z >= 1500000 || //Too far away to see
                z<0 ||          //Behind camera
                w<0 )           //Culled
                continue;

            loc = x + y*m_width;

            if( bDepthTest )
                if( m_zBuffer[loc] > z )
                    continue;
                else if (m_zBufferWrite)
                    m_zBuffer[loc] = (unsigned int)z;

            static int lBuf;
            lBuf = loc * m_bypp;
            if( bHasATexture )
            {           
                int u,v;

                u = (unsigned int)((iFinalSolutionMatrix[2] * x + iFinalSolutionMatrix[6] * y + iFinalSolutionMatrix[10])*float(m_pCurTexture->m_width)/w);
                v = (unsigned int)((iFinalSolutionMatrix[3] * x + iFinalSolutionMatrix[7] * y + iFinalSolutionMatrix[11])*float(m_pCurTexture->m_height)/w);

                if (m_pCurMercuryTexture->GetMapping() == SPHERE)
                {
                    u += y;
                    v += x;
                }

                u = u%m_pCurTexture->m_width;
                v = v%m_pCurTexture->m_height;
                if( u < 0 ) u+= m_pCurTexture->m_width;
                if( v < 0 ) v+= m_pCurTexture->m_height;

                fBuf = u+v*m_pCurTexture->m_width;

                if( m_pCurTexture->m_type == LUMINANCE_ALPHA )
                {
                    //No adverse effects of just assuming we're always not full alpha
                    ALPHA = m_pCurTexture->m_data[fBuf*2+1] * TAlpha;
                    NEGALPHA = 65536-ALPHA;
                    LUMINENCE = m_pCurTexture->m_data[fBuf*2+0];
                    m_cBuffer[ lBuf + 0] = ( m_cBuffer[ lBuf + 0] * NEGALPHA + LUMINENCE * ALPHA )>>16; 
                    m_cBuffer[ lBuf + 1] = ( m_cBuffer[ lBuf + 1] * NEGALPHA + LUMINENCE * ALPHA )>>16; 
                    m_cBuffer[ lBuf + 2] = ( m_cBuffer[ lBuf + 2] * NEGALPHA + LUMINENCE * ALPHA )>>16; 
                }
                if( !bNotFullAlpha )
                {
                    if ( m_pCurTexture->m_type == RGBA )
                    {
                        ALPHA = m_pCurTexture->m_data[fBuf*4+3];
                        NEGALPHA = 255-ALPHA;

                        m_cBuffer[ lBuf + 2] = ((ALPHA) * m_pCurTexture->m_data[fBuf*4+0] + NEGALPHA * m_cBuffer[ lBuf + 2])>>8;
                        m_cBuffer[ lBuf + 1] = ((ALPHA) * m_pCurTexture->m_data[fBuf*4+1] + NEGALPHA * m_cBuffer[ lBuf + 1])>>8;
                        m_cBuffer[ lBuf + 0] = ((ALPHA) * m_pCurTexture->m_data[fBuf*4+2] + NEGALPHA * m_cBuffer[ lBuf + 0])>>8;
                    } else if ( m_pCurTexture->m_type == RGB )
                    {
                        m_cBuffer[lBuf + 2] = m_pCurTexture->m_data[fBuf*3+0];
                        m_cBuffer[lBuf + 1] = m_pCurTexture->m_data[fBuf*3+1];
                        m_cBuffer[lBuf + 0] = m_pCurTexture->m_data[fBuf*3+2];
                    } 
                } else {
                    if ( m_pCurTexture->m_type == RGBA )
                    {
                        ALPHA = m_pCurTexture->m_data[fBuf*4+3];
                        NEGALPHA = 65536-(TAlpha*ALPHA);

                        m_cBuffer[ lBuf + 2] = (ALPHA * m_pCurTexture->m_data[fBuf*4+0] * TR + NEGALPHA * m_cBuffer[ lBuf + 2] )>>16;
                        m_cBuffer[ lBuf + 1] = (ALPHA * m_pCurTexture->m_data[fBuf*4+1] * TG + NEGALPHA * m_cBuffer[ lBuf + 1] )>>16;
                        m_cBuffer[ lBuf + 0] = (ALPHA * m_pCurTexture->m_data[fBuf*4+2] * TB + NEGALPHA * m_cBuffer[ lBuf + 0] )>>16;
                    } else if ( m_pCurTexture->m_type == RGB )
                    {
                        m_cBuffer[lBuf + 2] = ( m_cBuffer[lBuf + 2] * TNAlpha + m_pCurTexture->m_data[fBuf*3+0] * TR )>>8;
                        m_cBuffer[lBuf + 1] = ( m_cBuffer[lBuf + 1] * TNAlpha + m_pCurTexture->m_data[fBuf*3+1] * TG )>>8;
                        m_cBuffer[lBuf + 0] = ( m_cBuffer[lBuf + 0] * TNAlpha + m_pCurTexture->m_data[fBuf*3+2] * TB )>>8;
                    } 
                }
            } else {
                m_cBuffer[lBuf + 0] = (( m_cBuffer[lBuf + 0] * TNAlpha )>>8) + TB;
                m_cBuffer[lBuf + 1] = (( m_cBuffer[lBuf + 1] * TNAlpha )>>8) + TG;
                m_cBuffer[lBuf + 2] = (( m_cBuffer[lBuf + 2] * TNAlpha )>>8) + TR;
            }
        }
        }
}

void MercuryDisplaySoftwareC::SendMatrixData(const MercuryMatrix& m)
{
    static MercuryMatrix projection;
    static MercuryMatrix modelView;

    projection = GetProjection();
//  modelView = ViewStack.GetTop() * WorldStack.GetTop();
//  modelView = ViewStack.GetTop() * m;
    modelView = m_view * m;

    projection.Transpose();
    modelView.Transpose();

    mFinal = modelView * projection;
}


/* 
 * Copyright (c) 2006 Charles Lohr
 * 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.
 *  -   Neither the name of the Mercury Engine nor the names of its
 *      contributors may be used to endorse or promote products derived from
 *      this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 THE COPYRIGHT OWNER OR 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.
 */

---

Hosted by