nel/src/3d/computed_string.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2013-2014  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
   6 //
   7 // This program is free software: you can redistribute it and/or modify
   8 // it under the terms of the GNU Affero General Public License as
   9 // published by the Free Software Foundation, either version 3 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU Affero General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU Affero General Public License
  18 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 #include "std3d.h"
  21
  22 #include "nel/3d/computed_string.h"
  23 #include "nel/3d/texture.h"
  24 #include "nel/3d/index_buffer.h"
  25 #include "nel/3d/material.h"
  26 #include "nel/3d/frustum.h"
  27 #include "nel/3d/viewport.h"
  28 #include "nel/3d/debug_vb.h"
  29
  30 #include "nel/misc/smart_ptr.h"
  31 #include "nel/misc/debug.h"
  32
  33 #include "nel/misc/file.h"
  34 #include "nel/misc/fast_mem.h"
  35
  36 using namespace std;
  37
  38 #ifdef DEBUG_NEW
  39 #define new DEBUG_NEW
  40 #endif
  41
  42 namespace NL3D {
  43
  44
  45 /*------------------------------------------------------------------*\
  46                                                         getHotSpotVector()
  47 \*------------------------------------------------------------------*/
  48 CVector CComputedString::getHotSpotVector(THotSpot hotspot)
  49 {
  50         CVector hotspotVector(0,0,0);
  51
  52         if (hotspot==MiddleLeft)
  53                 hotspotVector = CVector(0,0,-StringHeight/2);
  54
  55         if (hotspot==TopLeft)
  56                 hotspotVector = CVector(0,0,-StringHeight);
  57
  58         if (hotspot==MiddleBottom)
  59                 hotspotVector = CVector(-StringWidth/2,0,0);
  60
  61         if (hotspot==MiddleMiddle)
  62                 hotspotVector = CVector(-StringWidth/2,0,-StringHeight/2);
  63
  64         if (hotspot==MiddleTop)
  65                 hotspotVector = CVector(-StringWidth/2,0,-StringHeight);
  66
  67         if (hotspot==BottomRight)
  68                 hotspotVector = CVector(-StringWidth,0,0);
  69
  70         if (hotspot==MiddleRight)
  71                 hotspotVector = CVector(-StringWidth,0,-StringHeight/2);
  72
  73         if (hotspot==TopRight)
  74                 hotspotVector = CVector(-StringWidth,0,-StringHeight);
  75
  76         return hotspotVector;
  77 }
  78
  79
  80 /*------------------------------------------------------------------*\
  81                                                         render2D()
  82 \*------------------------------------------------------------------*/
  83 void CComputedString::render2D (IDriver& driver,
  84                                                                 float x, float z,
  85                                                                 THotSpot hotspot,
  86                                                                 float scaleX, float scaleZ,
  87                                                                 float rotateY,
  88                                                                 bool useScreenAR43, bool roundToNearestPixel
  89                                                                 )
  90 {
  91         if (Vertices.getNumVertices() == 0)
  92                 return;
  93
  94         // get window size
  95         uint32  wndWidth, wndHeight;
  96         driver.getWindowSize(wndWidth, wndHeight);
  97         CViewport vp;
  98         driver.getViewport(vp);
  99         wndWidth = (uint32)((float)wndWidth * vp.getWidth());
 100         wndHeight = (uint32)((float)wndHeight * vp.getHeight());
 101         // scale to window size.
 102         x*= wndWidth;
 103         z*= wndHeight;
 104
 105         driver.setFrustum(0, (float)wndWidth, 0, (float)wndHeight, -1, 1, false);  // resX/resY
 106
 107         // Computing hotspot translation vector
 108         CVector hotspotVector = getHotSpotVector(hotspot);
 109
 110         // transformation matrix initialized to identity
 111         CMatrix matrix;
 112         matrix.identity();
 113
 114         // view matrix <-> identity
 115         driver.setupViewMatrix(matrix);
 116
 117         // model matrix :
 118         // centering to hotspot, then scaling, rotating, and translating.
 119         matrix.translate(CVector(x,0,z));
 120         matrix.rotateY(rotateY);
 121         matrix.scale(CVector(scaleX,1,scaleZ));
 122         // scale the string to follow window aspect Ratio
 123         if(useScreenAR43)
 124         {
 125                 matrix.scale(CVector((3.0f*wndWidth)/(4.0f*wndHeight),1,1));
 126         }
 127         matrix.translate(hotspotVector);
 128         // if roundToNearestPixel, then snap the position to the nearest pixel
 129         if( roundToNearestPixel)
 130         {
 131                 CVector pos= matrix.getPos();
 132                 pos.x= (float)floor(pos.x+0.5f);
 133                 pos.z= (float)floor(pos.z+0.5f);
 134                 matrix.setPos(pos);
 135         }
 136         // setup the matrix
 137         driver.setupModelMatrix(matrix);
 138
 139         driver.activeVertexBuffer(Vertices);
 140
 141         // rendering each primitives
 142         Material->setZFunc (CMaterial::always);
 143         Material->setZWrite (false);
 144         Material->setColor (Color);
 145         // Clamp for selection
 146         uint32  nNumQuad= Vertices.getNumVertices()/4;
 147         driver.renderRawQuads (*Material, SelectStart*4, min(nNumQuad, SelectSize) );
 148 }
 149
 150
 151 /*------------------------------------------------------------------*\
 152                                                         render3D()
 153 \*------------------------------------------------------------------*/
 154 void CComputedString::render3D (IDriver& driver, const CMatrix &matrixp, THotSpot hotspot)
 155 {
 156         if (Vertices.getNumVertices() == 0)
 157                 return;
 158
 159         CMatrix matrix = matrixp;
 160
 161         // get window size
 162         uint32  wndWidth, wndHeight;
 163         driver.getWindowSize(wndWidth, wndHeight);
 164         // scale according to window height (backward compatibility)
 165         matrix.scale(1.0f/wndHeight);
 166
 167         // Computing hotspot translation vector
 168         CVector hotspotVector = getHotSpotVector(hotspot);
 169         matrix.translate(hotspotVector);
 170
 171         // render
 172         driver.setupModelMatrix(matrix);
 173         driver.activeVertexBuffer(Vertices);
 174
 175         // Rendering each primitive blocks
 176         Material->setZFunc (CMaterial::lessequal);
 177         Material->setZWrite (true);
 178         Material->setColor (Color);
 179         // Clamp for selection
 180         uint32  nNumQuad= Vertices.getNumVertices()/4;
 181         driver.renderRawQuads (*Material, SelectStart*4, min(nNumQuad, SelectSize) );
 182 }
 183
 184
 185 /*------------------------------------------------------------------*\
 186                                                         render2DClip()
 187 \*------------------------------------------------------------------*/
 188 void CComputedString::render2DClip (IDriver& driver, CRenderStringBuffer &rdrBuffer,
 189                                         float x, float z,
 190                                         float xmin, float zmin, float xmax, float zmax)
 191 {
 192         if (Vertices.getNumVertices() == 0)
 193                 return;
 194         if(SelectSize==0)
 195                 return;
 196
 197         // get window size
 198         uint32  wndWidth, wndHeight;
 199         driver.getWindowSize(wndWidth, wndHeight);
 200         // scale to window size.
 201         x*= wndWidth;
 202         z*= wndHeight;
 203         xmin*= wndWidth;
 204         xmax*= wndWidth;
 205         zmin*= wndHeight;
 206         zmax*= wndHeight;
 207
 208         // Test String Bound against clip window
 209         // If entirely out skip
 210         if (((x+XMin) > xmax) || ((x+XMax) < xmin) ||
 211                 ((z+ZMin) > zmax) || ((z+ZMax) < zmin))
 212                 return;
 213
 214         // test if entirely in.
 215         bool    allIn;
 216         allIn=  ((x+XMin) >= xmin) && ((x+XMax) <= xmax) &&
 217                         ((z+ZMin) >= zmin) && ((z+ZMax) <= zmax);
 218
 219
 220         // How many quad to render?
 221         uint    nNumQuadSrc= Vertices.getNumVertices()/4;
 222         nNumQuadSrc= min(nNumQuadSrc, (uint)SelectSize);
 223
 224         // Enlarge dest Buffer if needed
 225         if( (rdrBuffer.NumQuads+nNumQuadSrc)*4 > rdrBuffer.Vertices.getNumVertices() )
 226         {
 227                 rdrBuffer.Vertices.setNumVertices( (rdrBuffer.NumQuads+nNumQuadSrc)*4 );
 228         }
 229
 230         // prepare copy.
 231         CVertexBuffer::TVertexColorType vtype = driver.getVertexColorFormat();
 232         Vertices.setVertexColorFormat (vtype);
 233         rdrBuffer.Vertices.setVertexColorFormat (vtype);
 234         CVertexBufferReadWrite srcvba;
 235         Vertices.lock (srcvba);
 236         CVertexBufferReadWrite dstvba;
 237         rdrBuffer.Vertices.lock (dstvba);
 238         sint    ofsSrcUV= Vertices.getTexCoordOff();
 239         sint    ofsDstUV= rdrBuffer.Vertices.getTexCoordOff();
 240         sint    ofsDstColor= rdrBuffer.Vertices.getColorOff();
 241         uint8   *srcPtr= (uint8*)srcvba.getVertexCoordPointer();
 242         uint8   *dstPtr= (uint8*)dstvba.getVertexCoordPointer(rdrBuffer.NumQuads*4);
 243         sint    srcSize= Vertices.getVertexSize();
 244         sint    dstSize= rdrBuffer.Vertices.getVertexSize();
 245
 246         // decal src for selection
 247         srcPtr+= SelectStart*4 * srcSize;
 248
 249         CRGBA   mCol = Color;
 250
 251         // **** clipping?
 252         if(allIn)
 253         {
 254                 // copy All vertices
 255                 uint numVerts= nNumQuadSrc*4;
 256                 uint count = 4;
 257                 uint lastIndex = 0;
 258                 for(uint i=0;i<numVerts;i++)
 259                 {
 260                         if(count==4)
 261                         {
 262                                 if(!LetterColors.empty())
 263                                 {
 264                                         if(LetterColors.getIndex(lastIndex)==i/4)
 265                                         {
 266                                                 mCol.modulateFromColor(Color, LetterColors.getColor(lastIndex));
 267
 268                                                 if(lastIndex+1<LetterColors.size())
 269                                                 {
 270                                                         lastIndex++;
 271                                                 }
 272                                         }
 273                                 }
 274
 275                                 count = 0;
 276                         }
 277
 278                         // copy and translate pos
 279                         CHECK_VBA_RANGE(srcvba, srcPtr, Vertices.getVertexSize());
 280                         CHECK_VBA_RANGE(dstvba, dstPtr, rdrBuffer.Vertices.getVertexSize())
 281                         ((CVector*)dstPtr)->x= x + ((CVector*)srcPtr)->x;
 282                         ((CVector*)dstPtr)->y= ((CVector*)srcPtr)->y;
 283                         ((CVector*)dstPtr)->z= z + ((CVector*)srcPtr)->z;
 284                         // uv
 285                         *((CUV*)(dstPtr+ofsDstUV))= *((CUV*)(srcPtr+ofsSrcUV));
 286                         // color
 287                         if (vtype == CVertexBuffer::TRGBA)
 288                                 *((CRGBA*)(dstPtr+ofsDstColor))= mCol;
 289                         else
 290                                 *((CBGRA*)(dstPtr+ofsDstColor))= mCol;
 291
 292                         // next
 293                         srcPtr+= srcSize;
 294                         dstPtr+= dstSize;
 295                         count++;
 296                 }
 297
 298                 // update the rdrBuffer
 299                 rdrBuffer.NumQuads+= nNumQuadSrc;
 300         }
 301         else
 302         {
 303                 uint    nNumQuadClipped= 0;
 304
 305                 // the real number of vertices to compute (with selection)
 306                 uint    numVerts= nNumQuadSrc*4;
 307
 308                 // clip into VerticesClipped
 309                 CVector *pIniPos0 = (CVector*)srcPtr;
 310                 CVector *pIniPos2 = (CVector*)(((uint8*)pIniPos0) + srcSize*2);
 311                 CVector *pClipPos0 = (CVector*)dstPtr;
 312                 CVector *pClipPos1 = (CVector*)(((uint8*)pClipPos0) + dstSize);
 313                 CVector *pClipPos2 = (CVector*)(((uint8*)pClipPos1) + dstSize);
 314                 CVector *pClipPos3 = (CVector*)(((uint8*)pClipPos2) + dstSize);
 315                 CUV *pClipUV0 = (CUV*)(dstPtr + ofsDstUV );
 316                 CUV *pClipUV1 = (CUV*)(((uint8*)pClipUV0) + dstSize);
 317                 CUV *pClipUV2 = (CUV*)(((uint8*)pClipUV1) + dstSize);
 318                 CUV *pClipUV3 = (CUV*)(((uint8*)pClipUV2) + dstSize);
 319                 float ratio;
 320
 321                 uint lastIndex = 0;
 322
 323                 for (uint32 i = 0; i < numVerts; i+=4)
 324                 {
 325                         if (((x+pIniPos0->x) > xmax) || ((x+pIniPos2->x) < xmin) ||
 326                                 ((z+pIniPos0->z) > zmax) || ((z+pIniPos2->z) < zmin))
 327                         {
 328                                 // Totally clipped do nothing
 329                         }
 330                         else
 331                         {
 332                                 if(!LetterColors.empty())
 333                                 {
 334                                         if(LetterColors.getIndex(lastIndex)==(i/4))
 335                                         {
 336                                                 mCol.modulateFromColor(Color, LetterColors.getColor(lastIndex));
 337
 338                                                 if(lastIndex+1<LetterColors.size())
 339                                                 {
 340                                                         lastIndex++;
 341                                                 }
 342                                         }
 343                                 }
 344
 345                                 // copy with no clip
 346                                 // v0
 347                                 *((CVector*) (dstPtr + dstSize*0))= *((CVector*) (srcPtr + srcSize*0));
 348                                 *((CUV*)         (dstPtr + dstSize*0 + ofsDstUV))= *((CUV*)(srcPtr + srcSize*0 + ofsSrcUV));
 349                                 if (vtype == CVertexBuffer::TRGBA)
 350                                         *((CRGBA*)       (dstPtr + dstSize*0 + ofsDstColor))= mCol;
 351                                 else
 352                                         *((CBGRA*)       (dstPtr + dstSize*0 + ofsDstColor))= mCol;
 353                                 // v1
 354                                 *((CVector*) (dstPtr + dstSize*1))= *((CVector*) (srcPtr + srcSize*1));
 355                                 *((CUV*)         (dstPtr + dstSize*1 + ofsDstUV))= *((CUV*)(srcPtr + srcSize*1 + ofsSrcUV));
 356                                 if (vtype == CVertexBuffer::TRGBA)
 357                                         *((CRGBA*)       (dstPtr + dstSize*1 + ofsDstColor))= mCol;
 358                                 else
 359                                         *((CBGRA*)       (dstPtr + dstSize*1 + ofsDstColor))= mCol;
 360                                 // v2
 361                                 *((CVector*) (dstPtr + dstSize*2))= *((CVector*) (srcPtr + srcSize*2));
 362                                 *((CUV*)         (dstPtr + dstSize*2 + ofsDstUV))= *((CUV*)(srcPtr + srcSize*2 + ofsSrcUV));
 363                                 if (vtype == CVertexBuffer::TRGBA)
 364                                         *((CRGBA*)       (dstPtr + dstSize*2 + ofsDstColor))= mCol;
 365                                 else
 366                                         *((CBGRA*)       (dstPtr + dstSize*2 + ofsDstColor))= mCol;
 367                                 // v3
 368                                 *((CVector*) (dstPtr + dstSize*3))= *((CVector*) (srcPtr + srcSize*3));
 369                                 *((CUV*)         (dstPtr + dstSize*3 + ofsDstUV))= *((CUV*)(srcPtr + srcSize*3 + ofsSrcUV));
 370                                 if (vtype == CVertexBuffer::TRGBA)
 371                                         *((CRGBA*)       (dstPtr + dstSize*3 + ofsDstColor))= mCol;
 372                                 else
 373                                         *((CBGRA*)       (dstPtr + dstSize*3 + ofsDstColor))= mCol;
 374
 375                                 // translate dest
 376                                 pClipPos0->x += x; pClipPos1->x += x; pClipPos2->x += x; pClipPos3->x += x;
 377                                 pClipPos0->z += z; pClipPos1->z += z; pClipPos2->z += z; pClipPos3->z += z;
 378                                 if ((pClipPos0->x >= xmin) && (pClipPos0->z >= zmin) && (pClipPos2->x <= xmax) && (pClipPos2->z <= zmax))
 379                                 {
 380                                         // Not clipped
 381                                 }
 382                                 else
 383                                 {
 384                                         // Partially clipped
 385
 386                                         if (pClipPos0->x < xmin)
 387                                         {
 388                                                 ratio = ((float)(xmin - pClipPos0->x))/((float)(pClipPos1->x - pClipPos0->x));
 389                                                 pClipPos3->x = pClipPos0->x = xmin;
 390                                                 pClipUV0->U += ratio*(pClipUV1->U - pClipUV0->U);
 391                                                 pClipUV3->U += ratio*(pClipUV2->U - pClipUV3->U);
 392                                         }
 393
 394                                         if (pClipPos0->z < zmin)
 395                                         {
 396                                                 ratio = ((float)(zmin - pClipPos0->z))/((float)(pClipPos3->z - pClipPos0->z));
 397                                                 pClipPos1->z = pClipPos0->z = zmin;
 398                                                 pClipUV0->V += ratio*(pClipUV3->V - pClipUV0->V);
 399                                                 pClipUV1->V += ratio*(pClipUV2->V - pClipUV1->V);
 400                                         }
 401
 402                                         if (pClipPos2->x > xmax)
 403                                         {
 404                                                 ratio = ((float)(xmax - pClipPos2->x))/((float)(pClipPos3->x - pClipPos2->x));
 405                                                 pClipPos2->x = pClipPos1->x = xmax;
 406                                                 pClipUV2->U += ratio*(pClipUV3->U - pClipUV2->U);
 407                                                 pClipUV1->U += ratio*(pClipUV0->U - pClipUV1->U);
 408                                         }
 409
 410                                         if (pClipPos2->z > zmax)
 411                                         {
 412                                                 ratio = ((float)(zmax - pClipPos2->z))/((float)(pClipPos1->z - pClipPos2->z));
 413                                                 pClipPos2->z = pClipPos3->z = zmax;
 414                                                 pClipUV2->V += ratio*(pClipUV1->V - pClipUV2->V);
 415                                                 pClipUV3->V += ratio*(pClipUV0->V - pClipUV3->V);
 416                                         }
 417                                 }
 418
 419                                 // next quad out
 420                                 ++nNumQuadClipped;
 421                                 pClipPos0 = (CVector*)(((uint8*)pClipPos0) + dstSize*4);
 422                                 pClipPos1 = (CVector*)(((uint8*)pClipPos0) + dstSize);
 423                                 pClipPos2 = (CVector*)(((uint8*)pClipPos1) + dstSize);
 424                                 pClipPos3 = (CVector*)(((uint8*)pClipPos2) + dstSize);
 425                                 pClipUV0 = (CUV*)( ((uint8*)pClipUV0) + dstSize*4 );
 426                                 pClipUV1 = (CUV*)(((uint8*)pClipUV0) + dstSize);
 427                                 pClipUV2 = (CUV*)(((uint8*)pClipUV1) + dstSize);
 428                                 pClipUV3 = (CUV*)(((uint8*)pClipUV2) + dstSize);
 429                                 dstPtr+=  4*dstSize;
 430                         }
 431                         // next quad in
 432                         pIniPos0 = (CVector*)(((uint8*)pIniPos0) + srcSize*4);
 433                         pIniPos2 = (CVector*)(((uint8*)pIniPos0) + srcSize*2);
 434                         srcPtr+=  4*srcSize;
 435                 }
 436
 437                 // update the rdrBuffer
 438                 rdrBuffer.NumQuads+= nNumQuadClipped;
 439         }
 440 }
 441
 442 /*------------------------------------------------------------------*\
 443                                                         render2DUnProjected()
 444 \*------------------------------------------------------------------*/
 445 void CComputedString::render2DUnProjected (IDriver& driver, CRenderStringBuffer &rdrBuffer, class NL3D::CFrustum &frustum,
 446         const NLMISC::CMatrix &scaleMatrix, float x, float z, float depth, float xmin, float zmin, float xmax, float zmax)
 447 {
 448         if (Vertices.getNumVertices() == 0)
 449                 return;
 450         if(SelectSize==0)
 451                 return;
 452
 453         // get window size
 454         uint32  wndWidth, wndHeight;
 455         driver.getWindowSize(wndWidth, wndHeight);
 456         // scale to window size.
 457         x*= wndWidth;
 458         z*= wndHeight;
 459         xmin*= wndWidth;
 460         xmax*= wndWidth;
 461         zmin*= wndHeight;
 462         zmax*= wndHeight;
 463
 464         // Test String Bound against clip window
 465         // If entirely out skip
 466         if (((x+XMin) > xmax) || ((x+XMax) < xmin) ||
 467                 ((z+ZMin) > zmax) || ((z+ZMax) < zmin))
 468                 return;
 469
 470         // test if entirely in.
 471         bool    allIn;
 472         allIn=  ((x+XMin) >= (xmin-0.001f)) && ((x+XMax) <= (xmax+0.001f)) &&
 473                         ((z+ZMin) >= (zmin-0.001f)) && ((z+ZMax) <= (zmax+0.001f));
 474
 475
 476         // How many quad to render?
 477         uint    nNumQuadSrc= Vertices.getNumVertices()/4;
 478         nNumQuadSrc= min(nNumQuadSrc, (uint)SelectSize);
 479
 480         // Enlarge dest Buffer if needed
 481         if( (rdrBuffer.NumQuads+nNumQuadSrc)*4 > rdrBuffer.Vertices.getNumVertices() )
 482         {
 483                 rdrBuffer.Vertices.setNumVertices( (rdrBuffer.NumQuads+nNumQuadSrc)*4 );
 484         }
 485
 486         // prepare copy.
 487         CVertexBuffer::TVertexColorType vtype = driver.getVertexColorFormat();
 488         Vertices.setVertexColorFormat (vtype);
 489         rdrBuffer.Vertices.setVertexColorFormat (vtype);
 490         CVertexBufferReadWrite srcvba;
 491         Vertices.lock (srcvba);
 492         CVertexBufferReadWrite dstvba;
 493         rdrBuffer.Vertices.lock (dstvba);
 494         sint    ofsSrcUV= Vertices.getTexCoordOff();
 495         sint    ofsDstUV= rdrBuffer.Vertices.getTexCoordOff();
 496         sint    ofsDstColor= rdrBuffer.Vertices.getColorOff();
 497         uint8   *srcPtr= (uint8*)srcvba.getVertexCoordPointer();
 498         uint8   *dstPtr= (uint8*)dstvba.getVertexCoordPointer(rdrBuffer.NumQuads*4);
 499         sint    srcSize= Vertices.getVertexSize();
 500         sint    dstSize= rdrBuffer.Vertices.getVertexSize();
 501
 502         // decal src for selection
 503         srcPtr+= SelectStart*4 * srcSize;
 504
 505         uint8   *dstPtrBackup = dstPtr;
 506
 507         // **** clipping?
 508         if(allIn)
 509         {
 510                 // copy All vertices
 511                 uint numVerts= nNumQuadSrc*4;
 512                 for(uint i=0;i<numVerts;i++)
 513                 {
 514                         // copy and translate pos
 515                         CHECK_VBA_RANGE(dstvba, dstPtr, Vertices.getVertexSize());
 516                         CHECK_VBA_RANGE(srcvba, srcPtr, rdrBuffer.Vertices.getVertexSize());
 517                         ((CVector*)dstPtr)->x= x + ((CVector*)srcPtr)->x;
 518                         ((CVector*)dstPtr)->z= z + ((CVector*)srcPtr)->z;
 519
 520                         // uv
 521                         *((CUV*)(dstPtr+ofsDstUV))= *((CUV*)(srcPtr+ofsSrcUV));
 522                         // color
 523                         if (vtype == CVertexBuffer::TRGBA)
 524                                 *((CRGBA*)(dstPtr+ofsDstColor))= Color;
 525                         else
 526                                 *((CBGRA*)(dstPtr+ofsDstColor))= Color;
 527
 528                         // next
 529                         srcPtr+= srcSize;
 530                         dstPtr+= dstSize;
 531                 }
 532
 533                 // update the rdrBuffer
 534                 rdrBuffer.NumQuads+= nNumQuadSrc;
 535         }
 536         else
 537         {
 538                 uint    nNumQuadClipped= 0;
 539
 540                 // the real number of vertices to compute (with selection)
 541                 uint    numVerts= nNumQuadSrc*4;
 542
 543                 // clip into VerticesClipped
 544                 CVector *pIniPos0 = (CVector*)srcPtr;
 545                 CVector *pIniPos2 = (CVector*)(((uint8*)pIniPos0) + srcSize*2);
 546                 CVector *pClipPos0 = (CVector*)dstPtr;
 547                 CVector *pClipPos1 = (CVector*)(((uint8*)pClipPos0) + dstSize);
 548                 CVector *pClipPos2 = (CVector*)(((uint8*)pClipPos1) + dstSize);
 549                 CVector *pClipPos3 = (CVector*)(((uint8*)pClipPos2) + dstSize);
 550                 CUV *pClipUV0 = (CUV*)(dstPtr + ofsDstUV );
 551                 CUV *pClipUV1 = (CUV*)(((uint8*)pClipUV0) + dstSize);
 552                 CUV *pClipUV2 = (CUV*)(((uint8*)pClipUV1) + dstSize);
 553                 CUV *pClipUV3 = (CUV*)(((uint8*)pClipUV2) + dstSize);
 554                 float ratio;
 555                 for (uint32 i = 0; i < numVerts; i+=4)
 556                 {
 557                         if (((x+pIniPos0->x) > xmax) || ((x+pIniPos2->x) < xmin) ||
 558                                 ((z+pIniPos0->z) > zmax) || ((z+pIniPos2->z) < zmin))
 559                         {
 560                                 // Totally clipped do nothing
 561                         }
 562                         else
 563                         {
 564                                 // copy with no clip
 565                                 // v0
 566                                 *((CVector*) (dstPtr + dstSize*0))= *((CVector*) (srcPtr + srcSize*0));
 567                                 *((CUV*)         (dstPtr + dstSize*0 + ofsDstUV))= *((CUV*)(srcPtr + srcSize*0 + ofsSrcUV));
 568                                 if (vtype == CVertexBuffer::TRGBA)
 569                                         *((CRGBA*)       (dstPtr + dstSize*0 + ofsDstColor))= Color;
 570                                 else
 571                                         *((CBGRA*)       (dstPtr + dstSize*0 + ofsDstColor))= Color;
 572                                 // v1
 573                                 *((CVector*) (dstPtr + dstSize*1))= *((CVector*) (srcPtr + srcSize*1));
 574                                 *((CUV*)         (dstPtr + dstSize*1 + ofsDstUV))= *((CUV*)(srcPtr + srcSize*1 + ofsSrcUV));
 575                                 if (vtype == CVertexBuffer::TRGBA)
 576                                         *((CRGBA*)       (dstPtr + dstSize*1 + ofsDstColor))= Color;
 577                                 else
 578                                         *((CBGRA*)       (dstPtr + dstSize*1 + ofsDstColor))= Color;
 579                                 // v2
 580                                 *((CVector*) (dstPtr + dstSize*2))= *((CVector*) (srcPtr + srcSize*2));
 581                                 *((CUV*)         (dstPtr + dstSize*2 + ofsDstUV))= *((CUV*)(srcPtr + srcSize*2 + ofsSrcUV));
 582                                 if (vtype == CVertexBuffer::TRGBA)
 583                                         *((CRGBA*)       (dstPtr + dstSize*2 + ofsDstColor))= Color;
 584                                 else
 585                                         *((CBGRA*)       (dstPtr + dstSize*2 + ofsDstColor))= Color;
 586                                 // v3
 587                                 *((CVector*) (dstPtr + dstSize*3))= *((CVector*) (srcPtr + srcSize*3));
 588                                 *((CUV*)         (dstPtr + dstSize*3 + ofsDstUV))= *((CUV*)(srcPtr + srcSize*3 + ofsSrcUV));
 589                                 if (vtype == CVertexBuffer::TRGBA)
 590                                         *((CRGBA*)       (dstPtr + dstSize*3 + ofsDstColor))= Color;
 591                                 else
 592                                         *((CBGRA*)       (dstPtr + dstSize*3 + ofsDstColor))= Color;
 593
 594
 595                                 // translate dest
 596                                 pClipPos0->x += x; pClipPos1->x += x; pClipPos2->x += x; pClipPos3->x += x;
 597                                 pClipPos0->z += z; pClipPos1->z += z; pClipPos2->z += z; pClipPos3->z += z;
 598                                 if ((pClipPos0->x >= xmin) && (pClipPos0->z >= zmin) && (pClipPos2->x <= xmax) && (pClipPos2->z <= zmax))
 599                                 {
 600                                         // Not clipped
 601                                 }
 602                                 else
 603                                 {
 604                                         // Partially clipped
 605
 606                                         if (pClipPos0->x < xmin)
 607                                         {
 608                                                 ratio = ((float)(xmin - pClipPos0->x))/((float)(pClipPos1->x - pClipPos0->x));
 609                                                 pClipPos3->x = pClipPos0->x = xmin;
 610                                                 pClipUV0->U += ratio*(pClipUV1->U - pClipUV0->U);
 611                                                 pClipUV3->U += ratio*(pClipUV2->U - pClipUV3->U);
 612                                         }
 613
 614                                         if (pClipPos0->z < zmin)
 615                                         {
 616                                                 ratio = ((float)(zmin - pClipPos0->z))/((float)(pClipPos3->z - pClipPos0->z));
 617                                                 pClipPos1->z = pClipPos0->z = zmin;
 618                                                 pClipUV0->V += ratio*(pClipUV3->V - pClipUV0->V);
 619                                                 pClipUV1->V += ratio*(pClipUV2->V - pClipUV1->V);
 620                                         }
 621
 622                                         if (pClipPos2->x > xmax)
 623                                         {
 624                                                 ratio = ((float)(xmax - pClipPos2->x))/((float)(pClipPos3->x - pClipPos2->x));
 625                                                 pClipPos2->x = pClipPos1->x = xmax;
 626                                                 pClipUV2->U += ratio*(pClipUV3->U - pClipUV2->U);
 627                                                 pClipUV1->U += ratio*(pClipUV0->U - pClipUV1->U);
 628                                         }
 629
 630                                         if (pClipPos2->z > zmax)
 631                                         {
 632                                                 ratio = ((float)(zmax - pClipPos2->z))/((float)(pClipPos1->z - pClipPos2->z));
 633                                                 pClipPos2->z = pClipPos3->z = zmax;
 634                                                 pClipUV2->V += ratio*(pClipUV1->V - pClipUV2->V);
 635                                                 pClipUV3->V += ratio*(pClipUV0->V - pClipUV3->V);
 636                                         }
 637                                 }
 638
 639                                 // next quad out
 640                                 ++nNumQuadClipped;
 641                                 pClipPos0 = (CVector*)(((uint8*)pClipPos0) + dstSize*4);
 642                                 pClipPos1 = (CVector*)(((uint8*)pClipPos0) + dstSize);
 643                                 pClipPos2 = (CVector*)(((uint8*)pClipPos1) + dstSize);
 644                                 pClipPos3 = (CVector*)(((uint8*)pClipPos2) + dstSize);
 645                                 pClipUV0 = (CUV*)( ((uint8*)pClipUV0) + dstSize*4 );
 646                                 pClipUV1 = (CUV*)(((uint8*)pClipUV0) + dstSize);
 647                                 pClipUV2 = (CUV*)(((uint8*)pClipUV1) + dstSize);
 648                                 pClipUV3 = (CUV*)(((uint8*)pClipUV2) + dstSize);
 649                                 dstPtr+=  4*dstSize;
 650                         }
 651                         // next quad in
 652                         pIniPos0 = (CVector*)(((uint8*)pIniPos0) + srcSize*4);
 653                         pIniPos2 = (CVector*)(((uint8*)pIniPos0) + srcSize*2);
 654                         srcPtr+=  4*srcSize;
 655                 }
 656
 657                 // update the rdrBuffer
 658                 rdrBuffer.NumQuads+= nNumQuadClipped;
 659         }
 660
 661         const float OOW = 1.f / (float)wndWidth;
 662         const float OOH = 1.f / (float)wndHeight;
 663
 664         while (dstPtrBackup != dstPtr)
 665         {
 666                 // preset unprojection
 667                 CVector tmp;
 668                 tmp.x = ((CVector*)dstPtrBackup)->x * OOW;
 669                 tmp.y = ((CVector*)dstPtrBackup)->z * OOH;
 670                 tmp.z = depth;
 671                 // mul by user scale matrix
 672                 tmp= scaleMatrix * tmp;
 673                 // Unproject it
 674                 *((CVector*)dstPtrBackup) = frustum.unProjectZ(tmp);
 675                 dstPtrBackup += dstSize;
 676         }
 677
 678 }
 679
 680 // ***************************************************************************
 681 CRenderStringBuffer::CRenderStringBuffer()
 682 {
 683         // Use color per vertex
 684         Vertices.setVertexFormat (CVertexBuffer::PositionFlag | CVertexBuffer::TexCoord0Flag | CVertexBuffer::PrimaryColorFlag);
 685         Vertices.setPreferredMemory (CVertexBuffer::RAMVolatile, true);
 686         Vertices.setName("CRenderStringBuffer");
 687         NumQuads= 0;
 688 }
 689
 690
 691 // ***************************************************************************
 692 CRenderStringBuffer::~CRenderStringBuffer()
 693 {
 694 }
 695
 696
 697 // ***************************************************************************
 698 void    CRenderStringBuffer::flush(IDriver& driver, CMaterial *fontMat)
 699 {
 700         if(NumQuads==0)
 701                 return;
 702
 703         // get window size
 704         uint32  wndWidth, wndHeight;
 705         driver.getWindowSize(wndWidth, wndHeight);
 706
 707         // **** setup driver context
 708         driver.setFrustum(0, (float)wndWidth, 0, (float)wndHeight, -1, 1, false);  // resX/resY
 709
 710         // view matrix and model matrix <-> identity
 711         driver.setupViewMatrix (CMatrix::Identity);
 712         driver.setupModelMatrix (CMatrix::Identity);
 713
 714         // setup material
 715         fontMat->setZFunc (CMaterial::always);
 716         fontMat->setZWrite (false);
 717
 718         // setup vertices clipped
 719         driver.activeVertexBuffer (Vertices);
 720
 721         // *** rendering
 722         driver.renderRawQuads (*fontMat, 0, NumQuads );
 723
 724         // *** reset
 725         NumQuads= 0;
 726 }
 727
 728
 729 // ***************************************************************************
 730 void    CRenderStringBuffer::flushUnProjected(IDriver& driver, CMaterial *fontMat, bool zwrite)
 731 {
 732         if(NumQuads==0)
 733                 return;
 734
 735         // setup material
 736         fontMat->setZFunc (CMaterial::lessequal);
 737         fontMat->setZWrite (zwrite);
 738
 739         // setup vertices clipped
 740         driver.activeVertexBuffer (Vertices);
 741
 742         // *** rendering
 743         driver.renderRawQuads (*fontMat, 0, NumQuads );
 744
 745         // *** reset
 746         NumQuads= 0;
 747 }
 748
 749
 750 } // NL3D