Fixed plural in array variable names.

Engine/Graphics/AnimatedModel.cpp

@@ -387,7 +387,7 @@ void AnimatedModel::SetModel(Model* model, bool createBones)
         geometryBoneMappings_.Push(geometryBoneMappings[i]);
     
     // Copy morphs
-    morphvertexBuffer_.Clear();
+    morphVertexBuffers_.Clear();
     morphs_.Clear();
     const Vector<ModelMorph>& morphs = model->GetMorphs();
     for (unsigned i = 0; i < morphs.Size(); ++i)
@@ -797,7 +797,7 @@ void AnimatedModel::cloneGeometries()
     const Vector<SharedPtr<VertexBuffer> >& originalVertexBuffers = model_->GetVertexBuffers();
     Map<VertexBuffer*, SharedPtr<VertexBuffer> > clonedVertexBuffers;
     
-    morphvertexBuffer_.Resize(originalVertexBuffers.Size());
+    morphVertexBuffers_.Resize(originalVertexBuffers.Size());
     
     for (unsigned i = 0; i < originalVertexBuffers.Size(); ++i)
     {
@@ -817,7 +817,7 @@ void AnimatedModel::cloneGeometries()
             clone->SetMorphRangeResetData(original->GetMorphRangeResetData());
             
             clonedVertexBuffers[original] = clone;
-            morphvertexBuffer_[i] = clone;
+            morphVertexBuffers_[i] = clone;
         }
     }
     
@@ -967,9 +967,9 @@ void AnimatedModel::UpdateMorphs()
         PROFILE(UpdateMorphs);
         
         // Reset the morph data range from all morphable vertex buffers, then apply morphs
