mirror of
https://github.com/minetest/irrlicht.git
synced 2024-09-20 12:29:04 +02:00
2fa3b0d1ee
Previously vertex buffer did some invalid casts to references which could cause it to copy whatever was in memory into the vertex-arrays. Generally it worked up to S3DVertex - but switch from another type to S3DVertex2TCoords or S3DVertexTangents caused it to be filled with whatever was in memory behind it. Setter functions in IVertexBuffer have now overloads for all known vertex types. Also adding const version of IVertexBuffer::getData. And some warnings in comments about using the array functions (if even we mess it up...) Also de-deprecate IIndexBuffer::pointer() again. I don't like having 2 functions for same stuff, but in the end it doesn't really hurt keeping it around. git-svn-id: svn://svn.code.sf.net/p/irrlicht/code/trunk@6360 dfc29bdd-3216-0410-991c-e03cc46cb475
280 lines
7.6 KiB
C++
280 lines
7.6 KiB
C++
// Copyright (C) 2008-2012 Nikolaus Gebhardt
|
|
// This file is part of the "Irrlicht Engine".
|
|
// For conditions of distribution and use, see copyright notice in irrlicht.h
|
|
|
|
#ifndef IRR_C_VERTEX_BUFFER_H_INCLUDED
|
|
#define IRR_C_VERTEX_BUFFER_H_INCLUDED
|
|
|
|
#include "IVertexBuffer.h"
|
|
|
|
|
|
namespace irr
|
|
{
|
|
namespace scene
|
|
{
|
|
|
|
class CVertexBuffer : public IVertexBuffer
|
|
{
|
|
class IVertexList
|
|
{
|
|
public:
|
|
virtual ~IVertexList(){};
|
|
|
|
virtual u32 stride() const =0;
|
|
|
|
virtual u32 size() const =0;
|
|
|
|
virtual void push_back (const video::S3DVertex &element) =0;
|
|
virtual void push_back(const video::S3DVertex2TCoords &element) =0;
|
|
virtual void push_back(const video::S3DVertexTangents &element) =0;
|
|
virtual void setValue(u32 index, const video::S3DVertex &value) =0;
|
|
virtual void setValue(u32 index, const video::S3DVertex2TCoords &value) =0;
|
|
virtual void setValue(u32 index, const video::S3DVertexTangents &value) =0;
|
|
|
|
virtual video::S3DVertex& operator [](u32 index) = 0;
|
|
virtual video::S3DVertex& operator [](const u32 index) const =0;
|
|
virtual video::S3DVertex& getLast() =0;
|
|
virtual void set_used(u32 usedNow) =0;
|
|
virtual void reallocate(u32 new_size, bool canShrink=true) =0;
|
|
virtual u32 allocated_size() const =0;
|
|
virtual void* pointer() =0;
|
|
virtual const void* const_pointer() const =0;
|
|
virtual video::E_VERTEX_TYPE getType() const =0;
|
|
};
|
|
|
|
template <class T>
|
|
class CSpecificVertexList : public IVertexList
|
|
{
|
|
public:
|
|
core::array<T> Vertices;
|
|
|
|
virtual u32 stride() const IRR_OVERRIDE {return sizeof(T);}
|
|
|
|
virtual u32 size() const IRR_OVERRIDE {return Vertices.size();}
|
|
|
|
virtual void push_back (const video::S3DVertex &element) IRR_OVERRIDE
|
|
{Vertices.push_back(element);}
|
|
virtual void push_back(const video::S3DVertex2TCoords &element) IRR_OVERRIDE
|
|
{Vertices.push_back(element);}
|
|
virtual void push_back(const video::S3DVertexTangents &element) IRR_OVERRIDE
|
|
{Vertices.push_back(element);}
|
|
|
|
virtual void setValue(u32 index, const video::S3DVertex &value) IRR_OVERRIDE
|
|
{Vertices[index] = value;}
|
|
virtual void setValue(u32 index, const video::S3DVertex2TCoords &value) IRR_OVERRIDE
|
|
{Vertices[index] = value;}
|
|
virtual void setValue(u32 index, const video::S3DVertexTangents &value) IRR_OVERRIDE
|
|
{Vertices[index] = value;}
|
|
|
|
virtual video::S3DVertex& operator [](u32 index) IRR_OVERRIDE
|
|
{return (video::S3DVertex&)Vertices[index];}
|
|
|
|
virtual video::S3DVertex& operator [](const u32 index) const IRR_OVERRIDE
|
|
{return (video::S3DVertex&)Vertices[index];}
|
|
|
|
virtual video::S3DVertex& getLast() IRR_OVERRIDE
|
|
{return (video::S3DVertex&)Vertices.getLast();}
|
|
|
|
virtual void set_used(u32 usedNow) IRR_OVERRIDE
|
|
{Vertices.set_used(usedNow);}
|
|
|
|
virtual void reallocate(u32 new_size, bool canShrink) IRR_OVERRIDE
|
|
{Vertices.reallocate(new_size, canShrink);}
|
|
|
|
virtual u32 allocated_size() const IRR_OVERRIDE
|
|
{
|
|
return Vertices.allocated_size();
|
|
}
|
|
|
|
virtual void* pointer() IRR_OVERRIDE {return Vertices.pointer();}
|
|
virtual const void* const_pointer() const IRR_OVERRIDE {return Vertices.const_pointer();}
|
|
|
|
virtual video::E_VERTEX_TYPE getType() const IRR_OVERRIDE {return T::getType();}
|
|
};
|
|
|
|
public:
|
|
IVertexList *Vertices;
|
|
|
|
CVertexBuffer(video::E_VERTEX_TYPE vertexType) : Vertices(0),
|
|
MappingHint(EHM_NEVER), ChangedID(1)
|
|
{
|
|
setType(vertexType);
|
|
}
|
|
|
|
CVertexBuffer(const IVertexBuffer &VertexBufferCopy) :
|
|
Vertices(0), MappingHint(EHM_NEVER),
|
|
ChangedID(1)
|
|
{
|
|
setType(VertexBufferCopy.getType());
|
|
reallocate(VertexBufferCopy.size());
|
|
|
|
for (u32 n=0;n<VertexBufferCopy.size();++n)
|
|
push_back(VertexBufferCopy[n]);
|
|
}
|
|
|
|
virtual ~CVertexBuffer()
|
|
{
|
|
delete Vertices;
|
|
}
|
|
|
|
virtual void setType(video::E_VERTEX_TYPE vertexType) IRR_OVERRIDE
|
|
{
|
|
if ( Vertices && Vertices->getType() == vertexType )
|
|
return;
|
|
|
|
IVertexList *NewVertices=0;
|
|
|
|
switch (vertexType)
|
|
{
|
|
case video::EVT_STANDARD:
|
|
{
|
|
NewVertices=new CSpecificVertexList<video::S3DVertex>;
|
|
break;
|
|
}
|
|
case video::EVT_2TCOORDS:
|
|
{
|
|
NewVertices=new CSpecificVertexList<video::S3DVertex2TCoords>;
|
|
break;
|
|
}
|
|
case video::EVT_TANGENTS:
|
|
{
|
|
NewVertices=new CSpecificVertexList<video::S3DVertexTangents>;
|
|
break;
|
|
}
|
|
}
|
|
if (Vertices)
|
|
{
|
|
NewVertices->reallocate( Vertices->size() );
|
|
|
|
switch (Vertices->getType()) // old type
|
|
{
|
|
case video::EVT_STANDARD:
|
|
{
|
|
for(u32 n=0;n<Vertices->size();++n)
|
|
NewVertices->push_back((*Vertices)[n]);
|
|
break;
|
|
}
|
|
case video::EVT_2TCOORDS:
|
|
{
|
|
for(u32 n=0;n<Vertices->size();++n)
|
|
NewVertices->push_back((video::S3DVertex2TCoords&)(*Vertices)[n]);
|
|
break;
|
|
}
|
|
case video::EVT_TANGENTS:
|
|
{
|
|
for(u32 n=0;n<Vertices->size();++n)
|
|
NewVertices->push_back((video::S3DVertexTangents&)(*Vertices)[n]);
|
|
break;
|
|
}
|
|
}
|
|
|
|
delete Vertices;
|
|
}
|
|
|
|
Vertices=NewVertices;
|
|
}
|
|
|
|
virtual void* getData() IRR_OVERRIDE {return Vertices->pointer();}
|
|
virtual const void* getData() const IRR_OVERRIDE {return Vertices->const_pointer();}
|
|
|
|
virtual video::E_VERTEX_TYPE getType() const IRR_OVERRIDE {return Vertices->getType();}
|
|
|
|
virtual u32 stride() const IRR_OVERRIDE {return Vertices->stride();}
|
|
|
|
virtual u32 size() const IRR_OVERRIDE
|
|
{
|
|
return Vertices->size();
|
|
}
|
|
|
|
virtual void push_back (const video::S3DVertex &element) IRR_OVERRIDE
|
|
{
|
|
Vertices->push_back(element);
|
|
}
|
|
|
|
virtual void push_back(const video::S3DVertex2TCoords &element) IRR_OVERRIDE
|
|
{
|
|
Vertices->push_back(element);
|
|
}
|
|
|
|
virtual void push_back(const video::S3DVertexTangents &element) IRR_OVERRIDE
|
|
{
|
|
Vertices->push_back(element);
|
|
}
|
|
|
|
virtual void setValue(u32 index, const video::S3DVertex &value) IRR_OVERRIDE
|
|
{
|
|
Vertices->setValue(index, value);
|
|
}
|
|
|
|
virtual void setValue(u32 index, const video::S3DVertex2TCoords &value) IRR_OVERRIDE
|
|
{
|
|
Vertices->setValue(index, value);
|
|
}
|
|
|
|
virtual void setValue(u32 index, const video::S3DVertexTangents &value) IRR_OVERRIDE
|
|
{
|
|
Vertices->setValue(index, value);
|
|
}
|
|
|
|
virtual video::S3DVertex& operator [](u32 index) IRR_OVERRIDE
|
|
{
|
|
return (*Vertices)[index];
|
|
}
|
|
|
|
virtual video::S3DVertex& operator [](const u32 index) const IRR_OVERRIDE
|
|
{
|
|
return (*Vertices)[index];
|
|
}
|
|
|
|
virtual video::S3DVertex& getLast() IRR_OVERRIDE
|
|
{
|
|
return Vertices->getLast();
|
|
}
|
|
|
|
virtual void set_used(u32 usedNow) IRR_OVERRIDE
|
|
{
|
|
Vertices->set_used(usedNow);
|
|
}
|
|
|
|
virtual void reallocate(u32 new_size, bool canShrink=true) IRR_OVERRIDE
|
|
{
|
|
Vertices->reallocate(new_size, canShrink);
|
|
}
|
|
|
|
virtual u32 allocated_size() const IRR_OVERRIDE
|
|
{
|
|
return Vertices->allocated_size();
|
|
}
|
|
|
|
//! get the current hardware mapping hint
|
|
virtual E_HARDWARE_MAPPING getHardwareMappingHint() const IRR_OVERRIDE
|
|
{
|
|
return MappingHint;
|
|
}
|
|
|
|
//! set the hardware mapping hint, for driver
|
|
virtual void setHardwareMappingHint( E_HARDWARE_MAPPING NewMappingHint ) IRR_OVERRIDE
|
|
{
|
|
MappingHint=NewMappingHint;
|
|
}
|
|
|
|
//! flags the mesh as changed, reloads hardware buffers
|
|
virtual void setDirty() IRR_OVERRIDE
|
|
{
|
|
++ChangedID;
|
|
}
|
|
|
|
//! Get the currently used ID for identification of changes.
|
|
/** This shouldn't be used for anything outside the VideoDriver. */
|
|
virtual u32 getChangedID() const IRR_OVERRIDE {return ChangedID;}
|
|
|
|
E_HARDWARE_MAPPING MappingHint;
|
|
u32 ChangedID;
|
|
};
|
|
|
|
|
|
} // end namespace scene
|
|
} // end namespace irr
|
|
|
|
#endif
|