khanat-opennel-code/code/nel/src/3d/computed_string.cpp
acemtp@users.sourceforge.net d5c601ffa5 initial version
2010-05-06 02:08:41 +02:00

735 lines
23 KiB
C++

// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program 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 Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "std3d.h"
#include "nel/3d/computed_string.h"
#include "nel/3d/texture.h"
#include "nel/3d/index_buffer.h"
#include "nel/3d/material.h"
#include "nel/3d/frustum.h"
#include "nel/misc/smart_ptr.h"
#include "nel/misc/debug.h"
#include "nel/misc/file.h"
#include "nel/misc/fast_mem.h"
using namespace std;
namespace NL3D {
/*------------------------------------------------------------------*\
getHotSpotVector()
\*------------------------------------------------------------------*/
CVector CComputedString::getHotSpotVector(THotSpot hotspot)
{
CVector hotspotVector(0,0,0);
if (hotspot==MiddleLeft)
hotspotVector = CVector(0,0,-StringHeight/2);
if (hotspot==TopLeft)
hotspotVector = CVector(0,0,-StringHeight);
if (hotspot==MiddleBottom)
hotspotVector = CVector(-StringWidth/2,0,0);
if (hotspot==MiddleMiddle)
hotspotVector = CVector(-StringWidth/2,0,-StringHeight/2);
if (hotspot==MiddleTop)
hotspotVector = CVector(-StringWidth/2,0,-StringHeight);
if (hotspot==BottomRight)
hotspotVector = CVector(-StringWidth,0,0);
if (hotspot==MiddleRight)
hotspotVector = CVector(-StringWidth,0,-StringHeight/2);
if (hotspot==TopRight)
hotspotVector = CVector(-StringWidth,0,-StringHeight);
return hotspotVector;
}
/*------------------------------------------------------------------*\
render2D()
\*------------------------------------------------------------------*/
void CComputedString::render2D (IDriver& driver,
float x, float z,
THotSpot hotspot,
float scaleX, float scaleZ,
float rotateY,
bool useScreenAR43, bool roundToNearestPixel
)
{
if (Vertices.getNumVertices() == 0)
return;
// get window size
uint32 wndWidth, wndHeight;
driver.getWindowSize(wndWidth, wndHeight);
// scale to window size.
x*= wndWidth;
z*= wndHeight;
driver.setFrustum(0, (float)wndWidth, 0, (float)wndHeight, -1, 1, false); // resX/resY
// Computing hotspot translation vector
CVector hotspotVector = getHotSpotVector(hotspot);
// transformation matrix initialized to identity
CMatrix matrix;
matrix.identity();
// view matrix <-> identity
driver.setupViewMatrix(matrix);
// model matrix :
// centering to hotspot, then scaling, rotating, and translating.
matrix.translate(CVector(x,0,z));
matrix.rotateY(rotateY);
matrix.scale(CVector(scaleX,1,scaleZ));
// scale the string to follow window aspect Ratio
if(useScreenAR43)
{
matrix.scale(CVector((3.0f*wndWidth)/(4.0f*wndHeight),1,1));
}
matrix.translate(hotspotVector);
// if roundToNearestPixel, then snap the position to the nearest pixel
if( roundToNearestPixel)
{
CVector pos= matrix.getPos();
pos.x= (float)floor(pos.x+0.5f);
pos.z= (float)floor(pos.z+0.5f);
matrix.setPos(pos);
}
// setup the matrix
driver.setupModelMatrix(matrix);
driver.activeVertexBuffer(Vertices);
// rendering each primitives
Material->setZFunc (CMaterial::always);
Material->setZWrite (false);
Material->setColor (Color);
// Clamp for selection
uint32 nNumQuad= Vertices.getNumVertices()/4;
driver.renderRawQuads (*Material, SelectStart*4, min(nNumQuad, SelectSize) );
}
/*------------------------------------------------------------------*\
render3D()
\*------------------------------------------------------------------*/
void CComputedString::render3D (IDriver& driver,CMatrix matrix,THotSpot hotspot)
{
if (Vertices.getNumVertices() == 0)
return;
// get window size
uint32 wndWidth, wndHeight;
driver.getWindowSize(wndWidth, wndHeight);
// scale according to window height (backward compatibility)
matrix.scale(1.0f/wndHeight);
// Computing hotspot translation vector
CVector hotspotVector = getHotSpotVector(hotspot);
matrix.translate(hotspotVector);
// render
driver.setupModelMatrix(matrix);
driver.activeVertexBuffer(Vertices);
// Rendering each primitive blocks
Material->setZFunc (CMaterial::lessequal);
Material->setZWrite (true);
Material->setColor (Color);
// Clamp for selection
uint32 nNumQuad= Vertices.getNumVertices()/4;
driver.renderRawQuads (*Material, SelectStart*4, min(nNumQuad, SelectSize) );
}
/*------------------------------------------------------------------*\
render2DClip()
\*------------------------------------------------------------------*/
void CComputedString::render2DClip (IDriver& driver, CRenderStringBuffer &rdrBuffer,
float x, float z,
float xmin, float zmin, float xmax, float zmax)
{
if (Vertices.getNumVertices() == 0)
return;
if(SelectSize==0)
return;
// get window size
uint32 wndWidth, wndHeight;
driver.getWindowSize(wndWidth, wndHeight);
// scale to window size.
x*= wndWidth;
z*= wndHeight;
xmin*= wndWidth;
xmax*= wndWidth;
zmin*= wndHeight;
zmax*= wndHeight;
// Test String Bound against clip window
// If entirely out skip
if (((x+XMin) > xmax) || ((x+XMax) < xmin) ||
((z+ZMin) > zmax) || ((z+ZMax) < zmin))
return;
// test if entirely in.
bool allIn;
allIn= ((x+XMin) >= xmin) && ((x+XMax) <= xmax) &&
((z+ZMin) >= zmin) && ((z+ZMax) <= zmax);
// How many quad to render?
uint nNumQuadSrc= Vertices.getNumVertices()/4;
nNumQuadSrc= min(nNumQuadSrc, (uint)SelectSize);
// Enlarge dest Buffer if needed
if( (rdrBuffer.NumQuads+nNumQuadSrc)*4 > rdrBuffer.Vertices.getNumVertices() )
{
rdrBuffer.Vertices.setNumVertices( (rdrBuffer.NumQuads+nNumQuadSrc)*4 );
}
// prepare copy.
CVertexBuffer::TVertexColorType vtype = driver.getVertexColorFormat();
Vertices.setVertexColorFormat (vtype);
rdrBuffer.Vertices.setVertexColorFormat (vtype);
CVertexBufferReadWrite srcvba;
Vertices.lock (srcvba);
CVertexBufferReadWrite dstvba;
rdrBuffer.Vertices.lock (dstvba);
sint ofsSrcUV= Vertices.getTexCoordOff();
sint ofsDstUV= rdrBuffer.Vertices.getTexCoordOff();
sint ofsDstColor= rdrBuffer.Vertices.getColorOff();
uint8 *srcPtr= (uint8*)srcvba.getVertexCoordPointer();
uint8 *dstPtr= (uint8*)dstvba.getVertexCoordPointer(rdrBuffer.NumQuads*4);
sint srcSize= Vertices.getVertexSize();
sint dstSize= rdrBuffer.Vertices.getVertexSize();
// decal src for selection
srcPtr+= SelectStart*4 * srcSize;
CRGBA mCol = Color;
// **** clipping?
if(allIn)
{
// copy All vertices
uint numVerts= nNumQuadSrc*4;
uint count = 4;
uint lastIndex = 0;
for(uint i=0;i<numVerts;i++)
{
if(count==4){
if(!LetterColors.empty())
{
if(LetterColors.getIndex(lastIndex)==i/4)
{
mCol.modulateFromColor(Color, LetterColors.getColor(lastIndex));
if(lastIndex+1<LetterColors.size())
{
lastIndex++;
}
}
}
count = 0;
}
// copy and translate pos
CHECK_VBA_RANGE(srcvba, srcPtr, Vertices.getVertexSize());
CHECK_VBA_RANGE(dstvba, dstPtr, rdrBuffer.Vertices.getVertexSize())
((CVector*)dstPtr)->x= x + ((CVector*)srcPtr)->x;
((CVector*)dstPtr)->y= ((CVector*)srcPtr)->y;
((CVector*)dstPtr)->z= z + ((CVector*)srcPtr)->z;
// uv
*((CUV*)(dstPtr+ofsDstUV))= *((CUV*)(srcPtr+ofsSrcUV));
// color
if (vtype == CVertexBuffer::TRGBA)
*((CRGBA*)(dstPtr+ofsDstColor))= mCol;
else
*((CBGRA*)(dstPtr+ofsDstColor))= mCol;
// next
srcPtr+= srcSize;
dstPtr+= dstSize;
count++;
}
// update the rdrBuffer
rdrBuffer.NumQuads+= nNumQuadSrc;
}
else
{
uint nNumQuadClipped= 0;
// the real number of vertices to compute (with selection)
uint numVerts= nNumQuadSrc*4;
// clip into VerticesClipped
CVector *pIniPos0 = (CVector*)srcPtr;
CVector *pIniPos2 = (CVector*)(((uint8*)pIniPos0) + srcSize*2);
CVector *pClipPos0 = (CVector*)dstPtr;
CVector *pClipPos1 = (CVector*)(((uint8*)pClipPos0) + dstSize);
CVector *pClipPos2 = (CVector*)(((uint8*)pClipPos1) + dstSize);
CVector *pClipPos3 = (CVector*)(((uint8*)pClipPos2) + dstSize);
CUV *pClipUV0 = (CUV*)(dstPtr + ofsDstUV );
CUV *pClipUV1 = (CUV*)(((uint8*)pClipUV0) + dstSize);
CUV *pClipUV2 = (CUV*)(((uint8*)pClipUV1) + dstSize);
CUV *pClipUV3 = (CUV*)(((uint8*)pClipUV2) + dstSize);
float ratio;
uint lastIndex = 0;
for (uint32 i = 0; i < numVerts; i+=4)
{
if (((x+pIniPos0->x) > xmax) || ((x+pIniPos2->x) < xmin) ||
((z+pIniPos0->z) > zmax) || ((z+pIniPos2->z) < zmin))
{
// Totally clipped do nothing
}
else
{
if(!LetterColors.empty())
{
if(LetterColors.getIndex(lastIndex)==(i/4))
{
mCol.modulateFromColor(Color, LetterColors.getColor(lastIndex));
if(lastIndex+1<LetterColors.size())
{
lastIndex++;
}
}
}
// copy with no clip
// v0
*((CVector*) (dstPtr + dstSize*0))= *((CVector*) (srcPtr + srcSize*0));
*((CUV*) (dstPtr + dstSize*0 + ofsDstUV))= *((CUV*)(srcPtr + srcSize*0 + ofsSrcUV));
if (vtype == CVertexBuffer::TRGBA)
*((CRGBA*) (dstPtr + dstSize*0 + ofsDstColor))= mCol;
else
*((CBGRA*) (dstPtr + dstSize*0 + ofsDstColor))= mCol;
// v1
*((CVector*) (dstPtr + dstSize*1))= *((CVector*) (srcPtr + srcSize*1));
*((CUV*) (dstPtr + dstSize*1 + ofsDstUV))= *((CUV*)(srcPtr + srcSize*1 + ofsSrcUV));
if (vtype == CVertexBuffer::TRGBA)
*((CRGBA*) (dstPtr + dstSize*1 + ofsDstColor))= mCol;
else
*((CBGRA*) (dstPtr + dstSize*1 + ofsDstColor))= mCol;
// v2
*((CVector*) (dstPtr + dstSize*2))= *((CVector*) (srcPtr + srcSize*2));
*((CUV*) (dstPtr + dstSize*2 + ofsDstUV))= *((CUV*)(srcPtr + srcSize*2 + ofsSrcUV));
if (vtype == CVertexBuffer::TRGBA)
*((CRGBA*) (dstPtr + dstSize*2 + ofsDstColor))= mCol;
else
*((CBGRA*) (dstPtr + dstSize*2 + ofsDstColor))= mCol;
// v3
*((CVector*) (dstPtr + dstSize*3))= *((CVector*) (srcPtr + srcSize*3));
*((CUV*) (dstPtr + dstSize*3 + ofsDstUV))= *((CUV*)(srcPtr + srcSize*3 + ofsSrcUV));
if (vtype == CVertexBuffer::TRGBA)
*((CRGBA*) (dstPtr + dstSize*3 + ofsDstColor))= mCol;
else
*((CBGRA*) (dstPtr + dstSize*3 + ofsDstColor))= mCol;
// translate dest
pClipPos0->x += x; pClipPos1->x += x; pClipPos2->x += x; pClipPos3->x += x;
pClipPos0->z += z; pClipPos1->z += z; pClipPos2->z += z; pClipPos3->z += z;
if ((pClipPos0->x >= xmin) && (pClipPos0->z >= zmin) && (pClipPos2->x <= xmax) && (pClipPos2->z <= zmax))
{
// Not clipped
}
else
{
// Partially clipped
if (pClipPos0->x < xmin)
{
ratio = ((float)(xmin - pClipPos0->x))/((float)(pClipPos1->x - pClipPos0->x));
pClipPos3->x = pClipPos0->x = xmin;
pClipUV0->U += ratio*(pClipUV1->U - pClipUV0->U);
pClipUV3->U += ratio*(pClipUV2->U - pClipUV3->U);
}
if (pClipPos0->z < zmin)
{
ratio = ((float)(zmin - pClipPos0->z))/((float)(pClipPos3->z - pClipPos0->z));
pClipPos1->z = pClipPos0->z = zmin;
pClipUV0->V += ratio*(pClipUV3->V - pClipUV0->V);
pClipUV1->V += ratio*(pClipUV2->V - pClipUV1->V);
}
if (pClipPos2->x > xmax)
{
ratio = ((float)(xmax - pClipPos2->x))/((float)(pClipPos3->x - pClipPos2->x));
pClipPos2->x = pClipPos1->x = xmax;
pClipUV2->U += ratio*(pClipUV3->U - pClipUV2->U);
pClipUV1->U += ratio*(pClipUV0->U - pClipUV1->U);
}
if (pClipPos2->z > zmax)
{
ratio = ((float)(zmax - pClipPos2->z))/((float)(pClipPos1->z - pClipPos2->z));
pClipPos2->z = pClipPos3->z = zmax;
pClipUV2->V += ratio*(pClipUV1->V - pClipUV2->V);
pClipUV3->V += ratio*(pClipUV0->V - pClipUV3->V);
}
}
// next quad out
++nNumQuadClipped;
pClipPos0 = (CVector*)(((uint8*)pClipPos0) + dstSize*4);
pClipPos1 = (CVector*)(((uint8*)pClipPos0) + dstSize);
pClipPos2 = (CVector*)(((uint8*)pClipPos1) + dstSize);
pClipPos3 = (CVector*)(((uint8*)pClipPos2) + dstSize);
pClipUV0 = (CUV*)( ((uint8*)pClipUV0) + dstSize*4 );
pClipUV1 = (CUV*)(((uint8*)pClipUV0) + dstSize);
pClipUV2 = (CUV*)(((uint8*)pClipUV1) + dstSize);
pClipUV3 = (CUV*)(((uint8*)pClipUV2) + dstSize);
dstPtr+= 4*dstSize;
}
// next quad in
pIniPos0 = (CVector*)(((uint8*)pIniPos0) + srcSize*4);
pIniPos2 = (CVector*)(((uint8*)pIniPos0) + srcSize*2);
srcPtr+= 4*srcSize;
}
// update the rdrBuffer
rdrBuffer.NumQuads+= nNumQuadClipped;
}
}
/*------------------------------------------------------------------*\
render2DUnProjected()
\*------------------------------------------------------------------*/
void CComputedString::render2DUnProjected (IDriver& driver, CRenderStringBuffer &rdrBuffer, class NL3D::CFrustum &frustum,
const NLMISC::CMatrix &scaleMatrix, float x, float z, float depth, float xmin, float zmin, float xmax, float zmax)
{
if (Vertices.getNumVertices() == 0)
return;
if(SelectSize==0)
return;
// get window size
uint32 wndWidth, wndHeight;
driver.getWindowSize(wndWidth, wndHeight);
// scale to window size.
x*= wndWidth;
z*= wndHeight;
xmin*= wndWidth;
xmax*= wndWidth;
zmin*= wndHeight;
zmax*= wndHeight;
// Test String Bound against clip window
// If entirely out skip
if (((x+XMin) > xmax) || ((x+XMax) < xmin) ||
((z+ZMin) > zmax) || ((z+ZMax) < zmin))
return;
// test if entirely in.
bool allIn;
allIn= ((x+XMin) >= (xmin-0.001f)) && ((x+XMax) <= (xmax+0.001f)) &&
((z+ZMin) >= (zmin-0.001f)) && ((z+ZMax) <= (zmax+0.001f));
// How many quad to render?
uint nNumQuadSrc= Vertices.getNumVertices()/4;
nNumQuadSrc= min(nNumQuadSrc, (uint)SelectSize);
// Enlarge dest Buffer if needed
if( (rdrBuffer.NumQuads+nNumQuadSrc)*4 > rdrBuffer.Vertices.getNumVertices() )
{
rdrBuffer.Vertices.setNumVertices( (rdrBuffer.NumQuads+nNumQuadSrc)*4 );
}
// prepare copy.
CVertexBuffer::TVertexColorType vtype = driver.getVertexColorFormat();
Vertices.setVertexColorFormat (vtype);
rdrBuffer.Vertices.setVertexColorFormat (vtype);
CVertexBufferReadWrite srcvba;
Vertices.lock (srcvba);
CVertexBufferReadWrite dstvba;
rdrBuffer.Vertices.lock (dstvba);
sint ofsSrcUV= Vertices.getTexCoordOff();
sint ofsDstUV= rdrBuffer.Vertices.getTexCoordOff();
sint ofsDstColor= rdrBuffer.Vertices.getColorOff();
uint8 *srcPtr= (uint8*)srcvba.getVertexCoordPointer();
uint8 *dstPtr= (uint8*)dstvba.getVertexCoordPointer(rdrBuffer.NumQuads*4);
sint srcSize= Vertices.getVertexSize();
sint dstSize= rdrBuffer.Vertices.getVertexSize();
// decal src for selection
srcPtr+= SelectStart*4 * srcSize;
uint8 *dstPtrBackup = dstPtr;
// **** clipping?
if(allIn)
{
// copy All vertices
uint numVerts= nNumQuadSrc*4;
for(uint i=0;i<numVerts;i++)
{
// copy and translate pos
CHECK_VBA_RANGE(dstvba, dstPtr, Vertices.getVertexSize());
CHECK_VBA_RANGE(srcvba, srcPtr, rdrBuffer.Vertices.getVertexSize());
((CVector*)dstPtr)->x= x + ((CVector*)srcPtr)->x;
((CVector*)dstPtr)->z= z + ((CVector*)srcPtr)->z;
// uv
*((CUV*)(dstPtr+ofsDstUV))= *((CUV*)(srcPtr+ofsSrcUV));
// color
if (vtype == CVertexBuffer::TRGBA)
*((CRGBA*)(dstPtr+ofsDstColor))= Color;
else
*((CBGRA*)(dstPtr+ofsDstColor))= Color;
// next
srcPtr+= srcSize;
dstPtr+= dstSize;
}
// update the rdrBuffer
rdrBuffer.NumQuads+= nNumQuadSrc;
}
else
{
uint nNumQuadClipped= 0;
// the real number of vertices to compute (with selection)
uint numVerts= nNumQuadSrc*4;
// clip into VerticesClipped
CVector *pIniPos0 = (CVector*)srcPtr;
CVector *pIniPos2 = (CVector*)(((uint8*)pIniPos0) + srcSize*2);
CVector *pClipPos0 = (CVector*)dstPtr;
CVector *pClipPos1 = (CVector*)(((uint8*)pClipPos0) + dstSize);
CVector *pClipPos2 = (CVector*)(((uint8*)pClipPos1) + dstSize);
CVector *pClipPos3 = (CVector*)(((uint8*)pClipPos2) + dstSize);
CUV *pClipUV0 = (CUV*)(dstPtr + ofsDstUV );
CUV *pClipUV1 = (CUV*)(((uint8*)pClipUV0) + dstSize);
CUV *pClipUV2 = (CUV*)(((uint8*)pClipUV1) + dstSize);
CUV *pClipUV3 = (CUV*)(((uint8*)pClipUV2) + dstSize);
float ratio;
for (uint32 i = 0; i < numVerts; i+=4)
{
if (((x+pIniPos0->x) > xmax) || ((x+pIniPos2->x) < xmin) ||
((z+pIniPos0->z) > zmax) || ((z+pIniPos2->z) < zmin))
{
// Totally clipped do nothing
}
else
{
// copy with no clip
// v0
*((CVector*) (dstPtr + dstSize*0))= *((CVector*) (srcPtr + srcSize*0));
*((CUV*) (dstPtr + dstSize*0 + ofsDstUV))= *((CUV*)(srcPtr + srcSize*0 + ofsSrcUV));
if (vtype == CVertexBuffer::TRGBA)
*((CRGBA*) (dstPtr + dstSize*0 + ofsDstColor))= Color;
else
*((CBGRA*) (dstPtr + dstSize*0 + ofsDstColor))= Color;
// v1
*((CVector*) (dstPtr + dstSize*1))= *((CVector*) (srcPtr + srcSize*1));
*((CUV*) (dstPtr + dstSize*1 + ofsDstUV))= *((CUV*)(srcPtr + srcSize*1 + ofsSrcUV));
if (vtype == CVertexBuffer::TRGBA)
*((CRGBA*) (dstPtr + dstSize*1 + ofsDstColor))= Color;
else
*((CBGRA*) (dstPtr + dstSize*1 + ofsDstColor))= Color;
// v2
*((CVector*) (dstPtr + dstSize*2))= *((CVector*) (srcPtr + srcSize*2));
*((CUV*) (dstPtr + dstSize*2 + ofsDstUV))= *((CUV*)(srcPtr + srcSize*2 + ofsSrcUV));
if (vtype == CVertexBuffer::TRGBA)
*((CRGBA*) (dstPtr + dstSize*2 + ofsDstColor))= Color;
else
*((CBGRA*) (dstPtr + dstSize*2 + ofsDstColor))= Color;
// v3
*((CVector*) (dstPtr + dstSize*3))= *((CVector*) (srcPtr + srcSize*3));
*((CUV*) (dstPtr + dstSize*3 + ofsDstUV))= *((CUV*)(srcPtr + srcSize*3 + ofsSrcUV));
if (vtype == CVertexBuffer::TRGBA)
*((CRGBA*) (dstPtr + dstSize*3 + ofsDstColor))= Color;
else
*((CBGRA*) (dstPtr + dstSize*3 + ofsDstColor))= Color;
// translate dest
pClipPos0->x += x; pClipPos1->x += x; pClipPos2->x += x; pClipPos3->x += x;
pClipPos0->z += z; pClipPos1->z += z; pClipPos2->z += z; pClipPos3->z += z;
if ((pClipPos0->x >= xmin) && (pClipPos0->z >= zmin) && (pClipPos2->x <= xmax) && (pClipPos2->z <= zmax))
{
// Not clipped
}
else
{
// Partially clipped
if (pClipPos0->x < xmin)
{
ratio = ((float)(xmin - pClipPos0->x))/((float)(pClipPos1->x - pClipPos0->x));
pClipPos3->x = pClipPos0->x = xmin;
pClipUV0->U += ratio*(pClipUV1->U - pClipUV0->U);
pClipUV3->U += ratio*(pClipUV2->U - pClipUV3->U);
}
if (pClipPos0->z < zmin)
{
ratio = ((float)(zmin - pClipPos0->z))/((float)(pClipPos3->z - pClipPos0->z));
pClipPos1->z = pClipPos0->z = zmin;
pClipUV0->V += ratio*(pClipUV3->V - pClipUV0->V);
pClipUV1->V += ratio*(pClipUV2->V - pClipUV1->V);
}
if (pClipPos2->x > xmax)
{
ratio = ((float)(xmax - pClipPos2->x))/((float)(pClipPos3->x - pClipPos2->x));
pClipPos2->x = pClipPos1->x = xmax;
pClipUV2->U += ratio*(pClipUV3->U - pClipUV2->U);
pClipUV1->U += ratio*(pClipUV0->U - pClipUV1->U);
}
if (pClipPos2->z > zmax)
{
ratio = ((float)(zmax - pClipPos2->z))/((float)(pClipPos1->z - pClipPos2->z));
pClipPos2->z = pClipPos3->z = zmax;
pClipUV2->V += ratio*(pClipUV1->V - pClipUV2->V);
pClipUV3->V += ratio*(pClipUV0->V - pClipUV3->V);
}
}
// next quad out
++nNumQuadClipped;
pClipPos0 = (CVector*)(((uint8*)pClipPos0) + dstSize*4);
pClipPos1 = (CVector*)(((uint8*)pClipPos0) + dstSize);
pClipPos2 = (CVector*)(((uint8*)pClipPos1) + dstSize);
pClipPos3 = (CVector*)(((uint8*)pClipPos2) + dstSize);
pClipUV0 = (CUV*)( ((uint8*)pClipUV0) + dstSize*4 );
pClipUV1 = (CUV*)(((uint8*)pClipUV0) + dstSize);
pClipUV2 = (CUV*)(((uint8*)pClipUV1) + dstSize);
pClipUV3 = (CUV*)(((uint8*)pClipUV2) + dstSize);
dstPtr+= 4*dstSize;
}
// next quad in
pIniPos0 = (CVector*)(((uint8*)pIniPos0) + srcSize*4);
pIniPos2 = (CVector*)(((uint8*)pIniPos0) + srcSize*2);
srcPtr+= 4*srcSize;
}
// update the rdrBuffer
rdrBuffer.NumQuads+= nNumQuadClipped;
}
const float OOW = 1.f / (float)wndWidth;
const float OOH = 1.f / (float)wndHeight;
while (dstPtrBackup != dstPtr)
{
// preset unprojection
CVector tmp;
tmp.x = ((CVector*)dstPtrBackup)->x * OOW;
tmp.y = ((CVector*)dstPtrBackup)->z * OOH;
tmp.z = depth;
// mul by user scale matrix
tmp= scaleMatrix * tmp;
// Unproject it
*((CVector*)dstPtrBackup) = frustum.unProjectZ(tmp);
dstPtrBackup += dstSize;
}
}
// ***************************************************************************
CRenderStringBuffer::CRenderStringBuffer()
{
// Use color per vertex
Vertices.setVertexFormat (CVertexBuffer::PositionFlag | CVertexBuffer::TexCoord0Flag | CVertexBuffer::PrimaryColorFlag);
Vertices.setPreferredMemory (CVertexBuffer::RAMVolatile, true);
Vertices.setName("CRenderStringBuffer");
NumQuads= 0;
}
// ***************************************************************************
CRenderStringBuffer::~CRenderStringBuffer()
{
}
// ***************************************************************************
void CRenderStringBuffer::flush(IDriver& driver, CMaterial *fontMat)
{
if(NumQuads==0)
return;
// get window size
uint32 wndWidth, wndHeight;
driver.getWindowSize(wndWidth, wndHeight);
// **** setup driver context
driver.setFrustum(0, (float)wndWidth, 0, (float)wndHeight, -1, 1, false); // resX/resY
// view matrix and model matrix <-> identity
driver.setupViewMatrix (CMatrix::Identity);
driver.setupModelMatrix (CMatrix::Identity);
// setup material
fontMat->setZFunc (CMaterial::always);
fontMat->setZWrite (false);
// setup vertices clipped
driver.activeVertexBuffer (Vertices);
// *** rendering
driver.renderRawQuads (*fontMat, 0, NumQuads );
// *** reset
NumQuads= 0;
}
// ***************************************************************************
void CRenderStringBuffer::flushUnProjected(IDriver& driver, CMaterial *fontMat, bool zwrite)
{
if(NumQuads==0)
return;
// setup material
fontMat->setZFunc (CMaterial::lessequal);
fontMat->setZWrite (zwrite);
// setup vertices clipped
driver.activeVertexBuffer (Vertices);
// *** rendering
driver.renderRawQuads (*fontMat, 0, NumQuads );
// *** reset
NumQuads= 0;
}
} // NL3D