nel/src/3d/driver/direct3d/driver_direct3d_index.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) 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 "stddirect3d.h"
  21
  22 #include "nel/3d/index_buffer.h"
  23 #include "nel/3d/light.h"
  24 #include "nel/misc/rect.h"
  25 #include "nel/3d/viewport.h"
  26 #include "nel/3d/scissor.h"
  27 #include "nel/3d/u_driver.h"
  28
  29 #include "driver_direct3d.h"
  30
  31 #ifdef DEBUG_NEW
  32 #define new DEBUG_NEW
  33 #endif
  34
  35 using namespace std;
  36 using namespace NLMISC;
  37
  38 namespace NL3D
  39 {
  40
  41 // ***************************************************************************
  42
  43 CIBDrvInfosD3D::CIBDrvInfosD3D(CDriverD3D *drv, ItIBDrvInfoPtrList it, CIndexBuffer *ib) : IIBDrvInfos(drv, it, ib)
  44 {
  45         H_AUTO_D3D(CIBDrvInfosD3D_CIBDrvInfosD3D)
  46         Driver = drv;
  47         IndexBuffer = NULL;
  48         VolatileIndexBuffer = NULL;
  49
  50 }
  51
  52 // ***************************************************************************
  53
  54 uint indexCount=0;
  55
  56 CIBDrvInfosD3D::~CIBDrvInfosD3D()
  57 {
  58         H_AUTO_D3D(CIBDrvInfosD3D_CIBDrvInfosD3DDtor);
  59         // Restore non resident memory
  60         if (IndexBufferPtr)
  61         {
  62                 IndexBufferPtr->setLocation(CIndexBuffer::NotResident);
  63                 IndexBufferPtr= NULL;
  64         }
  65
  66         // release index buffer
  67         if (IndexBuffer && !Volatile)
  68         {
  69                 if (Driver)
  70                 {
  71                         if (Driver->_IndexBufferCache.IndexBuffer == IndexBuffer)
  72                         {
  73                                 Driver->_IndexBufferCache.IndexBuffer = NULL;
  74                                 Driver->touchRenderVariable(&Driver->_IndexBufferCache);
  75                         }
  76                 }
  77                 indexCount--;
  78                 IndexBuffer->Release();
  79         }
  80 }
  81
  82 // ***************************************************************************
  83
  84 void *CIBDrvInfosD3D::lock (uint first, uint last, bool readOnly)
  85 {
  86         H_AUTO_D3D(CIBDrvInfosD3D_lock);
  87         nlassert (first != last);
  88         CDriverD3D *driver = static_cast<CDriverD3D*>(_Driver);
  89
  90         if (driver->getMaxVertexIndex() <= 0xffff && getFormat() != CIndexBuffer::Indices16)
  91         {
  92                 nlassert(getFormat() == CIndexBuffer::Indices32);
  93                 // 32-bit index not supported -> uses RAM mirror
  94                 nlassert(!RamVersion.empty());
  95                 return &RamVersion[0];
  96         }
  97         else
  98         {
  99                 if (Volatile)
 100                 {
 101                         // Lock the good buffer
 102                         CVolatileIndexBuffer **buffer = NULL;
 103                         if (getFormat() == CIndexBuffer::Indices16)
 104                         {
 105                                 buffer = VolatileRAM ? (&driver->_VolatileIndexBuffer16RAM[driver->_CurrentRenderPass&1]):(&driver->_VolatileIndexBuffer16AGP[driver->_CurrentRenderPass&1]);
 106                         }
 107                         else if (getFormat() == CIndexBuffer::Indices32)
 108                         {
 109                                 buffer = VolatileRAM ? (&driver->_VolatileIndexBuffer32RAM[driver->_CurrentRenderPass&1]):(&driver->_VolatileIndexBuffer32AGP[driver->_CurrentRenderPass&1]);
 110                         }
 111                         else
 112                         {
 113                                 nlassert(0);
 114                         }
 115                         void *ptr = (*buffer)->lock ((last-first)*getIndexNumBytes(), Offset);
 116                         if (!ptr)
 117                         {
 118                                 // buffer full, swap them
 119                                 CVolatileIndexBuffer **bufferOther;
 120                                 if (getFormat() == CIndexBuffer::Indices16)
 121                                 {
 122                                         bufferOther = VolatileRAM ? (&driver->_VolatileIndexBuffer16RAM[(driver->_CurrentRenderPass + 1) &1]):(&driver->_VolatileIndexBuffer16AGP[(driver->_CurrentRenderPass + 1 ) &1]);
 123                                 }
 124                                 else
 125                                 {
 126                                         bufferOther = VolatileRAM ? (&driver->_VolatileIndexBuffer32RAM[(driver->_CurrentRenderPass + 1) &1]):(&driver->_VolatileIndexBuffer32AGP[(driver->_CurrentRenderPass + 1 ) &1]);
 127                                 }
 128                                 std::swap(*buffer, *bufferOther);
 129                                 (*buffer)->reset();
 130                                 ptr = (*buffer)->lock ((last-first)*getIndexNumBytes(), Offset);
 131                                 nlassert(ptr);
 132                         }
 133                         nlassert(!VolatileIndexBuffer);
 134                         VolatileIndexBuffer = *buffer;
 135                         IndexBuffer = (*buffer)->IndexBuffer;
 136                         ptr = (uint8 *) ptr - first * getIndexNumBytes();
 137
 138                         // Current lock time
 139                         VolatileLockTime = driver->_CurrentRenderPass;
 140
 141                         // Touch the index buffer
 142                         driver->touchRenderVariable (&driver->_IndexBufferCache);
 143
 144                         return ptr;
 145                 }
 146                 else
 147                 {
 148                         nlassert (IndexBuffer);
 149                         // Lock Profile?
 150                         TTicks  beforeLock = 0;
 151                         if(driver->_IBProfiling /*&& Hardware*/)
 152                         {
 153                                 beforeLock= CTime::getPerformanceTime();
 154                         }
 155                         void *pbData;
 156                         HRESULT result = IndexBuffer->Lock ( first*getIndexNumBytes(), (last-first)*getIndexNumBytes(), &pbData, readOnly?D3DLOCK_READONLY:0);
 157                         nlassert(result == D3D_OK);
 158                         // Lock Profile?
 159                         if(driver->_IBProfiling /*&& Hardware*/)
 160                         {
 161                                 TTicks  afterLock;
 162                                 afterLock= CTime::getPerformanceTime();
 163                                 driver->appendIBLockProfile(afterLock-beforeLock, IndexBufferPtr);
 164                         }
 165                         if (result == D3D_OK) return pbData;
 166                 }
 167         }
 168         return NULL;
 169 }
 170
 171 // ***************************************************************************
 172
 173 void    CIBDrvInfosD3D::unlock (uint /* first */, uint /* last */)
 174 {
 175         H_AUTO_D3D(CIBDrvInfosD3D_unlock)
 176         CDriverD3D *driver = static_cast<CDriverD3D*>(_Driver);
 177         if (driver->getMaxVertexIndex() > 0xffff || getFormat() == CIndexBuffer::Indices16)
 178         {
 179                 if (Volatile)
 180                 {
 181                         nlassert(VolatileIndexBuffer);
 182                         VolatileIndexBuffer->unlock ();
 183                         VolatileIndexBuffer = NULL;
 184                 }
 185                 else
 186                 {
 187                         if (IndexBuffer) IndexBuffer->Unlock ();
 188                 }
 189         }
 190 }
 191
 192 // ***************************************************************************
 193
 194 DWORD RemapIndexBufferUsage[CIndexBuffer::LocationCount]=
 195 {
 196         D3DUSAGE_DYNAMIC,                                               // RAMResident
 197         D3DUSAGE_DYNAMIC|D3DUSAGE_WRITEONLY,    // AGPResident
 198         D3DUSAGE_WRITEONLY,                                             // VRAMResident
 199         0,                                                                              // Not used
 200 };
 201
 202 // ***************************************************************************
 203
 204 D3DPOOL RemapIndexBufferPool[CIndexBuffer::LocationCount]=
 205 {
 206         D3DPOOL_SYSTEMMEM,      // RAMResident
 207         D3DPOOL_DEFAULT,        // AGPResident
 208         D3DPOOL_DEFAULT,        // VRAMResident
 209         D3DPOOL_DEFAULT,        // Not used
 210 };
 211
 212 // ***************************************************************************
 213
 214 bool CDriverD3D::activeIndexBuffer(CIndexBuffer& IB)
 215 {
 216         H_AUTO_D3D(CDriverD3D_activeIndexBuffer)
 217
 218         // Must not be locked
 219         nlassert (!IB.isLocked());
 220
 221         // Must not be empty
 222         if (IB.capacity() == 0)
 223                 return false;
 224
 225         const bool touched = (IB.getTouchFlags() & (CIndexBuffer::TouchedReserve|CIndexBuffer::TouchedIndexFormat)) != 0;
 226         CIBDrvInfosD3D *info = static_cast<CIBDrvInfosD3D*>(static_cast<IIBDrvInfos*>(IB.DrvInfos));
 227
 228         // Volatile buffers must be filled at each pass (exception if emulated)
 229         if (_MaxVertexIndex > 0xffff)
 230         {
 231                 nlassertex (!info || !info->Volatile || IB.getKeepLocalMemory() || (info->VolatileLockTime == _CurrentRenderPass), ("Volatile buffers must be filled at each pass"));
 232         }
 233
 234         // Build the driver info
 235         if (touched)
 236         {
 237                 // Delete previous index buffer info
 238                 if (IB.DrvInfos)
 239                 {
 240                         delete IB.DrvInfos;
 241                         nlassert (IB.DrvInfos == NULL);
 242                 }
 243
 244                 // Rebuild it
 245                 _IBDrvInfos.push_front (NULL);
 246                 ItIBDrvInfoPtrList ite = _IBDrvInfos.begin();
 247                 info = new CIBDrvInfosD3D(this, ite, &IB);
 248                 *ite = info;
 249                 // Create the index buffer
 250                 const uint size = (uint)IB.capacity();
 251                 uint preferredMemory = 0;
 252                 if (_DisableHardwareIndexArrayAGP)
 253                 {
 254                         preferredMemory = CIndexBuffer::RAMResident;
 255                         info->Volatile = false;
 256                 }
 257                 else
 258                 {
 259                         switch (IB.getPreferredMemory ())
 260                         {
 261                         case CIndexBuffer::RAMPreferred:
 262                                 preferredMemory = CIndexBuffer::RAMResident;
 263                                 info->Volatile = false;
 264                                 break;
 265                         case CIndexBuffer::AGPPreferred:
 266                                 preferredMemory = CIndexBuffer::AGPResident;
 267                                 info->Volatile = false;
 268                                 break;
 269                         case CIndexBuffer::StaticPreferred:
 270                                 if (getStaticMemoryToVRAM())
 271                                         preferredMemory = CIndexBuffer::VRAMResident;
 272                                 else
 273                                         preferredMemory = CIndexBuffer::AGPResident;
 274                                 info->Volatile = false;
 275                                 break;
 276                         case CIndexBuffer::RAMVolatile:
 277                                 preferredMemory = CIndexBuffer::RAMResident;
 278                                 info->Volatile = true;
 279                                 break;
 280                         case CIndexBuffer::AGPVolatile:
 281                                 preferredMemory = CIndexBuffer::AGPResident;
 282                                 info->Volatile = true;
 283                                 break;
 284                         }
 285                 }
 286
 287                 // if 32 bit index not supported, the index buffer will be reformated so return a RAM mirror
 288                 // Real index buffer will be allocated if indices are not modified (e.g a single lock is used to update the content)
 289                 if (_MaxVertexIndex <= 0xffff && IB.getFormat() == CIndexBuffer::Indices32)
 290                 {
 291                         info->RamVersion.resize(size);
 292                         info->IndexBuffer = NULL;
 293                 }
 294                 else
 295                 {
 296                         // Volatile index buffer
 297                         if (info->Volatile)
 298                         {
 299                                 nlassert (info->IndexBuffer == NULL);
 300                                 info->VolatileRAM = preferredMemory == CIndexBuffer::RAMResident;
 301                         }
 302                         else
 303                         {
 304                                 // Offset will be 0
 305                                 info->Offset = 0;
 306                                 bool success = false;
 307                                 do
 308                                 {
 309                                         success = _DeviceInterface->CreateIndexBuffer(size*IB.getIndexNumBytes(),
 310                                                 RemapIndexBufferUsage[preferredMemory],
 311                                                 IB.getFormat() == CIndexBuffer::Indices32 ? D3DFMT_INDEX32 : D3DFMT_INDEX16,
 312                                                 RemapIndexBufferPool[preferredMemory],
 313                                                 &(info->IndexBuffer), NULL) == D3D_OK;
 314
 315                                         if (success)
 316                                                 break;
 317                                 }
 318                                 while (preferredMemory--);
 319                                 if (!success)
 320                                         return false;
 321                                 ++indexCount;
 322                         }
 323                         // Force the vertex buffer update
 324                         touchRenderVariable (&_IndexBufferCache);
 325                 }
 326                 // Release the local index buffer
 327                 IB.DrvInfos = info;
 328                 IB.setLocation((CIndexBuffer::TLocation)preferredMemory);
 329         }
 330
 331         // Set the current index buffer
 332         nlassert (info);
 333         _LastIndexBufferInfo = info;
 334
 335         // Fill the buffer if in local memory
 336         IB.fillBuffer ();
 337
 338         _CurrIndexBufferFormat = IB.getFormat();
 339
 340         // Set the index buffer
 341         if (_MaxVertexIndex > 0xffff || IB.getFormat() == CIndexBuffer::Indices16)
 342         {
 343                 setIndexBuffer (info->IndexBuffer, info->Offset);
 344         }
 345         return true;
 346 }
 347
 348 // ***************************************************************************
 349
 350 bool CDriverD3D::supportIndexBufferHard() const
 351 {
 352         H_AUTO_D3D(CDriverD3D_supportIndexBufferHard);
 353         return !_DisableHardwareIndexArrayAGP;
 354 }
 355
 356 // ***************************************************************************
 357
 358 void CDriverD3D::disableHardwareIndexArrayAGP()
 359 {
 360         H_AUTO_D3D(CDriverD3D_disableHardwareIndexArrayAGP)
 361         _DisableHardwareIndexArrayAGP = true;
 362 }
 363
 364 // ***************************************************************************
 365 // CVolatileIndexBuffer
 366 // ***************************************************************************
 367
 368 CVolatileIndexBuffer::CVolatileIndexBuffer()
 369 {
 370         H_AUTO_D3D(CVolatileIndexBuffer_CVolatileIndexBuffer);
 371         IndexBuffer = NULL;
 372         Locked = false;
 373 }
 374
 375 // ***************************************************************************
 376
 377 CVolatileIndexBuffer::~CVolatileIndexBuffer()
 378 {
 379         H_AUTO_D3D(CVolatileIndexBuffer_CVolatileIndexBufferDtor);
 380         release ();
 381 }
 382
 383 // ***************************************************************************
 384
 385 void CVolatileIndexBuffer::release ()
 386 {
 387         H_AUTO_D3D(CVolatileIndexBuffer_release);
 388         if (IndexBuffer)
 389                 IndexBuffer->Release();
 390         IndexBuffer = NULL;
 391 }
 392
 393 // ***************************************************************************
 394 void CVolatileIndexBuffer::init (CIndexBuffer::TLocation location, uint sizeInBytes, uint maxSize, CDriverD3D *driver, CIndexBuffer::TFormat format)
 395 {
 396         H_AUTO_D3D(CVolatileIndexBuffer_init);
 397         release();
 398         if (maxSize < sizeInBytes) maxSize = sizeInBytes;
 399
 400         // Init the buffer
 401         Location = location;
 402         Size = sizeInBytes;
 403         MaxSize = maxSize;
 404         Driver = driver;
 405
 406         nlassert(format == CIndexBuffer::Indices16 || format == CIndexBuffer::Indices32);
 407         if (format == CIndexBuffer::Indices32)
 408         {
 409                 // device must support 32 bits indices
 410                 nlassert(driver->_MaxVertexIndex > 0xffff);
 411         }
 412         D3DFORMAT d3dFormat = format == CIndexBuffer::Indices16 ? D3DFMT_INDEX16 : D3DFMT_INDEX32;
 413
 414         // Allocate the vertex buffer
 415         if (Driver->_DeviceInterface->CreateIndexBuffer(sizeInBytes, RemapIndexBufferUsage[location],
 416                 d3dFormat, RemapIndexBufferPool[location], &IndexBuffer, NULL) != D3D_OK)
 417         {
 418                 // Location in RAM must not failed
 419                 nlassert (location != CIndexBuffer::RAMResident);
 420
 421                 // Allocate in RAM
 422                 nlverify (Driver->_DeviceInterface->CreateIndexBuffer(sizeInBytes, RemapIndexBufferUsage[CIndexBuffer::RAMResident],
 423                                  d3dFormat, RemapIndexBufferPool[CIndexBuffer::RAMResident], &IndexBuffer, NULL) != D3D_OK);
 424                 Location = CIndexBuffer::RAMResident;
 425         }
 426         Format = format;
 427 }
 428
 429
 430
 431
 432 // ***************************************************************************
 433 void *CVolatileIndexBuffer::lock (uint size, uint &offset)
 434 {
 435         nlassertex(!Locked, ("Volatile buffer usage should follow an atomic lock/unlock/render sequence"));
 436         H_AUTO_D3D(CVolatileIndexBuffer_lock);
 437         /* If not enough room to allocate this buffer, resise the buffer to Size+Size/2 but do not reset CurrentIndex
 438          * to be sure the buffer will be large enough next pass. */
 439
 440         // Enough room for this index ?
 441         if (CurrentIndex+size > Size)
 442         {
 443                 if (CurrentIndex+size > MaxSize && CurrentIndex != 0)
 444                 {
 445                         return NULL;  // max size exceeded -> can reallocate only if we are at start of block
 446                 }
 447                 // No, reallocate
 448                 init (Location, std::max (std::min(Size+Size/2, MaxSize),  CurrentIndex+size), MaxSize, Driver, Format);
 449         }
 450         // Lock Profile?
 451         TTicks  beforeLock = 0;
 452         if(Driver->_IBProfiling /*&& Hardware*/)
 453         {
 454                 beforeLock= CTime::getPerformanceTime();
 455         }
 456         // Lock the buffer, noblocking lock here if not the first allocation since a reset
 457         VOID *pbData;
 458         if (CurrentIndex==0)
 459         {
 460                 nlverify (IndexBuffer->Lock (0, size, &pbData, 0) == D3D_OK);
 461         }
 462         else
 463         {
 464                 nlverify (IndexBuffer->Lock (CurrentIndex, size, &pbData, D3DLOCK_NOOVERWRITE) == D3D_OK);
 465         }
 466         if(Driver->_IBProfiling /*&& Hardware*/)
 467         {
 468                 TTicks  afterLock;
 469                 afterLock= CTime::getPerformanceTime();
 470                 Driver->_VolatileIBLockTime += afterLock - beforeLock;
 471         }
 472
 473         // Old buffer position
 474         offset = CurrentIndex / (Format == CIndexBuffer::Indices32 ? sizeof(uint32) : sizeof(uint16));
 475
 476         // New buffer position
 477         CurrentIndex += size;
 478         Locked = true;
 479         return pbData;
 480 }
 481
 482 // ***************************************************************************
 483
 484 void CVolatileIndexBuffer::unlock ()
 485 {
 486         H_AUTO_D3D(CVolatileIndexBuffer_unlock);
 487         nlassertex(Locked, ("Volatile buffer usage should follow an atomic lock/unlock/render sequence"));
 488         nlverify (IndexBuffer->Unlock () == D3D_OK);
 489         Locked = false;
 490 }
 491
 492 // ***************************************************************************
 493 void CVolatileIndexBuffer::reset ()
 494 {
 495         H_AUTO_D3D(CVolatileIndexBuffer_reset);
 496         CurrentIndex = 0;
 497 }
 498
 499 // ***************************************************************************
 500 bool CDriverD3D::buildQuadIndexBuffer()
 501 {
 502         // this code will becomes useless when 16 bits buffer are really supported
 503         nlassert(!_QuadIB);
 504         uint numQuads = std::min(MAX_NUM_QUADS, (uint) (_MaxPrimitiveCount * 2)); // 2 primitives for each quads
 505         HRESULT r = _DeviceInterface->CreateIndexBuffer(sizeof(uint16) * 6 * numQuads, D3DUSAGE_DYNAMIC, D3DFMT_INDEX16, D3DPOOL_SYSTEMMEM, &_QuadIB, NULL);
 506         if (r != D3D_OK) return false;
 507         void *datas;
 508         r = _QuadIB->Lock(0, sizeof(uint16) * 6 * numQuads, &datas, 0);
 509         if (r != D3D_OK) return false;
 510         fillQuadIndexes((uint16 *) datas, 0, 6 * numQuads);
 511         _QuadIB->Unlock();
 512         return true;
 513 }
 514
 515
 516 // ***************************************************************************
 517
 518 } // NL3D