ciao.
Ho implementato un gestore di bufferobject opengl, funziona coi template e si usa cosi:
codice:
CVboManager<
		CVboCreator	,
		3,
		glm::vec3[3],
		GL_FLOAT,
		CEmpty,
		0,
		glm::vec3[3],
		GL_FLOAT
		> VBO("VertexPosition", "", "VertexColor");
	
	VBO.Position[0].x = -0.5f;
	VBO.Position[0].y = -0.5f;
	VBO.Position[0].z = 0.5f;
ecc.....
il primo parametro è il Creator , ce ne possono essere vari e l'ho pensato in un futuro in cui volessi cambiare o implementare per es la versione directx ,il secondo è il numero di elementi
il terzo il tipo di elemento(glm è una libreria matematica studiata per opengl, in questo caso uso un array di tre vettori float.
il 4 è il tipo del elemento base per opengl. passo il problema e non mi dilungo: in questo caso
devo per forza sapere in anticipo il numero di elementi che avra' quel vertex buffer e mi piacerebbe aggiungere quanti voglio elementi senza starli a contare e fare si che sia il c++ a calcolare il tutto.

per questo ho pensato ad un mio personale buffer tipo questobasandomi su di un vector(pseudocodice)
codice:
#pragma once
#include <vector>
template< class T >
class CSizeVaringData
{
public:
	CSizeVaringData();
	~CSizeVaringData();
	std::vector<T> m_data;
	typedef T Type;
	void AddData(T element)
	{
		m_data.push_back(element);
	}
	
	T* getAllData(){
		return m_data[];
	}
	
};
in modo da fare cosi:
codice:
CVboManager<
		CVboCreator	,
		3,
		CSizeVaringData<glm::vec3>,
		GL_FLOAT,
		CEmpty,
		0,
		glm::vec3[3],
		GL_FLOAT
		> VBO("VertexPosition", "", "VertexColor");
il problema è che devo mantenere la compatibilità con i precedenti parametri.

e devo usare l'overloading per gestire diversamente il cariccamento nel creator del buffer
codice:
Creator:
	template<class Data>
	bool Create(GLuint& vertexArrayObject, GLuint& vertexBufferObject, std::string strSemantic, ptrBaseEffect ptrEff, GLenum type, Data* VBOData)
	{
		glGenBuffers(1, &vertexBufferObject);
		glBindBuffer(GL_ARRAY_BUFFER, vertexBufferObject);
		glBufferData(GL_ARRAY_BUFFER, sizeof(*VBOData), glm::value_ptr(*VBOData[0]), GL_STATIC_DRAW);
		glVertexAttribPointer(glGetAttribLocation(ptrEff->m_headerShader, strSemantic.c_str()), 3, GL_FLOAT, GL_FALSE, sizeof(*VBOData[0]), (void*)0/*nOffset*/);
		glEnableVertexAttribArray(glGetAttribLocation(ptrEff->m_headerShader, strSemantic.c_str()));
		float* pF = glm::value_ptr(*VBOData[0]);
		return true;
	}
	template<class Data>
	bool Create(GLuint& vertexArrayObject, GLuint& vertexBufferObject, std::string strSemantic, ptrBaseEffect ptrEff, GLenum type, CEmpty* VBOData)
	{
		return true;
	}
	template<class Data>
	bool Create(GLuint& vertexArrayObject, GLuint& vertexBufferObject, std::string strSemantic, ptrBaseEffect ptrEff, GLenum type, CSizeVaringData<glm::vec3>* VBOData)
	{
	}

//il problema è attorno a questa funzione in overload:
//bool Create(GLuint& vertexArrayObject, GLuint& vertexBufferObject, std::string strSemantic, ptrBaseEffect ptrEff, GLenum type, CSizeVaringData<glm::vec3>* VBOData)
//{
//}
il problema è questo:
CSizeVaringData<glm::vec3>* VBOData
se uso un overloading cosi va, ma io non so che tipo ho specificato nel template CVboManager potrei aver specificato un int3 ,
e devo specificare per forza un tipo nel parametro con CSizeVaringData.
quello che posso fare è utilizzare due parametri template , uno per il contenitore e uno per il tipo contenuto nel contenitore.
poi gestire in overloading i diversi contenitori , quando ce ne ho 2 o 3 è abbastanza per quello che devo fare .
non vedo altra soluzione.
è possibile utilizzare i template template parameter ? come si usano? possono tornare utili in questo caso
io non ci sono riuscito.
grazie.