ZFX + Developia

Code: Alles auswählen

layout(location = 0) in vec4 aPosition;
layout(location = 1) in vec3 aNormal;
...

Code: Alles auswählen

#include "InstancedModel.hpp"

#include <assimp/Importer.hpp>
#include <assimp/PostProcess.h>
#include <assimp/scene.h>

#include <GL/glew.h>

using namespace std;
using namespace glm;

InstancedModel::InstancedModel(string ModelFile, string VertexFile, string FragmentFile)
{
	Assimp::Importer Importer;
	const aiScene* Scene=Importer.ReadFile(ModelFile,
		                                    aiProcess_Triangulate | aiProcess_CalcTangentSpace | aiProcess_RemoveRedundantMaterials |
		                                    aiProcess_OptimizeGraph | aiProcess_OptimizeMeshes | aiProcess_LimitBoneWeights);
	auto Mesh=Scene->mMeshes[0];

	//Positions
	m_PositionData.resize(Mesh->mNumVertices);
	memcpy(m_PositionData.data(), Mesh->mVertices, m_PositionData.size()*sizeof(vec3));

	//Uvs
	m_UvData.resize(Mesh->mNumVertices);
	memcpy(m_UvData.data(), Mesh->mTextureCoords[0], m_UvData.size()*sizeof(vec2));

	//Indices
	m_IndexData.resize(Mesh->mNumFaces*3);
	for(unsigned int i=0; i<Mesh->mNumFaces; ++i)
	{
		if(Mesh->mFaces[i].mNumIndices<3)
			continue; //skip points and lines
		
		//copy the indices of 1 triangle
		m_IndexData[i*3+0]=Mesh->mFaces[i].mIndices[0];
		m_IndexData[i*3+1]=Mesh->mFaces[i].mIndices[1];
		m_IndexData[i*3+2]=Mesh->mFaces[i].mIndices[2];
	}

	//and some fancy positions:
	for(auto i=0u; i<10; ++i)
	{
		m_InstancedPositionData.push_back(vec3(0, 0, i*10));
	}


	//Position Buffer:
	unsigned int PositionBuffer;
	glGenBuffers(1, &PositionBuffer);
	glBindBuffer(GL_ARRAY_BUFFER, PositionBuffer);
	glBufferData(GL_ARRAY_BUFFER, sizeof(vec3)*m_PositionData.size(), m_PositionData.data(), GL_STATIC_DRAW);

	//Uv Buffer:
	unsigned int UvBuffer;
	glGenBuffers(1, &UvBuffer);
	glBindBuffer(GL_ARRAY_BUFFER, UvBuffer);
	glBufferData(GL_ARRAY_BUFFER, sizeof(vec2)*m_UvData.size(), m_UvData.data(), GL_STATIC_DRAW);

	//Index Buffer
	unsigned int IndexBuffer;
	glGenBuffers(1, &IndexBuffer);
	glBindBuffer(GL_ARRAY_BUFFER, IndexBuffer);
	glBufferData(GL_ARRAY_BUFFER, sizeof(unsigned int)*m_IndexData.size(), m_IndexData.data(), GL_STATIC_DRAW);

	//Instanced Positions:
	unsigned int InstancedPositionBuffer;
	glGenBuffers(1, &InstancedPositionBuffer);
	glBindBuffer(GL_ARRAY_BUFFER, InstancedPositionBuffer);
	glBufferData(GL_ARRAY_BUFFER, sizeof(vec3)*m_InstancedPositionData.size(), m_InstancedPositionData.data(), GL_STATIC_DRAW);

	//The Shader
	m_Shader.Load(VertexFile, FragmentFile);
	auto PositionLocation=glGetAttribLocation(m_Shader.GetProgram(), "attPosition");
	auto UvLocation=glGetAttribLocation(m_Shader.GetProgram(), "attUv");
	auto InstPosLocation=glGetAttribLocation(m_Shader.GetProgram(), "instPosition");


	//The Vertex Array Object
	glGenVertexArrays(1, &m_VertexArrayObject);
	glBindVertexArray(m_VertexArrayObject);
	
	//Positions
	glBindBuffer(GL_ARRAY_BUFFER, PositionBuffer);
	glVertexAttribPointer(PositionLocation, 3,	GL_FLOAT, GL_FALSE, 0, nullptr);
	glEnableVertexAttribArray(PositionLocation);
	
	//Uv
	glBindBuffer(GL_ARRAY_BUFFER, UvBuffer);
	glVertexAttribPointer(UvLocation, 2,	GL_FLOAT, GL_FALSE, 0, nullptr);
	glEnableVertexAttribArray(UvLocation);

	//Instanced Positions
	glBindBuffer(GL_ARRAY_BUFFER, InstancedPositionBuffer);
	glVertexAttribPointer(InstPosLocation, 3,	GL_FLOAT, GL_FALSE, 0, nullptr);
	glEnableVertexAttribArray(InstPosLocation);
	glVertexAttribDivisor(InstPosLocation, 1);


	//Indicies
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IndexBuffer);

	glBindVertexArray(0);
}

InstancedModel::~InstancedModel()
{
	glDeleteVertexArrays(1, &m_VertexArrayObject);

	//well, delete buffers
}


void InstancedModel::Render()
{
	m_Shader.Set();
	glBindVertexArray(m_VertexArrayObject);
	//glDrawArrays(GL_TRIANGLES, 0, m_IndexData.size()/3);
	//glDrawElements(GL_TRIANGLES, m_IndexData.size()/3, GL_UNSIGNED_INT, nullptr);
	glDrawElementsInstanced(GL_TRIANGLES, m_IndexData.size()/3, GL_UNSIGNED_INT, nullptr, 10);
	glBindVertexArray(0);
	m_Shader.Unset();
}