701 lines
19 KiB
C++
701 lines
19 KiB
C++
#include <string.h> // strlen
|
|
#include <locale.h>
|
|
|
|
#include <iostream>
|
|
#include <fstream>
|
|
|
|
#include "RenderModule.h"
|
|
#include "RenderUtils.h"
|
|
#include "Globals.h"
|
|
#include "FileModificationObserver.h"
|
|
|
|
#include "imgui/imgui.h"
|
|
#include "imgui_dock.h"
|
|
|
|
using namespace SimpleMath;
|
|
using namespace SimpleMath::GL;
|
|
|
|
//
|
|
// Camera
|
|
//
|
|
void Camera::UpdateMatrices() {
|
|
mViewMatrix = LookAt(mEye, mPoi, mUp);
|
|
|
|
if (mIsOrthographic) {
|
|
float width = mWidth * 0.5f * (mFar - mNear * 0.5f) * 0.001f;
|
|
float height = width * mHeight / mWidth;
|
|
|
|
mProjectionMatrix = Ortho(-width * 0.5f, width * 0.5f, -height * 0.5f, height * 0.5f, mNear, mFar);
|
|
} else {
|
|
mProjectionMatrix = Perspective(mFov, mWidth / mHeight, mNear, mFar);
|
|
}
|
|
}
|
|
|
|
void Camera::DrawGui() {
|
|
ImGui::Text("Width %3.4f, Height %3.4f", mWidth, mHeight);
|
|
|
|
ImGui::InputFloat3("Eye", mEye.data(), -10.0f, 10.0f);
|
|
ImGui::SliderFloat3("EyeS", mEye.data(), -10.0f, 10.0f);
|
|
|
|
ImGui::InputFloat3("Poi", mPoi.data(), -10.0f, 10.0f);
|
|
ImGui::InputFloat3("Up", mUp.data(), -10.0f, 10.0f);
|
|
ImGui::Checkbox("Orthographic", &mIsOrthographic);
|
|
ImGui::SliderFloat("Fov", &mFov, 5, 160);
|
|
ImGui::SliderFloat("Near", &mNear, -10, 10);
|
|
ImGui::SliderFloat("Far", &mFar, -20, 50);
|
|
if (ImGui::Button("Reset")) {
|
|
*this = Camera();
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// RenderProgram
|
|
//
|
|
|
|
RenderProgram::~RenderProgram() {
|
|
if (mProgramId != -1)
|
|
glDeleteProgram(mProgramId);
|
|
}
|
|
|
|
|
|
GLuint RenderProgram::CompileVertexShader() {
|
|
// Create the shaders
|
|
GLuint VertexShaderID = glCreateShader(GL_VERTEX_SHADER);
|
|
|
|
// Read the Vertex Shader code from the file
|
|
std::string VertexShaderCode;
|
|
std::ifstream VertexShaderStream(mVertexShaderFilename.c_str(), std::ios::in);
|
|
if(VertexShaderStream.is_open()){
|
|
std::stringstream sstr;
|
|
sstr << VertexShaderStream.rdbuf();
|
|
VertexShaderCode = sstr.str();
|
|
VertexShaderStream.close();
|
|
}else{
|
|
gLog("Impossible to open %s. Are you in the right directory ? Don't forget to read the FAQ !", mVertexShaderFilename.c_str());
|
|
getchar();
|
|
return -1;
|
|
}
|
|
|
|
GLint Result = GL_FALSE;
|
|
int InfoLogLength;
|
|
|
|
// Compile Vertex Shader
|
|
gLog("Compiling shader : %s", mVertexShaderFilename.c_str());
|
|
char const * VertexSourcePointer = VertexShaderCode.c_str();
|
|
glShaderSource(VertexShaderID, 1, &VertexSourcePointer , NULL);
|
|
glCompileShader(VertexShaderID);
|
|
|
|
// Check Vertex Shader
|
|
glGetShaderiv(VertexShaderID, GL_COMPILE_STATUS, &Result);
|
|
glGetShaderiv(VertexShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength);
|
|
if ( InfoLogLength > 0 ){
|
|
std::vector<char> VertexShaderErrorMessage(InfoLogLength+1);
|
|
glGetShaderInfoLog(VertexShaderID, InfoLogLength, NULL, &VertexShaderErrorMessage[0]);
|
|
gLog("%s", &VertexShaderErrorMessage[0]);
|
|
|
|
return -1;
|
|
}
|
|
|
|
return VertexShaderID;
|
|
}
|
|
|
|
GLuint RenderProgram::CompileFragmentShader() {
|
|
GLuint FragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);
|
|
|
|
// Read the Fragment Shader code from the file
|
|
std::string FragmentShaderCode;
|
|
std::ifstream FragmentShaderStream(mFragmentShaderFilename.c_str(), std::ios::in);
|
|
if(FragmentShaderStream.is_open()){
|
|
std::stringstream sstr;
|
|
sstr << FragmentShaderStream.rdbuf();
|
|
FragmentShaderCode = sstr.str();
|
|
FragmentShaderStream.close();
|
|
}
|
|
|
|
GLint Result = GL_FALSE;
|
|
int InfoLogLength;
|
|
|
|
// Compile Fragment Shader
|
|
gLog("Compiling shader : %s", mFragmentShaderFilename.c_str());
|
|
char const * FragmentSourcePointer = FragmentShaderCode.c_str();
|
|
glShaderSource(FragmentShaderID, 1, &FragmentSourcePointer , NULL);
|
|
glCompileShader(FragmentShaderID);
|
|
|
|
// Check Fragment Shader
|
|
glGetShaderiv(FragmentShaderID, GL_COMPILE_STATUS, &Result);
|
|
glGetShaderiv(FragmentShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength);
|
|
if ( InfoLogLength > 0 ){
|
|
std::vector<char> FragmentShaderErrorMessage(InfoLogLength+1);
|
|
glGetShaderInfoLog(FragmentShaderID, InfoLogLength, NULL, &FragmentShaderErrorMessage[0]);
|
|
gLog("%s", &FragmentShaderErrorMessage[0]);
|
|
|
|
return -1;
|
|
}
|
|
|
|
return FragmentShaderID;
|
|
}
|
|
|
|
GLuint RenderProgram::LinkProgram(GLuint vertex_shader, GLuint fragment_shader) {
|
|
// Link the program
|
|
gLog("Linking program");
|
|
GLuint ProgramID = glCreateProgram();
|
|
glAttachShader(ProgramID, vertex_shader);
|
|
glAttachShader(ProgramID, fragment_shader);
|
|
|
|
// Bind attribute locations
|
|
glBindAttribLocation(ProgramID, 0, "inCoord");
|
|
glBindAttribLocation(ProgramID, 1, "inNormal");
|
|
glBindAttribLocation(ProgramID, 2, "inUV");
|
|
glBindAttribLocation(ProgramID, 3, "inColor");
|
|
|
|
glLinkProgram(ProgramID);
|
|
|
|
GLint Result = GL_FALSE;
|
|
int InfoLogLength;
|
|
|
|
// Check the program
|
|
glGetProgramiv(ProgramID, GL_LINK_STATUS, &Result);
|
|
glGetProgramiv(ProgramID, GL_INFO_LOG_LENGTH, &InfoLogLength);
|
|
if ( InfoLogLength > 0 ){
|
|
std::vector<char> ProgramErrorMessage(InfoLogLength+1);
|
|
glGetProgramInfoLog(ProgramID, InfoLogLength, NULL, &ProgramErrorMessage[0]);
|
|
gLog("%s", &ProgramErrorMessage[0]);
|
|
}
|
|
|
|
return ProgramID;
|
|
}
|
|
|
|
bool RenderProgram::Load() {
|
|
GLuint vertex_shader_id = CompileVertexShader();
|
|
if (vertex_shader_id == -1) {
|
|
return false;
|
|
}
|
|
|
|
GLuint fragment_shader_id = CompileFragmentShader();
|
|
if (fragment_shader_id == -1) {
|
|
glDeleteShader(vertex_shader_id);
|
|
return false;
|
|
}
|
|
|
|
mProgramId = LinkProgram(vertex_shader_id, fragment_shader_id);
|
|
if (mProgramId == -1) {
|
|
glDeleteShader(vertex_shader_id);
|
|
glDeleteShader(fragment_shader_id);
|
|
|
|
return false;
|
|
}
|
|
|
|
glDetachShader(mProgramId, vertex_shader_id);
|
|
glDetachShader(mProgramId, fragment_shader_id);
|
|
|
|
glDeleteShader(vertex_shader_id);
|
|
glDeleteShader(fragment_shader_id);
|
|
|
|
return true;
|
|
}
|
|
|
|
GLuint RenderProgram::GetUniformLocation(const std::string& name) {
|
|
if (mProgramId == -1) {
|
|
gLog("Cannot get uniform '%s' for program '%s' and '%s': shader not valid.",
|
|
name.c_str(),
|
|
mVertexShaderFilename.c_str(),
|
|
mFragmentShaderFilename.c_str()
|
|
);
|
|
assert(mProgramId != -1);
|
|
}
|
|
GLuint result = glGetUniformLocation(mProgramId, name.c_str());
|
|
if (result == -1) {
|
|
gLog ("Error loading uniform '%s' from shaders '%s' and '%s': uniform not found.",
|
|
name.c_str(),
|
|
mVertexShaderFilename.c_str(),
|
|
mFragmentShaderFilename.c_str()
|
|
);
|
|
assert(false);
|
|
} else {
|
|
gLog ("Uniform '%s': %d", name.c_str(), result);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void RenderProgram::RegisterFileModification() {
|
|
gFileModificationObserver->AddListener(mVertexShaderFilename, this);
|
|
gFileModificationObserver->AddListener(mFragmentShaderFilename, this);
|
|
}
|
|
|
|
bool RenderProgram::OnFileChanged(const std::string& filename) {
|
|
gLog("Renderprogram reload as file %s changed", filename.c_str());
|
|
|
|
GLuint vertex_shader_id = CompileVertexShader();
|
|
if (vertex_shader_id == -1) {
|
|
gLog ("Reload failed: error when compiling vertex shader");
|
|
return true;
|
|
}
|
|
|
|
GLuint fragment_shader_id = CompileFragmentShader();
|
|
if (fragment_shader_id == -1) {
|
|
glDeleteShader(vertex_shader_id);
|
|
gLog ("Reload failed: error when compiling fragment shader");
|
|
return false;
|
|
}
|
|
|
|
mProgramId = LinkProgram(vertex_shader_id, fragment_shader_id);
|
|
if (mProgramId == -1) {
|
|
glDeleteShader(vertex_shader_id);
|
|
glDeleteShader(fragment_shader_id);
|
|
|
|
gLog ("Reload failed: error when linking the program");
|
|
|
|
return false;
|
|
}
|
|
|
|
glDetachShader(mProgramId, vertex_shader_id);
|
|
glDetachShader(mProgramId, fragment_shader_id);
|
|
|
|
glDeleteShader(vertex_shader_id);
|
|
glDeleteShader(fragment_shader_id);
|
|
|
|
gLog ("Reload successful");
|
|
|
|
return true;
|
|
}
|
|
|
|
//
|
|
// RenderTarget
|
|
//
|
|
RenderTarget::~RenderTarget() {
|
|
Cleanup();
|
|
}
|
|
|
|
void RenderTarget::Initialize(int width, int height, int flags) {
|
|
Cleanup();
|
|
|
|
mFlags = flags;
|
|
|
|
Resize(width, height);
|
|
}
|
|
|
|
void RenderTarget::Bind() {
|
|
assert(glIsFramebuffer(mFrameBufferId));
|
|
glBindFramebuffer(GL_FRAMEBUFFER, mFrameBufferId);
|
|
GLenum shadow_map_draw_buffers[] = { GL_COLOR_ATTACHMENT0 };
|
|
glDrawBuffers(1, shadow_map_draw_buffers);
|
|
}
|
|
|
|
void RenderTarget::Cleanup() {
|
|
if (mFrameBufferId != -1) {
|
|
glDeleteFramebuffers(1, &mFrameBufferId);
|
|
mFrameBufferId = -1;
|
|
}
|
|
|
|
if (mColorTexture != -1) {
|
|
glDeleteTextures(1, &mColorTexture);
|
|
mColorTexture = -1;
|
|
}
|
|
|
|
if (mDepthTexture!= -1) {
|
|
glDeleteTextures(1, &mDepthTexture);
|
|
mDepthTexture = -1;
|
|
}
|
|
|
|
if (mDepthBuffer != -1) {
|
|
glDeleteRenderbuffers(1, &mDepthBuffer);
|
|
mDepthBuffer = -1;
|
|
}
|
|
|
|
if (mLinearizedDepthTexture != -1) {
|
|
glDeleteTextures(1, &mLinearizedDepthTexture);
|
|
mLinearizedDepthTexture = -1;
|
|
}
|
|
|
|
mWidth = -1;
|
|
mHeight = -1;
|
|
}
|
|
|
|
void RenderTarget::Resize(int width, int height) {
|
|
if (width == mWidth && height == mHeight)
|
|
return;
|
|
|
|
Cleanup();
|
|
|
|
gLog("Resizing RenderTarget to %d,%d", width, height);
|
|
|
|
mWidth = width;
|
|
mHeight = height;
|
|
|
|
glGenFramebuffers(1, &mFrameBufferId);
|
|
glBindFramebuffer(GL_FRAMEBUFFER, mFrameBufferId);
|
|
|
|
if (mFlags & EnableColor) {
|
|
glGenTextures(1, &mColorTexture);
|
|
glBindTexture(GL_TEXTURE_2D, mColorTexture);
|
|
|
|
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, mWidth, mHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
|
|
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
|
|
|
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mColorTexture, 0);
|
|
}
|
|
|
|
if (mFlags & EnableDepthTexture) {
|
|
assert((mFlags & EnableDepth) == false);
|
|
|
|
glGenTextures(1, &mDepthTexture);
|
|
glBindTexture(GL_TEXTURE_2D, mDepthTexture);
|
|
|
|
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, mWidth, mHeight, 0, GL_DEPTH_COMPONENT, GL_FLOAT, 0);
|
|
|
|
// Set parameters so that we can set a shadow2DSampler
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
|
|
float border_color[] = { 1.0f, 1.0f, 1.0f, 1.0f };
|
|
glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, border_color);
|
|
|
|
|
|
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, mDepthTexture, 0);
|
|
|
|
if (mFlags & EnableLinearizedDepthTexture) {
|
|
glGenTextures(1, &mLinearizedDepthTexture);
|
|
glBindTexture(GL_TEXTURE_2D, mLinearizedDepthTexture);
|
|
|
|
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, mWidth, mHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
|
|
|
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_2D, mLinearizedDepthTexture, 0);
|
|
}
|
|
} else if (mFlags & EnableDepth) {
|
|
assert((mFlags & EnableDepthTexture) == false);
|
|
glGenRenderbuffers(1, &mDepthBuffer);
|
|
glBindRenderbuffer(GL_RENDERBUFFER, mDepthBuffer);
|
|
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, mWidth, mHeight);
|
|
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, mDepthBuffer);
|
|
}
|
|
|
|
GLenum result = glCheckFramebufferStatus(GL_FRAMEBUFFER);
|
|
if (result != GL_FRAMEBUFFER_COMPLETE) {
|
|
switch (result) {
|
|
case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT: gLog("Error: GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT");
|
|
break;
|
|
case GL_FRAMEBUFFER_UNDEFINED: gLog("Error: GL_FRAMEBUFFER_UNDEFINED");
|
|
break;
|
|
case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: gLog("Error: GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT");
|
|
break;
|
|
default: gLog("Error when creating Framebuffer: %d", result);
|
|
}
|
|
}
|
|
|
|
assert(result == GL_FRAMEBUFFER_COMPLETE);
|
|
}
|
|
|
|
void RenderTarget::RenderToLinearizedDepth(const float& near, const float& far, bool is_orthographic) {
|
|
assert(mFlags & EnableLinearizedDepthTexture);
|
|
assert(mLinearizedDepthTexture != -1);
|
|
assert(mVertexArray != nullptr);
|
|
assert(mQuadMesh != nullptr);
|
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, mFrameBufferId);
|
|
GLenum draw_attachment_1[] = { GL_COLOR_ATTACHMENT1 };
|
|
glDrawBuffers(1, draw_attachment_1);
|
|
|
|
glClear(GL_COLOR_BUFFER_BIT);
|
|
glDisable(GL_DEPTH_TEST);
|
|
|
|
glActiveTexture(GL_TEXTURE0);
|
|
glBindTexture(GL_TEXTURE_2D, mDepthTexture);
|
|
|
|
// render depth texture
|
|
glUseProgram(mLinearizeDepthProgram.mProgramId);
|
|
mLinearizeDepthProgram.SetFloat("uNear", near);
|
|
mLinearizeDepthProgram.SetFloat("uFar", far);
|
|
mLinearizeDepthProgram.SetFloat("uIsOrthographic", is_orthographic ? 1.0f : 0.0f);
|
|
mLinearizeDepthProgram.SetInt("uDepthTexture", 0);
|
|
|
|
mVertexArray->Bind();
|
|
mQuadMesh->Draw(GL_TRIANGLES);
|
|
|
|
if (mFlags & EnableColor) {
|
|
GLenum draw_attachment_0[] = { GL_COLOR_ATTACHMENT1 };
|
|
glDrawBuffers(1, draw_attachment_0);
|
|
glEnable(GL_DEPTH_TEST);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Texture
|
|
//
|
|
|
|
Texture::~Texture() {
|
|
if (mTextureId != -1) {
|
|
glDeleteTextures(1, &mTextureId);
|
|
mTextureId = -1;
|
|
}
|
|
}
|
|
|
|
void Texture::MakeGrid(const int& size, const Vector3f &c1, const Vector3f &c2) {
|
|
mWidth = size;
|
|
mHeight = size;
|
|
|
|
unsigned char buffer[size * size * 3];
|
|
int size_half = size / 2;
|
|
|
|
for (int i = 0; i < size_half; ++i) {
|
|
for (int j = 0; j < size_half; ++j) {
|
|
buffer[(i * size * 3) + (j * 3) + 0] = static_cast<unsigned char>(c1[0] * 255.0f);
|
|
buffer[(i * size * 3) + (j * 3) + 1] = static_cast<unsigned char>(c1[1] * 255.0f);
|
|
buffer[(i * size * 3) + (j * 3) + 2] = static_cast<unsigned char>(c1[2] * 255.0f);
|
|
}
|
|
}
|
|
|
|
for (int i = size_half; i < size; ++i) {
|
|
for (int j = 0; j < size_half; ++j) {
|
|
buffer[(i * size * 3) + (j * 3) + 0] = static_cast<unsigned char>(c2[0] * 255.0f);
|
|
buffer[(i * size * 3) + (j * 3) + 1] = static_cast<unsigned char>(c2[1] * 255.0f);
|
|
buffer[(i * size * 3) + (j * 3) + 2] = static_cast<unsigned char>(c2[2] * 255.0f);
|
|
}
|
|
}
|
|
|
|
for (int i = size_half; i < size; ++i) {
|
|
for (int j = size_half; j < size; ++j) {
|
|
buffer[(i * size * 3) + (j * 3) + 0] = static_cast<unsigned char>(c1[0] * 255.0f);
|
|
buffer[(i * size * 3) + (j * 3) + 1] = static_cast<unsigned char>(c1[1] * 255.0f);
|
|
buffer[(i * size * 3) + (j * 3) + 2] = static_cast<unsigned char>(c1[2] * 255.0f);
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < size_half; ++i) {
|
|
for (int j = size_half; j < size; ++j) {
|
|
buffer[(i * size * 3) + (j * 3) + 0] = static_cast<unsigned char>(c2[0] * 255.0f);
|
|
buffer[(i * size * 3) + (j * 3) + 1] = static_cast<unsigned char>(c2[1] * 255.0f);
|
|
buffer[(i * size * 3) + (j * 3) + 2] = static_cast<unsigned char>(c2[2] * 255.0f);
|
|
}
|
|
}
|
|
|
|
glGenTextures(1, &mTextureId);
|
|
glBindTexture(GL_TEXTURE_2D, mTextureId);
|
|
|
|
glTexImage2D(GL_TEXTURE_2D,
|
|
0, // level
|
|
GL_RGB, // internal format
|
|
size, // width
|
|
size, // height
|
|
0, // border (must be 0)
|
|
GL_RGB, // format of pixel data
|
|
GL_UNSIGNED_BYTE, // type of pixel data
|
|
buffer // pixel data
|
|
);
|
|
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
|
|
}
|
|
|
|
bool Texture::Load(const char* filename, int num_components) {
|
|
// unsigned char* rgb = stbi_load(filename, &mWidth, &mHeight, num_components);
|
|
assert(false);
|
|
}
|
|
|
|
VertexArray::~VertexArray() {
|
|
if (mVertexArrayId != -1) {
|
|
Cleanup();
|
|
}
|
|
}
|
|
|
|
void VertexArray::Initialize(const int& size, GLenum usage) {
|
|
mNumVertices = size;
|
|
mNumUsedVertices = 0;
|
|
|
|
glGenVertexArrays (1, &mVertexArrayId);
|
|
glBindVertexArray(mVertexArrayId);
|
|
|
|
glGenBuffers(1, &mVertexBuffer);
|
|
glBindBuffer(GL_ARRAY_BUFFER, mVertexBuffer);
|
|
glBufferData(GL_ARRAY_BUFFER, sizeof(VertexData) * mNumVertices, NULL, usage);
|
|
}
|
|
|
|
void VertexArray::Cleanup() {
|
|
glDeleteBuffers(1, &mVertexBuffer);
|
|
mVertexBuffer = -1;
|
|
glDeleteVertexArrays(1, &mVertexArrayId);
|
|
mVertexArrayId = -1;
|
|
|
|
mNumVertices = -1;
|
|
mNumUsedVertices = -1;
|
|
}
|
|
|
|
GLuint VertexArray::AllocateMesh(const int& size) {
|
|
if (mNumUsedVertices + size > mNumVertices) {
|
|
gLog("Cannot allocate mesh in VertexArray: not enough vertices available");
|
|
assert(false);
|
|
return -1;
|
|
}
|
|
|
|
GLuint offset = mNumUsedVertices;
|
|
mNumUsedVertices += size;
|
|
return offset;
|
|
}
|
|
|
|
void VertexArray::Bind() {
|
|
glBindBuffer(GL_ARRAY_BUFFER, mVertexBuffer);
|
|
|
|
// Attribute 0: coords
|
|
glEnableVertexAttribArray(0);
|
|
glVertexAttribPointer(
|
|
0,
|
|
4,
|
|
GL_FLOAT,
|
|
GL_FALSE,
|
|
(sizeof(VertexData)),
|
|
(void*)0
|
|
);
|
|
// Attribute 1: normals
|
|
glEnableVertexAttribArray(1);
|
|
glVertexAttribPointer(
|
|
1,
|
|
3,
|
|
GL_FLOAT,
|
|
GL_FALSE,
|
|
(sizeof(VertexData)),
|
|
(void*)(sizeof(float) * 4)
|
|
);
|
|
// Attribute 2: texture coordinates
|
|
glEnableVertexAttribArray(2);
|
|
glVertexAttribPointer(
|
|
2,
|
|
2,
|
|
GL_FLOAT,
|
|
GL_FALSE,
|
|
(sizeof(VertexData)),
|
|
(void*)(sizeof(float) * 7)
|
|
);
|
|
// Attribute 1: color
|
|
glEnableVertexAttribArray(3);
|
|
glVertexAttribPointer(
|
|
3,
|
|
4,
|
|
GL_UNSIGNED_BYTE,
|
|
GL_TRUE,
|
|
(sizeof(VertexData)),
|
|
(void*)(sizeof(float) * 9)
|
|
);
|
|
}
|
|
|
|
bool VertexArray::IsBound() {
|
|
GLint bound_vertex_buffer = -1;
|
|
glGetIntegerv (GL_ARRAY_BUFFER_BINDING, &bound_vertex_buffer);
|
|
return bound_vertex_buffer == mVertexBuffer;
|
|
}
|
|
|
|
void VertexArrayMesh::Initialize(VertexArray &array, const int& size) {
|
|
mVertexArray = &array;
|
|
mIndexOffset = mVertexArray->AllocateMesh(size);
|
|
mOffsetPtr = (void*) (sizeof(VertexArray::VertexData) * mIndexOffset);
|
|
}
|
|
|
|
void VertexArrayMesh::SetData(
|
|
const VertexArray::VertexData* data,
|
|
const int& count
|
|
) {
|
|
// upload the data
|
|
mVertexCount = count;
|
|
glBindBuffer(GL_ARRAY_BUFFER, mVertexArray->mVertexBuffer);
|
|
|
|
glBufferSubData(
|
|
GL_ARRAY_BUFFER,
|
|
(GLintptr) mOffsetPtr,
|
|
sizeof(VertexArray::VertexData) * count,
|
|
data
|
|
);
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER, 0);
|
|
}
|
|
|
|
void VertexArrayMesh::SetData(
|
|
const std::vector<Vector4f> &coords,
|
|
const std::vector<Vector3f> &normals,
|
|
const std::vector<Vector2f> &uvs,
|
|
const std::vector<Vector4f> &colors,
|
|
const std::vector<GLuint> &indices
|
|
) {
|
|
assert(mOffsetPtr != (void*) -1);
|
|
|
|
int vertex_count = coords.size();
|
|
assert(vertex_count > 0);
|
|
|
|
bool have_normals = normals.size() > 0;
|
|
bool have_uvs = uvs.size() > 0;
|
|
bool have_colors = colors.size() > 0;
|
|
|
|
assert(!have_normals || (normals.size() == vertex_count));
|
|
assert(!have_uvs || (uvs.size() == vertex_count));
|
|
assert(!have_colors || (colors.size() == vertex_count));
|
|
|
|
std::vector<VertexArray::VertexData> vertex_data(vertex_count, VertexArray::VertexData());
|
|
|
|
for (int i = 0, n = vertex_count; i < n; ++i) {
|
|
memcpy (vertex_data[i].mCoords, coords[i].data(), sizeof(float) * 4);
|
|
|
|
if (have_normals) {
|
|
memcpy (vertex_data[i].mNormals, normals[i].data(), sizeof(float) * 3);
|
|
} else {
|
|
memset (vertex_data[i].mNormals, 0, sizeof(float) * 3);
|
|
}
|
|
|
|
if (have_uvs) {
|
|
memcpy (vertex_data[i].mTexCoords, uvs[i].data(), sizeof(float) * 2);
|
|
} else {
|
|
memset (vertex_data[i].mTexCoords, 0, sizeof(float) * 2);
|
|
}
|
|
|
|
if (have_colors) {
|
|
for (int j = 0; j < 4; ++j) {
|
|
vertex_data[i].mColor[j] = GLubyte(colors[i][j] * 255.0f);
|
|
}
|
|
} else {
|
|
memset (vertex_data[i].mColor, 0, sizeof(float) * 4);
|
|
}
|
|
}
|
|
|
|
SetData(
|
|
vertex_data.data(),
|
|
vertex_count
|
|
);
|
|
}
|
|
|
|
void VertexArrayMesh::SetIndexData(const GLuint* indices, const int& count) {
|
|
assert(mIndexBuffer == -1);
|
|
|
|
// copy the indices and increase the indices by mIndexOffset
|
|
GLuint temp_buffer[count];
|
|
memcpy (temp_buffer, indices, sizeof(GLuint) * count);
|
|
for (int i = 0; i < count; ++i) {
|
|
temp_buffer[i] += mIndexOffset;
|
|
}
|
|
|
|
mIndexCount = count;
|
|
|
|
glGenBuffers(1, &mIndexBuffer);
|
|
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mIndexBuffer);
|
|
glBufferData(GL_ELEMENT_ARRAY_BUFFER, count * sizeof(GLuint), temp_buffer, GL_STATIC_DRAW);
|
|
}
|
|
|
|
void VertexArrayMesh::Draw(GLenum mode) {
|
|
assert(mVertexArray->IsBound());
|
|
|
|
if (mIndexBuffer == -1) {
|
|
glDrawArrays(mode, mIndexOffset, mVertexCount);
|
|
} else {
|
|
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mIndexBuffer);
|
|
glDrawElements(mode, mIndexCount, GL_UNSIGNED_INT, (void*) 0);
|
|
}
|
|
|
|
}
|