Home | History | Annotate | Download | only in d3d 
      1 //
      2 // Copyright (c) 2002-2012 The ANGLE Project Authors. All rights reserved.
      3 // Use of this source code is governed by a BSD-style license that can be
      4 // found in the LICENSE file.
      5 //
      6 
      7 // IndexBuffer.cpp: Defines the abstract IndexBuffer class and IndexBufferInterface
      8 // class with derivations, classes that perform graphics API agnostic index buffer operations.
      9 
     10 #include "libGLESv2/renderer/d3d/IndexBuffer.h"
     11 #include "libGLESv2/renderer/Renderer.h"
     12 
     13 namespace rx
     14 {
     15 
     16 unsigned int IndexBuffer::mNextSerial = 1;
     17 
     18 IndexBuffer::IndexBuffer()
     19 {
     20     updateSerial();
     21 }
     22 
     23 IndexBuffer::~IndexBuffer()
     24 {
     25 }
     26 
     27 unsigned int IndexBuffer::getSerial() const
     28 {
     29     return mSerial;
     30 }
     31 
     32 void IndexBuffer::updateSerial()
     33 {
     34     mSerial = mNextSerial++;
     35 }
     36 
     37 
     38 IndexBufferInterface::IndexBufferInterface(Renderer *renderer, bool dynamic) : mRenderer(renderer)
     39 {
     40     mIndexBuffer = renderer->createIndexBuffer();
     41 
     42     mDynamic = dynamic;
     43     mWritePosition = 0;
     44 }
     45 
     46 IndexBufferInterface::~IndexBufferInterface()
     47 {
     48     if (mIndexBuffer)
     49     {
     50         delete mIndexBuffer;
     51     }
     52 }
     53 
     54 GLenum IndexBufferInterface::getIndexType() const
     55 {
     56     return mIndexBuffer->getIndexType();
     57 }
     58 
     59 unsigned int IndexBufferInterface::getBufferSize() const
     60 {
     61     return mIndexBuffer->getBufferSize();
     62 }
     63 
     64 unsigned int IndexBufferInterface::getSerial() const
     65 {
     66     return mIndexBuffer->getSerial();
     67 }
     68 
     69 gl::Error IndexBufferInterface::mapBuffer(unsigned int size, void** outMappedMemory, unsigned int *streamOffset)
     70 {
     71     // Protect against integer overflow
     72     if (mWritePosition + size < mWritePosition)
     73     {
     74         return gl::Error(GL_OUT_OF_MEMORY, "Mapping of internal index buffer would cause an integer overflow.");
     75     }
     76 
     77     gl::Error error = mIndexBuffer->mapBuffer(mWritePosition, size, outMappedMemory);
     78     if (error.isError())
     79     {
     80         if (outMappedMemory)
     81         {
     82             *outMappedMemory = NULL;
     83         }
     84         return error;
     85     }
     86 
     87     if (streamOffset)
     88     {
     89         *streamOffset = mWritePosition;
     90     }
     91 
     92     mWritePosition += size;
     93     return gl::Error(GL_NO_ERROR);
     94 }
     95 
     96 gl::Error IndexBufferInterface::unmapBuffer()
     97 {
     98     return mIndexBuffer->unmapBuffer();
     99 }
    100 
    101 IndexBuffer * IndexBufferInterface::getIndexBuffer() const
    102 {
    103     return mIndexBuffer;
    104 }
    105 
    106 unsigned int IndexBufferInterface::getWritePosition() const
    107 {
    108     return mWritePosition;
    109 }
    110 
    111 void IndexBufferInterface::setWritePosition(unsigned int writePosition)
    112 {
    113     mWritePosition = writePosition;
    114 }
    115 
    116 gl::Error IndexBufferInterface::discard()
    117 {
    118     return mIndexBuffer->discard();
    119 }
    120 
    121 gl::Error IndexBufferInterface::setBufferSize(unsigned int bufferSize, GLenum indexType)
    122 {
    123     if (mIndexBuffer->getBufferSize() == 0)
    124     {
    125         return mIndexBuffer->initialize(bufferSize, indexType, mDynamic);
    126     }
    127     else
    128     {
    129         return mIndexBuffer->setSize(bufferSize, indexType);
    130     }
    131 }
    132 
    133 StreamingIndexBufferInterface::StreamingIndexBufferInterface(Renderer *renderer) : IndexBufferInterface(renderer, true)
    134 {
    135 }
    136 
    137 StreamingIndexBufferInterface::~StreamingIndexBufferInterface()
    138 {
    139 }
    140 
    141 gl::Error StreamingIndexBufferInterface::reserveBufferSpace(unsigned int size, GLenum indexType)
    142 {
    143     unsigned int curBufferSize = getBufferSize();
    144     unsigned int writePos = getWritePosition();
    145     if (size > curBufferSize)
    146     {
    147         gl::Error error = setBufferSize(std::max(size, 2 * curBufferSize), indexType);
    148         if (error.isError())
    149         {
    150             return error;
    151         }
    152         setWritePosition(0);
    153     }
    154     else if (writePos + size > curBufferSize || writePos + size < writePos)
    155     {
    156         gl::Error error = discard();
    157         if (error.isError())
    158         {
    159             return error;
    160         }
    161         setWritePosition(0);
    162     }
    163 
    164     return gl::Error(GL_NO_ERROR);
    165 }
    166 
    167 
    168 StaticIndexBufferInterface::StaticIndexBufferInterface(Renderer *renderer) : IndexBufferInterface(renderer, false)
    169 {
    170 }
    171 
    172 StaticIndexBufferInterface::~StaticIndexBufferInterface()
    173 {
    174 }
    175 
    176 gl::Error StaticIndexBufferInterface::reserveBufferSpace(unsigned int size, GLenum indexType)
    177 {
    178     unsigned int curSize = getBufferSize();
    179     if (curSize == 0)
    180     {
    181         return setBufferSize(size, indexType);
    182     }
    183     else if (curSize >= size && indexType == getIndexType())
    184     {
    185         return gl::Error(GL_NO_ERROR);
    186     }
    187     else
    188     {
    189         UNREACHABLE();
    190         return gl::Error(GL_INVALID_OPERATION, "Internal static index buffers can't be resized");
    191     }
    192 }
    193 
    194 IndexRangeCache *StaticIndexBufferInterface::getIndexRangeCache()
    195 {
    196     return &mIndexRangeCache;
    197 }
    198 
    199 }
    200