-        for (unsigned i = 0; i < morphvertexBuffer_.Size(); ++i)
+        for (unsigned i = 0; i < morphVertexBuffers_.Size(); ++i)
         {
-            VertexBuffer* buffer = morphvertexBuffer_[i];
+            VertexBuffer* buffer = morphVertexBuffers_[i];
             if (buffer)
             {
                 void* lockedMorphRange = buffer->LockMorphRange();

Engine/Graphics/AnimatedModel.h

@@ -113,7 +113,7 @@ public:
     /// Return all vertex morphs
     const Vector<ModelMorph>& GetMorphs() const { return morphs_; }
     /// Return all morph vertex buffers
-    const Vector<SharedPtr<VertexBuffer> >& GetMorphVertexBuffers() const { return morphvertexBuffer_; }
+    const Vector<SharedPtr<VertexBuffer> >& GetMorphVertexBuffers() const { return morphVertexBuffers_; }
     /// Return number of vertex morphs
     unsigned GetNumMorphs() const { return morphs_.Size(); }
     /// Return vertex morph weight by index
@@ -162,7 +162,7 @@ private:
     /// Skeleton
     Skeleton skeleton_;
     /// Morph vertex buffers
-    Vector<SharedPtr<VertexBuffer> > morphvertexBuffer_;
+    Vector<SharedPtr<VertexBuffer> > morphVertexBuffers_;
     /// Vertex morphs
     Vector<ModelMorph> morphs_;
     /// Animation states

Engine/Graphics/Batch.cpp

@@ -359,7 +359,7 @@ void BatchGroup::SetTransforms(void* lockedData, unsigned& freeIndex)
     freeIndex += instances_.Size();
 }
 
-void BatchGroup::Draw(Graphics* graphics, VertexBuffer* buffer) const
+void BatchGroup::Draw(Graphics* graphics, VertexBuffer* instanceBuffer) const
 {
     if (!instances_.Size())
         return;
@@ -376,7 +376,7 @@ void BatchGroup::Draw(Graphics* graphics, VertexBuffer* buffer) const
     batch.vertexShaderIndex_ = vertexShaderIndex_;
     
     // Draw as individual instances if below minimum size, or if instancing not supported
-    if ((instances_.Size() < MIN_INSTANCES) || (!buffer))
+    if ((instances_.Size() < MIN_INSTANCES) || (!instanceBuffer))
     {
         batch.Prepare(graphics, false);
         
@@ -409,8 +409,8 @@ void BatchGroup::Draw(Graphics* graphics, VertexBuffer* buffer) const
         // Get the geometry vertex buffers, then add the instancing stream buffer
         Vector<SharedPtr<VertexBuffer> > vertexBuffers = geometry_->GetVertexBuffers();
         PODVector<unsigned> elementMasks = geometry_->GetVertexElementMasks();
-        vertexBuffers.Push(SharedPtr<VertexBuffer>(buffer));
-        elementMasks.Push(buffer->GetElementMask());
+        vertexBuffers.Push(SharedPtr<VertexBuffer>(instanceBuffer));
+        elementMasks.Push(instanceBuffer->GetElementMask());
         
         // No stream offset support, instancing buffer not pre-filled with transforms: have to lock and fill now
         if (startIndex_ == M_MAX_UNSIGNED)
@@ -419,17 +419,17 @@ void BatchGroup::Draw(Graphics* graphics, VertexBuffer* buffer) const
             while (startIndex < instances_.Size())
             {
                 unsigned instances = instances_.Size() - startIndex;
-                if (instances > buffer->GetVertexCount())
-                    instances = buffer->GetVertexCount();
+                if (instances > instanceBuffer->GetVertexCount())
+                    instances = instanceBuffer->GetVertexCount();
                 
                 // Lock the instance stream buffer and copy the transforms
-                void* data = buffer->Lock(0, instances, LOCK_DISCARD);
+                void* data = instanceBuffer->Lock(0, instances, LOCK_DISCARD);
                 if (!data)
                     return;
                 Matrix3x4* dest = (Matrix3x4*)data;
                 for (unsigned i = 0; i < instances; ++i)
                     dest[i] = *instances_[i + startIndex].worldTransform_;
-                buffer->Unlock();
+                instanceBuffer->Unlock();
                 
                 graphics->SetIndexBuffer(geometry_->GetIndexBuffer());
                 graphics->SetVertexBuffers(vertexBuffers, elementMasks);

Engine/Graphics/Batch.h

@@ -131,7 +131,7 @@ struct BatchGroup
     /// Pre-set the instance transforms. Buffer must be big enough to hold all transforms
     void SetTransforms(void* lockedData, unsigned& freeIndex);
     /// Prepare and draw
-    void Draw(Graphics* graphics, VertexBuffer* buffer) const;
+    void Draw(Graphics* graphics, VertexBuffer* instanceBuffer) const;
     
     /// Geometry
     Geometry* geometry_;

Engine/Graphics/Geometry.cpp

@@ -59,8 +59,8 @@ bool Geometry::SetNumVertexBuffers(unsigned num)
         return false;
     }
     
-    unsigned oldSize = vertexBuffer_.Size();
-    vertexBuffer_.Resize(num);
+    unsigned oldSize = vertexBuffers_.Size();
+    vertexBuffers_.Resize(num);
     elementMasks_.Resize(num);
     
     for (unsigned i = oldSize; i < num; ++i)
@@ -72,13 +72,13 @@ bool Geometry::SetNumVertexBuffers(unsigned num)
 
 bool Geometry::SetVertexBuffer(unsigned index, VertexBuffer* buffer, unsigned elementMask)
 {
-    if (index >= vertexBuffer_.Size())
+    if (index >= vertexBuffers_.Size())
     {
         LOGERROR("Stream index out of bounds");
         return false;
     }
     
-    vertexBuffer_[index] = buffer;
+    vertexBuffers_[index] = buffer;
     
     if (buffer)
     {
@@ -116,7 +116,7 @@ bool Geometry::SetDrawRange(PrimitiveType type, unsigned indexStart, unsigned in
     
     // Get min.vertex index and num of vertices from index buffer. If it fails, use full range as fallback
     vertexStart_ = 0;
-    vertexCount_ = vertexBuffer_[0]->GetVertexCount();
+    vertexCount_ = vertexBuffers_[0]->GetVertexCount();
     
     if (GetUsedVertexRange)
         indexBuffer_->GetUsedVertexRange(indexStart_, indexCount_, vertexStart_, vertexCount_);
@@ -157,13 +157,13 @@ void Geometry::SetLodDistance(float distance)
 void Geometry::Draw(Graphics* graphics)
 {
     graphics->SetIndexBuffer(indexBuffer_);
-    graphics->SetVertexBuffers(vertexBuffer_, elementMasks_);
+    graphics->SetVertexBuffers(vertexBuffers_, elementMasks_);
     graphics->Draw(primitiveType_, indexStart_, indexCount_, vertexStart_, vertexCount_);
 }
 
 VertexBuffer* Geometry::GetVertexBuffer(unsigned index) const
 {
-    return index < vertexBuffer_.Size() ? vertexBuffer_[index] : (VertexBuffer*)0;
+    return index < vertexBuffers_.Size() ? vertexBuffers_[index] : (VertexBuffer*)0;
 }
 
 unsigned Geometry::GetVertexElementMask(unsigned index) const
@@ -175,9 +175,9 @@ unsigned short Geometry::GetBufferHash() const
 {
     unsigned short hash = 0;
     
-    for (unsigned i = 0; i < vertexBuffer_.Size(); ++i)
+    for (unsigned i = 0; i < vertexBuffers_.Size(); ++i)
     {
-        VertexBuffer* vBuf = vertexBuffer_[i];
+        VertexBuffer* vBuf = vertexBuffers_[i];
         hash += *((unsigned short*)&vBuf);
     }
     
@@ -207,11 +207,12 @@ float Geometry::GetDistance(const Ray& ray)
 
 void Geometry::LockRawData(const unsigned char*& vertexData, unsigned& vertexSize, const unsigned char*& indexData, unsigned& indexSize)
 {
-    if ((indexBuffer_) && (positionBufferIndex_ < vertexBuffer_.Size()))
+    if ((indexBuffer_) && (positionBufferIndex_ < vertexBuffers_.Size()))
     {
-        VertexBuffer* positionBuffer = vertexBuffer_[positionBufferIndex_];
+        VertexBuffer* positionBuffer = vertexBuffers_[positionBufferIndex_];
         
-        vertexData = reinterpret_cast<const unsigned char*>(positionBuffer->Lock(0, positionBuffer->GetVertexCount(), LOCK_READONLY));
+        vertexData = reinterpret_cast<const unsigned char*>(positionBuffer->Lock(0, positionBuffer->GetVertexCount(),
+            LOCK_READONLY));
         vertexSize = positionBuffer->GetVertexSize();
         indexData = reinterpret_cast<const unsigned char*>(indexBuffer_->Lock(0, indexBuffer_->GetIndexCount(), LOCK_READONLY));
         indexSize = indexBuffer_->GetIndexSize();
@@ -234,18 +235,18 @@ void Geometry::LockRawData(const unsigned char*& vertexData, unsigned& vertexSiz
 
 void Geometry::UnlockRawData()
 {
-    if ((indexBuffer_) && (positionBufferIndex_ < vertexBuffer_.Size()))
+    if ((indexBuffer_) && (positionBufferIndex_ < vertexBuffers_.Size()))
     {
-        vertexBuffer_[positionBufferIndex_]->Unlock();
+        vertexBuffers_[positionBufferIndex_]->Unlock();
         indexBuffer_->Unlock();
     }
 }
 
 void Geometry::GetPositionBufferIndex()
 {
-    for (unsigned i = 0; i < vertexBuffer_.Size(); ++i)
+    for (unsigned i = 0; i < vertexBuffers_.Size(); ++i)
     {
-        if ((vertexBuffer_[i]) && (vertexBuffer_[i]->GetElementMask() & MASK_POSITION))
+        if ((vertexBuffers_[i]) && (vertexBuffers_[i]->GetElementMask() & MASK_POSITION))
         {
             positionBufferIndex_ = i;
             return;

Engine/Graphics/Geometry.h

@@ -58,11 +58,11 @@ public:
     void Draw(Graphics* graphics);
     
     /// Return all vertex buffers
-    const Vector<SharedPtr<VertexBuffer> >& GetVertexBuffers() const { return vertexBuffer_; }
+    const Vector<SharedPtr<VertexBuffer> >& GetVertexBuffers() const { return vertexBuffers_; }
     /// Return vertex element masks
     const PODVector<unsigned>& GetVertexElementMasks() const { return elementMasks_; }
     /// Return number of vertex buffers
-    unsigned GetNumVertexBuffers() const { return vertexBuffer_.Size(); }
+    unsigned GetNumVertexBuffers() const { return vertexBuffers_.Size(); }
     /// Return vertex buffer by index
     VertexBuffer* GetVertexBuffer(unsigned index) const;
     /// Return vertex element mask by index
@@ -95,7 +95,7 @@ private:
     void GetPositionBufferIndex();
     
     /// Vertex buffers
-    Vector<SharedPtr<VertexBuffer> > vertexBuffer_;
+    Vector<SharedPtr<VertexBuffer> > vertexBuffers_;
     /// Vertex element masks
     PODVector<unsigned> elementMasks_;
     /// Index buffer

Engine/Graphics/Graphics.cpp

@@ -454,7 +454,7 @@ void Graphics::Close()
         diffBuffer_.Reset();
         normalBuffer_.Reset();
         depthBuffer_.Reset();
-        immediatevertexBuffer_.Clear();
+        immediateVertexBuffers_.Clear();
         
         DestroyWindow(impl_->window_);
         impl_->window_ = 0;
@@ -708,7 +708,7 @@ void Graphics::DrawInstanced(PrimitiveType type, unsigned indexStart, unsigned i
     
     for (unsigned i = 0; i < MAX_VERTEX_STREAMS; ++i)
     {
-        VertexBuffer* buffer = vertexBuffer_[i];
+        VertexBuffer* buffer = vertexBuffers_[i];
         if (buffer)
         {
             if (buffer->GetElementMask() & MASK_INSTANCEMATRIX1)
@@ -746,10 +746,10 @@ void Graphics::SetVertexBuffer(VertexBuffer* buffer)
     SetVertexBuffers(vertexBuffers, elementMasks);
 }
 
-bool Graphics::SetVertexBuffers(const Vector<VertexBuffer*>& buffers, const PODVector<unsigned>& elementMasks,
-    unsigned instanceOffset)
+bool Graphics::SetVertexBuffers(const Vector<VertexBuffer*>& buffers, const PODVector<unsigned>&
+    elementMasks, unsigned instanceOffset)
 {
-    if (buffers.Size() > MAX_VERTEX_STREAMS)
+   if (buffers.Size() > MAX_VERTEX_STREAMS)
     {
         LOGERROR("Too many vertex buffers");
         return false;
@@ -805,15 +805,15 @@ bool Graphics::SetVertexBuffers(const Vector<VertexBuffer*>& buffers, const PODV
                 offset = instanceOffset * buffer->GetVertexSize();
         }
         
-        if ((buffer != vertexBuffer_[i]) || (offset != streamOffset_[i]))
+        if ((buffer != vertexBuffers_[i]) || (offset != streamOffsets_[i]))
         {
             if (buffer)
                 impl_->device_->SetStreamSource(i, (IDirect3DVertexBuffer9*)buffer->GetGPUObject(), offset, buffer->GetVertexSize());
             else
                 impl_->device_->SetStreamSource(i, 0, 0, 0);
             
-            vertexBuffer_[i] = buffer;
-            streamOffset_[i] = offset;
+            vertexBuffers_[i] = buffer;
+            streamOffsets_[i] = offset;
         }
     }
     
@@ -879,15 +879,15 @@ bool Graphics::SetVertexBuffers(const Vector<SharedPtr<VertexBuffer> >& buffers,
                 offset = instanceOffset * buffer->GetVertexSize();
         }
         
-        if ((buffer != vertexBuffer_[i]) || (offset != streamOffset_[i]))
+        if ((buffer != vertexBuffers_[i]) || (offset != streamOffsets_[i]))
         {
             if (buffer)
                 impl_->device_->SetStreamSource(i, (IDirect3DVertexBuffer9*)buffer->GetGPUObject(), offset, buffer->GetVertexSize());
             else
                 impl_->device_->SetStreamSource(i, 0, 0, 0);
             
-            vertexBuffer_[i] = buffer;
-            streamOffset_[i] = offset;
+            vertexBuffers_[i] = buffer;
+            streamOffsets_[i] = offset;
         }
     }
     
@@ -1126,7 +1126,7 @@ void Graphics::SetTexture(unsigned index, Texture* texture)
     // Check if texture is currently bound as a render target. In that case, use its backup texture, or blank if not defined
     if (texture)
     {
-        if ((renderTarget_[0]) && (renderTarget_[0]->GetParentTexture() == texture))
+        if ((renderTargets_[0]) && (renderTargets_[0]->GetParentTexture() == texture))
             texture = texture->GetBackupTexture();
         // Check also for the view texture, in case a specific rendering pass does not bind the destination render target,
         // but should still not sample it either
@@ -1134,14 +1134,14 @@ void Graphics::SetTexture(unsigned index, Texture* texture)
             texture = texture->GetBackupTexture();
     }
     
-    if (texture != texture_[index])
+    if (texture != textures_[index])
     {
         if (texture)
             impl_->device_->SetTexture(index, (IDirect3DBaseTexture9*)texture->GetGPUObject());
         else
             impl_->device_->SetTexture(index, 0);
         
-        texture_[index] = texture;
+        textures_[index] = texture;
     }
     
     if (texture)
@@ -1152,38 +1152,38 @@ void Graphics::SetTexture(unsigned index, Texture* texture)
         
         D3DTEXTUREFILTERTYPE minMag, mip;
         minMag = d3dMinMagFilter[filterMode];
-        if (minMag != impl_->minMagFilter_[index])
+        if (minMag != impl_->minMagFilters_[index])
         {
             impl_->device_->SetSamplerState(index, D3DSAMP_MAGFILTER, minMag);
             impl_->device_->SetSamplerState(index, D3DSAMP_MINFILTER, minMag);
-            impl_->minMagFilter_[index] = minMag;
+            impl_->minMagFilters_[index] = minMag;
         }
         mip = d3dMipFilter[filterMode];
-        if (mip != impl_->mipFilter_[index])
+        if (mip != impl_->mipFilters_[index])
         {
             impl_->device_->SetSamplerState(index, D3DSAMP_MIPFILTER, mip);
-            impl_->mipFilter_[index] = mip;
+            impl_->mipFilters_[index] = mip;
         }
         D3DTEXTUREADDRESS u, v;
         u = d3dAddressMode[texture->GetAddressMode(COORD_U)];
-        if (u != impl_->uAddressMode_[index])
+        if (u != impl_->uAddressModes_[index])
         {
             impl_->device_->SetSamplerState(index, D3DSAMP_ADDRESSU, u);
-            impl_->uAddressMode_[index] = u;
+            impl_->uAddressModes_[index] = u;
         }
         v = d3dAddressMode[texture->GetAddressMode(COORD_V)];
-        if (v != impl_->vAddressMode_[index])
+        if (v != impl_->vAddressModes_[index])
         {
             impl_->device_->SetSamplerState(index, D3DSAMP_ADDRESSV, v);
-            impl_->vAddressMode_[index] = v;
+            impl_->vAddressModes_[index] = v;
         }
         if ((u == D3DTADDRESS_BORDER) || (v == D3DTADDRESS_BORDER))
         {
             const Color& borderColor = texture->GetBorderColor();
-            if (borderColor != impl_->borderColor_[index])
+            if (borderColor != impl_->borderColors_[index])
             {
                 impl_->device_->SetSamplerState(index, D3DSAMP_BORDERCOLOR, borderColor.ToUInt());
-                impl_->borderColor_[index] = borderColor;
+                impl_->borderColors_[index] = borderColor;
             }
         }
     }
@@ -1231,12 +1231,12 @@ void Graphics::SetRenderTarget(unsigned index, RenderSurface* renderTarget)
             newColorSurface = impl_->defaultColorSurface_;
     }
     
-    renderTarget_[index] = renderTarget;
+    renderTargets_[index] = renderTarget;
     
-    if (newColorSurface != impl_->colorSurface_[index])
+    if (newColorSurface != impl_->colorSurfaces_[index])
     {
         impl_->device_->SetRenderTarget(index, newColorSurface);
-        impl_->colorSurface_[index] = newColorSurface;
+        impl_->colorSurfaces_[index] = newColorSurface;
     }
     
     // If the rendertarget is also bound as a texture, replace with backup texture or null
@@ -1246,8 +1246,8 @@ void Graphics::SetRenderTarget(unsigned index, RenderSurface* renderTarget)
         
         for (unsigned i = 0; i < MAX_TEXTURE_UNITS; ++i)
         {
-            if (texture_[i] == parentTexture)
-                SetTexture(i, texture_[i]->GetBackupTexture());
+            if (textures_[i] == parentTexture)
+                SetTexture(i, textures_[i]->GetBackupTexture());
         }
     }
     
@@ -1339,8 +1339,8 @@ void Graphics::SetViewTexture(Texture* texture)
     {
         for (unsigned i = 0; i < MAX_TEXTURE_UNITS; ++i)
         {
-            if (texture_[i] == texture)
-                SetTexture(i, texture_[i]->GetBackupTexture());
+            if (textures_[i] == texture)
+                SetTexture(i, textures_[i]->GetBackupTexture());
         }
     }
 }
@@ -1627,10 +1627,10 @@ void Graphics::SetStencilTest(bool enable, CompareMode mode, StencilOp pass, Ste
 
 void Graphics::SetStreamFrequency(unsigned index, unsigned frequency)
 {
-    if ((index < MAX_VERTEX_STREAMS) && (streamFrequency_[index] != frequency))
+    if ((index < MAX_VERTEX_STREAMS) && (streamFrequencies_[index] != frequency))
     {
         impl_->device_->SetStreamSourceFreq(index, frequency);
-        streamFrequency_[index] = frequency;
+        streamFrequencies_[index] = frequency;
     }
 }
 
@@ -1638,10 +1638,10 @@ void Graphics::ResetStreamFrequencies()
 {
     for (unsigned i = 0; i < MAX_VERTEX_STREAMS; ++i)
     {
-        if (streamFrequency_[i] != 1)
+        if (streamFrequencies_[i] != 1)
         {
             impl_->device_->SetStreamSourceFreq(i, 1);
-            streamFrequency_[i] = 1;
+            streamFrequencies_[i] = 1;
         }
     }
 }
@@ -1667,17 +1667,17 @@ bool Graphics::BeginImmediate(PrimitiveType type, unsigned vertexCount, unsigned
         newSize <<= 1;
         
     // See if buffer exists for this vertex format. If not, create new
-    if (immediatevertexBuffer_.Find(elementMask) == immediatevertexBuffer_.End())
+    if (immediateVertexBuffers_.Find(elementMask) == immediateVertexBuffers_.End())
     {
         LOGDEBUG("Created immediate vertex buffer");
         VertexBuffer* newBuffer = new VertexBuffer(context_);
         newBuffer->SetSize(newSize, elementMask, true);
-        immediatevertexBuffer_[elementMask] = newBuffer;
+        immediateVertexBuffers_[elementMask] = newBuffer;
         immediateVertexBufferPos_[elementMask] = 0;
     }
     
     // Resize buffer if it is too small
-    VertexBuffer* buffer = immediatevertexBuffer_[elementMask];
+    VertexBuffer* buffer = immediateVertexBuffers_[elementMask];
     if (buffer->GetVertexCount() < newSize)
     {
         LOGDEBUG("Resized immediate vertex buffer to " + String(newSize));
@@ -1871,7 +1871,7 @@ PODVector<int> Graphics::GetMultiSampleLevels() const
 
 VertexBuffer* Graphics::GetVertexBuffer(unsigned index) const
 {
-    return index < MAX_VERTEX_STREAMS ? vertexBuffer_[index] : 0;
+    return index < MAX_VERTEX_STREAMS ? vertexBuffers_[index] : 0;
 }
 
 ShaderParameter Graphics::GetShaderParameter(const String& name)
@@ -1914,27 +1914,27 @@ const String& Graphics::GetTextureUnitName(TextureUnit unit)
 
 Texture* Graphics::GetTexture(unsigned index) const
 {
-    return index < MAX_TEXTURE_UNITS ? texture_[index] : 0;
+    return index < MAX_TEXTURE_UNITS ? textures_[index] : 0;
 }
 
 RenderSurface* Graphics::GetRenderTarget(unsigned index) const
 {
-    return index < MAX_RENDERTARGETS ? renderTarget_[index] : 0;
+    return index < MAX_RENDERTARGETS ? renderTargets_[index] : 0;
 }
 
 unsigned Graphics::GetStreamFrequency(unsigned index) const
 {
-    return index < MAX_VERTEX_STREAMS ? streamFrequency_[index] : 0;
+    return index < MAX_VERTEX_STREAMS ? streamFrequencies_[index] : 0;
 }
 
 IntVector2 Graphics::GetRenderTargetDimensions() const
 {
     int width, height;
     
-    if (renderTarget_[0])
+    if (renderTargets_[0])
     {
-        width = renderTarget_[0]->GetWidth();
-        height = renderTarget_[0]->GetHeight();
+        width = renderTargets_[0]->GetWidth();
+        height = renderTargets_[0]->GetHeight();
     }
     else
     {
@@ -2200,14 +2200,14 @@ void Graphics::CreateRenderTargets()
         {
             for (unsigned i = 0; i < NUM_SCREEN_BUFFERS; ++i)
             {
-                screenBuffer_[i] = new Texture2D(context_);
-                screenBuffer_[i]->SetSize(0, 0, GetRGBAFormat(), TEXTURE_RENDERTARGET);
+                screenBuffers_[i] = new Texture2D(context_);
+                screenBuffers_[i]->SetSize(0, 0, GetRGBAFormat(), TEXTURE_RENDERTARGET);
             }
         }
         else
         {
             for (unsigned i = 0; i < NUM_SCREEN_BUFFERS; ++i)
-                screenBuffer_[i].Reset();
+                screenBuffers_[i].Reset();
         }
     }
     else
@@ -2216,7 +2216,7 @@ void Graphics::CreateRenderTargets()
         normalBuffer_.Reset();
         depthBuffer_.Reset();
         for (unsigned i = 0; i < NUM_SCREEN_BUFFERS; ++i)
-            screenBuffer_[i].Reset();
+            screenBuffers_[i].Reset();
     }
 }
 
@@ -2277,24 +2277,24 @@ void Graphics::ResetCachedState()
 {
     for (unsigned i = 0; i < MAX_VERTEX_STREAMS; ++i)
     {
-        vertexBuffer_[i] = 0;
-        streamOffset_[i] = 0;
+        vertexBuffers_[i] = 0;
+        streamOffsets_[i] = 0;
     }
     
     for (unsigned i = 0; i < MAX_TEXTURE_UNITS; ++i)
     {
-        texture_[i] = 0;
-        impl_->minMagFilter_[i] = D3DTEXF_POINT;
-        impl_->mipFilter_[i] = D3DTEXF_NONE;
-        impl_->uAddressMode_[i] = D3DTADDRESS_WRAP;
-        impl_->vAddressMode_[i] = D3DTADDRESS_WRAP;
-        impl_->borderColor_[i] = Color(0.0f, 0.0f, 0.0f, 0.0f);
+        textures_[i] = 0;
+        impl_->minMagFilters_[i] = D3DTEXF_POINT;
+        impl_->mipFilters_[i] = D3DTEXF_NONE;
+        impl_->uAddressModes_[i] = D3DTADDRESS_WRAP;
+        impl_->vAddressModes_[i] = D3DTADDRESS_WRAP;
+        impl_->borderColors_[i] = Color(0.0f, 0.0f, 0.0f, 0.0f);
     }
     
     for (unsigned i = 0; i < MAX_RENDERTARGETS; ++i)
     {
-        renderTarget_[i] = 0;
-        impl_->colorSurface_[i] = 0;
+        renderTargets_[i] = 0;
+        impl_->colorSurfaces_[i] = 0;
     }
     depthStencil_ = 0;
     impl_->depthStencilSurface_ = 0;
@@ -2302,7 +2302,7 @@ void Graphics::ResetCachedState()
     viewTexture_ = 0;
     
     for (unsigned i = 0; i < MAX_VERTEX_STREAMS; ++i)
-        streamFrequency_[i] = 1;
+        streamFrequencies_[i] = 1;
     
     indexBuffer_ = 0;
     vertexDeclaration_ = 0;

Engine/Graphics/Graphics.h

@@ -336,7 +336,7 @@ public:
     /// Return depth buffer for deferred rendering. If reading hardware depth is supported, return a depth texture
     Texture2D* GetDepthBuffer() const { return depthBuffer_; }
     /// Return screen buffer for post-processing
-    Texture2D* GetScreenBuffer(unsigned index) const { return screenBuffer_[index & (NUM_SCREEN_BUFFERS - 1)]; }
+    Texture2D* GetScreenBuffer(unsigned index) const { return screenBuffers_[index & (NUM_SCREEN_BUFFERS - 1)]; }
     
     /// Add a GPU object to keep track of. Called by GPUObject.
     void AddGPUObject(GPUObject* object);
@@ -439,7 +439,7 @@ private:
     /// Vertex declarations
     Map<unsigned long long, SharedPtr<VertexDeclaration> > vertexDeclarations_;
     /// Immediate rendering vertex buffers by vertex declaration
-    Map<unsigned, SharedPtr<VertexBuffer> > immediatevertexBuffer_;
+    Map<unsigned, SharedPtr<VertexBuffer> > immediateVertexBuffers_;
     /// Immediate rendering vertex buffer start positions
     Map<unsigned, unsigned> immediateVertexBufferPos_;
     /// Deferred rendering diffuse buffer
@@ -449,7 +449,7 @@ private:
     /// Deferred rendering depth buffer
     SharedPtr<Texture2D> depthBuffer_;
     /// Screen buffers for post processing
-    SharedPtr<Texture2D> screenBuffer_[NUM_SCREEN_BUFFERS];
+    SharedPtr<Texture2D> screenBuffers_[NUM_SCREEN_BUFFERS];
     /// Shadow map dummy color texture format
     unsigned dummyColorFormat_;
     /// Shadow map depth texture format
@@ -457,11 +457,11 @@ private:
     /// Shadow map 24-bit depth texture format
     unsigned hiresShadowMapFormat_;
     /// Vertex buffers in use
-    VertexBuffer* vertexBuffer_[MAX_VERTEX_STREAMS];
+    VertexBuffer* vertexBuffers_[MAX_VERTEX_STREAMS];
     /// Stream frequencies by vertex buffer
-    unsigned streamFrequency_[MAX_VERTEX_STREAMS];
+    unsigned streamFrequencies_[MAX_VERTEX_STREAMS];
     /// Stream offsets by vertex buffer
-    unsigned streamOffset_[MAX_VERTEX_STREAMS];
+    unsigned streamOffsets_[MAX_VERTEX_STREAMS];
     /// Index buffer in use
     IndexBuffer* indexBuffer_;
     /// Vertex declaration in use
@@ -477,13 +477,13 @@ private:
     /// Last shader parameter sources per parameter
     const void* lastShaderParameterSources_[MAX_SHADER_PARAMETERS];
     /// Textures in use
-    Texture* texture_[MAX_TEXTURE_UNITS];
+    Texture* textures_[MAX_TEXTURE_UNITS];
     /// "View texture" to prevent sampling the destination render target
     Texture* viewTexture_;
     /// Texture unit mappings
     Map<String, TextureUnit> textureUnits_;
     /// Render targets in use
-    RenderSurface* renderTarget_[MAX_RENDERTARGETS];
+    RenderSurface* renderTargets_[MAX_RENDERTARGETS];
     /// Depth stencil buffer in use
     RenderSurface* depthStencil_;
     /// Viewport coordinates

Engine/Graphics/GraphicsImpl.h

@@ -78,17 +78,17 @@ private:
     /// Direct3D presentation parameters
     D3DPRESENT_PARAMETERS presentParams_;
     /// Texture min/mag filter modes in use
-    D3DTEXTUREFILTERTYPE minMagFilter_[MAX_TEXTURE_UNITS];
+    D3DTEXTUREFILTERTYPE minMagFilters_[MAX_TEXTURE_UNITS];
     /// Texture mip filter modes in use
-    D3DTEXTUREFILTERTYPE mipFilter_[MAX_TEXTURE_UNITS];
+    D3DTEXTUREFILTERTYPE mipFilters_[MAX_TEXTURE_UNITS];
     /// Texture U coordinate addressing modes in use
-    D3DTEXTUREADDRESS uAddressMode_[MAX_TEXTURE_UNITS];
+    D3DTEXTUREADDRESS uAddressModes_[MAX_TEXTURE_UNITS];
     /// Texture V coordinate addressing modes in use
-    D3DTEXTUREADDRESS vAddressMode_[MAX_TEXTURE_UNITS];
+    D3DTEXTUREADDRESS vAddressModes_[MAX_TEXTURE_UNITS];
     /// Texture border colors in use
-    Color borderColor_[MAX_TEXTURE_UNITS];
+    Color borderColors_[MAX_TEXTURE_UNITS];
     /// Color surfaces in use
-    IDirect3DSurface9* colorSurface_[MAX_RENDERTARGETS];
+    IDirect3DSurface9* colorSurfaces_[MAX_RENDERTARGETS];
     /// Depth stencil buffer in use
     IDirect3DSurface9* depthStencilSurface_;
     /// Blending enabled flag

Engine/Graphics/Model.cpp

@@ -89,7 +89,7 @@ bool Model::Load(Deserializer& source)
     geometries_.Clear();
     geometryBoneMappings_.Clear();
     morphs_.Clear();
-    vertexBuffer_.Clear();
+    vertexBuffers_.Clear();
     indexBuffers_.Clear();
     
     SetMemoryUse(source.GetSize());
@@ -124,7 +124,7 @@ bool Model::Load(Deserializer& source)
         else
             return false;
         
-        vertexBuffer_.Push(buffer);
+        vertexBuffers_.Push(buffer);
     }
     
     // Read index buffers
@@ -173,7 +173,7 @@ bool Model::Load(Deserializer& source)
             unsigned indexStart = source.ReadUInt();
             unsigned indexCount = source.ReadUInt();
             
-            if (vertexBufferRef >= vertexBuffer_.Size())
+            if (vertexBufferRef >= vertexBuffers_.Size())
             {
                 LOGERROR("Vertex buffer index out of bounds");
                 return false;
@@ -186,7 +186,7 @@ bool Model::Load(Deserializer& source)
             
             SharedPtr<Geometry> geometry(new Geometry(context_));
             geometry->SetNumVertexBuffers(1);
-            geometry->SetVertexBuffer(0, vertexBuffer_[vertexBufferRef]);
+            geometry->SetVertexBuffer(0, vertexBuffers_[vertexBufferRef]);
             geometry->SetIndexBuffer(indexBuffers_[indexBufferRef]);
             geometry->SetDrawRange(type, indexStart, indexCount);
             geometry->SetLodDistance(distance);

Engine/Graphics/Model.h

@@ -96,7 +96,7 @@ public:
     /// Return skeleton
     Skeleton& GetSkeleton() { return skeleton_; }
     /// Return vertex buffers
-    const Vector<SharedPtr<VertexBuffer> >& GetVertexBuffers() const { return vertexBuffer_; }
+    const Vector<SharedPtr<VertexBuffer> >& GetVertexBuffers() const { return vertexBuffers_; }
     /// Return index buffers
     const Vector<SharedPtr<IndexBuffer> >& GetIndexBuffers() const { return indexBuffers_; }
     /// Return number of geometries
@@ -125,11 +125,11 @@ private:
     BoundingBox boundingBox_;
     /// Skeleton
     Skeleton skeleton_;
-    /// Vertex buffer pointers
-    Vector<SharedPtr<VertexBuffer> > vertexBuffer_;
-    /// Index buffer pointers
+    /// Vertex buffers
+    Vector<SharedPtr<VertexBuffer> > vertexBuffers_;
+    /// Index buffers
     Vector<SharedPtr<IndexBuffer> > indexBuffers_;
-    /// Geometry pointers
+    /// Geometries
     Vector<Vector<SharedPtr<Geometry> > > geometries_;
     /// Geometry bone mappings
     Vector<PODVector<unsigned> > geometryBoneMappings_;