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