Creating the MeshBase interface

anki/gl/BufferObject.h

@@ -105,7 +105,10 @@ public:
 	void write(void* buff, size_t offset, size_t size);
 
 	/// If created is run successfully it returns true
-	bool isCreated() const {return glId != 0;}
+	bool isCreated() const
+	{
+		return glId != 0;
+	}
 
 private:
 	uint glId; ///< The OpenGL id of the BO

anki/resource/Mesh.cpp

@@ -44,19 +44,19 @@ void Mesh::load(const char* filename)
 //==============================================================================
 void Mesh::createVbos(const MeshData& meshData)
 {
-	vbos[VBO_VERT_INDECES].create(
+	vbos[VBO_INDICES].create(
 		GL_ELEMENT_ARRAY_BUFFER,
 		Util::getVectorSizeInBytes(meshData.getVertIndeces()),
 		&meshData.getVertIndeces()[0],
 		GL_STATIC_DRAW);
 
-	vbos[VBO_VERT_POSITIONS].create(
+	vbos[VBO_POSITIONS].create(
 		GL_ARRAY_BUFFER,
 		Util::getVectorSizeInBytes(meshData.getVertCoords()),
 		&meshData.getVertCoords()[0],
 		GL_STATIC_DRAW);
 
-	vbos[VBO_VERT_NORMALS].create(
+	vbos[VBO_NORMALS].create(
 		GL_ARRAY_BUFFER,
 		Util::getVectorSizeInBytes(meshData.getVertNormals()),
 		&meshData.getVertNormals()[0],
@@ -64,7 +64,7 @@ void Mesh::createVbos(const MeshData& meshData)
 
 	if(meshData.getVertTangents().size() > 1)
 	{
-		vbos[VBO_VERT_TANGENTS].create(
+		vbos[VBO_TANGENTS].create(
 			GL_ARRAY_BUFFER,
 			Util::getVectorSizeInBytes(meshData.getVertTangents()),
 			&meshData.getVertTangents()[0],
@@ -82,7 +82,7 @@ void Mesh::createVbos(const MeshData& meshData)
 
 	if(meshData.getVertWeights().size() > 1)
 	{
-		vbos[VBO_VERT_WEIGHTS].create(
+		vbos[VBO_WEIGHTS].create(
 			GL_ARRAY_BUFFER,
 			Util::getVectorSizeInBytes(meshData.getVertWeights()),
 			&meshData.getVertWeights()[0],

anki/resource/Mesh.h

@@ -3,7 +3,6 @@
 
 #include <boost/array.hpp>
 #include "anki/math/Math.h"
-#include "anki/resource/Resource.h"
 #include "anki/gl/Vbo.h"
 #include "anki/collision/Obb.h"
 
@@ -14,29 +13,35 @@ namespace anki {
 class MeshData;
 
 
-/// XXX
+/// This is the interface class for meshes. Its interface because the skin
+/// nodes override it
 class MeshBase
 {
 public:
-	MeshBase()
-	{}
+	enum VboId
+	{
+		VBO_POSITIONS, ///< VBO never empty
+		VBO_NORMALS, ///< VBO never empty
+		VBO_TANGENTS, ///< VBO never empty
+		VBO_TEX_COORDS, ///< VBO may be empty
+		VBO_INDICES, ///< VBO never empty
+		VBO_WEIGHTS, ///< VBO may be empty
+		VBOS_NUMBER
+	};
 
 	virtual ~MeshBase()
 	{}
 
 	/// @name Accessors
 	/// @{
-	virtual const Vbo& getPositionsVbo() const = 0;
-	virtual const Vbo& getNormalsVbo() const = 0;
-	virtual const Vbo& getTangentsVbo() const = 0;
-	virtual const Vbo& getTextureCoordsVbo(uint channel) const = 0;
-	virtual const Vbo& getIndecesVbo(uint lod) const = 0;
-	virtual const Vbo& getWeightsVbo() const = 0;
+
+	/// Get a VBO. Its nullptr if it does not exist
+	virtual const Vbo* getVbo(VboId id) const = 0;
 
 	virtual uint getTextureChannelsNumber() const = 0;
 	virtual uint getLodsNumber() const = 0;
 	virtual uint getIndicesNumber(uint lod) const = 0;
-	virtual uint getVertexNumber(uint lod) const = 0;
+	virtual uint getVerticesNumber(uint lod) const = 0;
 	/// @}
 
 	/// @name Ask for geometry properties
@@ -46,89 +51,92 @@ public:
 		return getTextureChannelsNumber() > 0;
 	}
 
-	virtual bool hasWeights() const;
+	bool hasWeights() const
+	{
+		return getVbo(VBO_WEIGHTS) != NULL;
+	}
+
+	bool hasNormalsAndTangents() const
+	{
+		return getVbo(VBO_NORMALS) && getVbo(VBO_TANGENTS);
+	}
 	/// @}
 };
 
 
 /// Mesh Resource. It contains the geometry packed in VBOs
-class Mesh
+class Mesh: public MeshBase
 {
 public:
-	/// Used in @ref vbos array
-	enum Vbos
-	{
-		VBO_VERT_POSITIONS, ///< VBO never empty
-		VBO_VERT_NORMALS, ///< VBO never empty
-		VBO_VERT_TANGENTS, ///< VBO never empty
-		VBO_TEX_COORDS, ///< VBO may be empty
-		VBO_VERT_INDECES, ///< VBO never empty
-		VBO_VERT_WEIGHTS, ///< VBO may be empty
-		VBOS_NUM
-	};
+	typedef boost::array<Vbo, VBOS_NUMBER> VbosArray;
 
-	typedef boost::array<Vbo, VBOS_NUM> VbosArray;
+	/// @name Constructors
+	/// @{
 
-	/// Default constructor
+	/// Default constructor. Do nothing
 	Mesh()
 	{}
 
+	/// Load file
+	Mesh(const char* filename)
+	{
+		load(filename);
+	}
+	/// @}
+
 	/// Does nothing
 	~Mesh()
 	{}
 
 	/// @name Accessors
 	/// @{
-	const Vbo& getVbo(Vbos id) const
-	{
-		return vbos[id];
-	}
 
-	uint getVertIdsNum() const
+	/// Implements MeshBase::getVbo
+	const Vbo* getVbo(VboId id) const
 	{
-		return vertIdsNum;
+		return vbos[id].isCreated() ? &vbos[id] : NULL;
 	}
 
-	const Obb& getVisibilityShape() const
+	/// Implements MeshBase::getTextureChannelsNumber
+	uint getTextureChannelsNumber() const
 	{
-		return visibilityShape;
+		return vbos[VBO_TEX_COORDS].isCreated() ? 1 : 0;
 	}
 
-	uint getVertsNum() const
+	/// Implements MeshBase::getLodsNumber
+	uint getLodsNumber() const
 	{
-		return vertsNum;
+		return 1;
 	}
-	/// @}
 
-	/// Load from a file
-	void load(const char* filename);
-
-	/// @name Ask for geometry properties
-	/// @{
-	bool hasTexCoords() const
+	/// Implements MeshBase::getIndicesNumber
+	uint getIndicesNumber(uint) const
 	{
-		return vbos[VBO_TEX_COORDS].isCreated();
+		return vertIdsNum;
 	}
 
-	bool hasVertWeights() const
+	/// Implements MeshBase::getVerticesNumber
+	uint getVerticesNumber(uint) const
 	{
-		return vbos[VBO_VERT_WEIGHTS].isCreated();
+		return vertsNum;
 	}
 
-	bool hasNormalsAndTangents() const
+	const Obb& getVisibilityShape() const
 	{
-		return vbos[VBO_VERT_NORMALS].isCreated() &&
-			vbos[VBO_VERT_TANGENTS].isCreated();
+		return visibilityShape;
 	}
 	/// @}
 
+	/// Load from a file
+	void load(const char* filename);
+
 private:
 	VbosArray vbos; ///< The vertex buffer objects
 	uint vertIdsNum; ///< The number of vertex IDs
 	Obb visibilityShape;
 	uint vertsNum;
 
-	/// Create the VBOs
+	/// Create the VBOs using the mesh data
 	void createVbos(const MeshData& meshData);
 };