void DrawableManager::initRenderTypes() {
/*
* precalls
*/
auto doubleBufferPreCall = [](gl::Program & prog, const DrawableType & drawType, const core::Camera & cam){
prog.use();
#ifdef LEGACY_MODE
const auto modelIndex = glGetUniformBlockIndex(static_cast<GLuint>(prog), "ModelMatrixBuffer");
glUniformBlockBinding(static_cast<GLuint>(prog), modelIndex, k_modelBufferBinding);
glBindBufferBase(GL_UNIFORM_BUFFER, k_modelBufferBinding, drawType.modelBuffer);
const auto colorIndex = glGetUniformBlockIndex(static_cast<GLuint>(prog), "ColorBuffer");
glUniformBlockBinding(static_cast<GLuint>(prog), colorIndex, k_colorBufferBinding);
glBindBufferBase(GL_UNIFORM_BUFFER, k_colorBufferBinding, drawType.colorBuffer);
#else
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, k_modelBufferBinding, drawType.modelBuffer);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, k_colorBufferBinding, drawType.colorBuffer);
#endif
prog["ViewProj"] = cam.getProjMatrix() * cam.getViewMatrix();
prog["View"] = cam.getViewMatrix();
prog["lightDir"] = glm::vec3(1.f, 2.f, -3.f);
drawType.vao.bind();
};
auto tripleBufferPreCall = [](gl::Program & prog, const DrawableType & drawType, const core::Camera & cam){
prog.use();
#ifdef LEGACY_MODE
const auto modelIndex = glGetUniformBlockIndex(static_cast<GLuint>(prog), "ModelMatrixBuffer");
glUniformBlockBinding(static_cast<GLuint>(prog), modelIndex, k_modelBufferBinding);
glBindBufferBase(GL_UNIFORM_BUFFER, k_modelBufferBinding, drawType.modelBuffer);
const auto colorIndex = glGetUniformBlockIndex(static_cast<GLuint>(prog), "ColorBuffer");
glUniformBlockBinding(static_cast<GLuint>(prog), colorIndex, k_colorBufferBinding);
glBindBufferBase(GL_UNIFORM_BUFFER, k_colorBufferBinding, drawType.colorBuffer);
const auto miscIndex = glGetUniformBlockIndex(static_cast<GLuint>(prog), "MiscBuffer");
glUniformBlockBinding(static_cast<GLuint>(prog), miscIndex, k_miscBufferBinding);
glBindBufferBase(GL_UNIFORM_BUFFER, k_miscBufferBinding, drawType.miscBuffer);
#else
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, k_modelBufferBinding, drawType.modelBuffer);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, k_colorBufferBinding, drawType.colorBuffer);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, k_miscBufferBinding, drawType.miscBuffer);
#endif
prog["ViewProj"] = cam.getProjMatrix() * cam.getViewMatrix();
prog["View"] = cam.getViewMatrix();
prog["lightDir"] = glm::vec3(1.f, 2.f, -3.f);
drawType.vao.bind();
};
auto singleBufferPreCall = [](gl::Program & prog, const DrawableType & drawType, const core::Camera & cam){
prog.use();
#ifdef LEGACY_MODE
const auto modelIndex = glGetUniformBlockIndex(static_cast<GLuint>(prog), "ModelMatrixBuffer");
glUniformBlockBinding(static_cast<GLuint>(prog), modelIndex, k_modelBufferBinding);
glBindBufferBase(GL_UNIFORM_BUFFER, k_modelBufferBinding, drawType.modelBuffer);
#else
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, k_modelBufferBinding, drawType.modelBuffer);
#endif
prog["col"] = drawType.col;
prog["ViewProj"] = cam.getProjMatrix() * cam.getViewMatrix();
prog["View"] = cam.getViewMatrix();
prog["lightDir"] = glm::vec3(1.f, 2.f, -3.f);
drawType.vao.bind();
};
/*
* UNICOLORED QUAD
*/
const std::vector<GLubyte> quadIdx = {
3, 2, 0,
0, 1, 3
};
auto renderType = RenderTypeName::QUAD;
#ifdef LEGACY_MODE
gl::Shader quadVert(GL_VERTEX_SHADER);
quadVert.addSourceFromString("#version 330 core\n");
quadVert.addSourceFromString("const int NUM_MATRICES = " + std::to_string(m_maxNumObjects) + ";\n");
quadVert.addSourceFromFile("shader/geometries/quad_legacy.vert");
if (!quadVert.compileSource()) {
LOG_ERROR("could not compile vertex shader!");
}
gl::Shader frag("shader/lighting/direct_lighting_legacy.frag");
m_renderTypes[renderType].prog.attachShader(quadVert);
m_renderTypes[renderType].prog.attachShader(frag);
m_renderTypes[renderType].ibo.bind(GL_ARRAY_BUFFER);
m_renderTypes[renderType].ibo.createMutableStorage(static_cast<unsigned int>(quadIdx.size() * sizeof(GLubyte)),
GL_STATIC_DRAW, quadIdx.data());
m_renderTypes[renderType].ibo.unbind();
#else
gl::Shader quadVert("shader/geometries/quad.vert", "quad_instance_vert");
gl::Shader frag("shader/lighting/direct_lighting.frag");
m_renderTypes[renderType].prog.attachShader(quadVert);
m_renderTypes[renderType].prog.attachShader(frag);
m_renderTypes[renderType].ibo.createImmutableStorage(static_cast<unsigned int>(quadIdx.size() * sizeof(GLubyte)),
0, quadIdx.data());
#endif
// drawCall
m_renderTypes[renderType].drawCall = [](const GLsizei size){
glDrawElementsInstanced(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, 0, size);
};
// preCall
m_renderTypes[renderType].preCall = singleBufferPreCall;
/*
* MULTICOLORED QUAD
*/
renderType = RenderTypeName::MULTICOLOR_QUAD;
#ifdef LEGACY_MODE
gl::Shader multicolorQuadVert(GL_VERTEX_SHADER);
multicolorQuadVert.addSourceFromString("#version 330 core\n");
multicolorQuadVert.addSourceFromString("const int NUM_MATRICES = " + std::to_string(m_maxNumObjects) + ";\n");
multicolorQuadVert.addSourceFromFile("shader/geometries/multicolor_quad_legacy.vert");
if (!multicolorQuadVert.compileSource()) {
LOG_ERROR("could not compile vertex shader!");
}
m_renderTypes[renderType].prog.attachShader(multicolorQuadVert);
m_renderTypes[renderType].prog.attachShader(frag);
m_renderTypes[renderType].ibo.bind(GL_ARRAY_BUFFER);
m_renderTypes[renderType].ibo.createMutableStorage(
static_cast<unsigned int>(quadIdx.size() * sizeof(GLubyte)),
GL_STATIC_DRAW, quadIdx.data());
m_renderTypes[renderType].ibo.unbind();
#else
gl::Shader multicolorQuadVert("shader/geometries/multicolor_quad.vert", "multicolor_quad_vert");
m_renderTypes[renderType].prog.attachShader(multicolorQuadVert);
m_renderTypes[renderType].prog.attachShader(frag);
m_renderTypes[renderType].ibo.createImmutableStorage(static_cast<unsigned int>(quadIdx.size() * sizeof(GLubyte)),
0, quadIdx.data());
#endif
// drawCall
m_renderTypes[renderType].drawCall = [](const GLsizei size){
glDrawElementsInstanced(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, 0, size);
};
// preCall
m_renderTypes[renderType].preCall = doubleBufferPreCall;
/*
* UNICOLORED CUBE
*/
const std::vector<GLushort> cubeIdx = {
19, 18, 16,
16, 17, 19,
7, 3, 1,
1, 5, 7,
22, 23, 21,
21, 20, 22,
2, 6, 4,
4, 0, 2,
9, 8, 12,
12, 13, 9,
14, 15, 11,
11, 10, 14
};
renderType = RenderTypeName::CUBE;
#ifdef LEGACY_MODE
gl::Shader cubeVert(GL_VERTEX_SHADER);
cubeVert.addSourceFromString("#version 330 core\n");
cubeVert.addSourceFromString("const int NUM_MATRICES = " + std::to_string(m_maxNumObjects) + ";\n");
cubeVert.addSourceFromFile("shader/geometries/cube_legacy.vert");
if (!cubeVert.compileSource()) {
LOG_ERROR("could not compile vertex shader!");
}
m_renderTypes[renderType].prog.attachShader(cubeVert);
m_renderTypes[renderType].prog.attachShader(frag);
m_renderTypes[renderType].ibo.bind(GL_ARRAY_BUFFER);
m_renderTypes[renderType].ibo.createMutableStorage(
static_cast<unsigned int>(cubeIdx.size() * sizeof(GLushort)),
GL_STATIC_DRAW, cubeIdx.data());
m_renderTypes[renderType].ibo.unbind();
#else
gl::Shader cubeVert("shader/geometries/cube.vert", "cube_vert");
m_renderTypes[renderType].prog.attachShader(cubeVert);
m_renderTypes[renderType].prog.attachShader(frag);
m_renderTypes[renderType].ibo.createImmutableStorage(static_cast<unsigned int>(cubeIdx.size() * sizeof(GLushort)),
0, cubeIdx.data());
#endif
// drawCall
m_renderTypes[renderType].drawCall = [](const GLsizei size){
glDrawElementsInstanced(GL_TRIANGLES, 36, GL_UNSIGNED_SHORT, 0, size);
};
// preCall
m_renderTypes[renderType].preCall = singleBufferPreCall;
/*
* MULTICOLORED CUBE
*/
renderType = RenderTypeName::MULTICOLOR_CUBE;
#ifdef LEGACY_MODE
gl::Shader multicolorCubeVert(GL_VERTEX_SHADER);
multicolorCubeVert.addSourceFromString("#version 330 core\n");
multicolorCubeVert.addSourceFromString("const int NUM_MATRICES = " + std::to_string(m_maxNumObjects) + ";\n");
multicolorCubeVert.addSourceFromFile("shader/geometries/multicolor_cube_legacy.vert");
if (!multicolorCubeVert.compileSource()) {
LOG_ERROR("could not compile vertex shader!");
}
m_renderTypes[renderType].prog.attachShader(multicolorCubeVert);
m_renderTypes[renderType].prog.attachShader(frag);
m_renderTypes[renderType].ibo.bind(GL_ARRAY_BUFFER);
m_renderTypes[renderType].ibo.createMutableStorage(
static_cast<unsigned int>(cubeIdx.size() * sizeof(GLushort)),
GL_STATIC_DRAW, cubeIdx.data());
m_renderTypes[renderType].ibo.unbind();
#else
gl::Shader multicolorCubeVert("shader/geometries/multicolor_cube.vert", "multicolor_cube_vert");
m_renderTypes[renderType].prog.attachShader(multicolorCubeVert);
m_renderTypes[renderType].prog.attachShader(frag);
m_renderTypes[renderType].ibo.createImmutableStorage(static_cast<unsigned int>(cubeIdx.size() * sizeof(GLushort)),
0, cubeIdx.data());
#endif
// drawCall
m_renderTypes[renderType].drawCall = [](const GLsizei size){
glDrawElementsInstanced(GL_TRIANGLES, 36, GL_UNSIGNED_SHORT, 0, size);
};
// preCall
m_renderTypes[renderType].preCall = doubleBufferPreCall;
/*
* FAN
*/
std::vector<GLushort> fanIdx;
constexpr auto segments = 100u;
fanIdx.reserve(segments + 2);
for (auto i = 0u; i < segments + 2; ++i) {
fanIdx.emplace_back(i);
}
renderType = RenderTypeName::FAN;
#ifdef LEGACY_MODE
gl::Shader fanVert(GL_VERTEX_SHADER);
fanVert.addSourceFromString("#version 330 core\n");
fanVert.addSourceFromString("const int NUM_MATRICES = " + std::to_string(m_maxNumObjects) + ";\n");
fanVert.addSourceFromFile("shader/geometries/fan_legacy.vert");
if (!fanVert.compileSource()) {
LOG_ERROR("could not compile vertex shader!");
}
m_renderTypes[renderType].prog.attachShader(fanVert);
m_renderTypes[renderType].prog.attachShader(frag);
m_renderTypes[renderType].ibo.bind(GL_ARRAY_BUFFER);
m_renderTypes[renderType].ibo.createMutableStorage(
static_cast<unsigned int>(fanIdx.size() * sizeof(GLushort)),
GL_STATIC_DRAW, fanIdx.data());
m_renderTypes[renderType].ibo.unbind();
#else
gl::Shader fanVert("shader/geometries/fan.vert", "fan_vert");
m_renderTypes[renderType].prog.attachShader(fanVert);
m_renderTypes[renderType].prog.attachShader(frag);
m_renderTypes[renderType].ibo.createImmutableStorage(static_cast<unsigned int>(fanIdx.size() * sizeof(GLushort)),
0, fanIdx.data());
#endif
// drawCall
m_renderTypes[renderType].drawCall = [](const GLsizei size){
glDrawElementsInstanced(GL_TRIANGLE_FAN, segments + 2, GL_UNSIGNED_SHORT, 0, size);
};
// preCall
m_renderTypes[renderType].preCall = tripleBufferPreCall;
/*
* ANNULUS
*/
std::vector<GLushort> annulusIdx;
annulusIdx.reserve(2 * segments + 2);
for (auto i = 0u; i < 2 * segments + 2; ++i) {
annulusIdx.emplace_back(i);
}
renderType = RenderTypeName::ANNULUS;
#ifdef LEGACY_MODE
gl::Shader annulusVert(GL_VERTEX_SHADER);
annulusVert.addSourceFromString("#version 330 core\n");
annulusVert.addSourceFromString("const int NUM_MATRICES = " + std::to_string(m_maxNumObjects) + ";\n");
annulusVert.addSourceFromFile("shader/geometries/circlesegment_legacy.vert");
if (!annulusVert.compileSource()) {
LOG_ERROR("could not compile vertex shader!");
}
m_renderTypes[renderType].prog.attachShader(annulusVert);
m_renderTypes[renderType].prog.attachShader(frag);
m_renderTypes[renderType].ibo.bind(GL_ARRAY_BUFFER);
m_renderTypes[renderType].ibo.createMutableStorage(
static_cast<unsigned int>(annulusIdx.size() * sizeof(GLushort)),
GL_STATIC_DRAW, annulusIdx.data());
m_renderTypes[renderType].ibo.unbind();
#else
gl::Shader annulusVert("shader/geometries/circlesegment.vert", "circlesegment_vert");
m_renderTypes[renderType].prog.attachShader(annulusVert);
m_renderTypes[renderType].prog.attachShader(frag);
m_renderTypes[renderType].ibo.createImmutableStorage(static_cast<unsigned int>(annulusIdx.size() * sizeof(GLushort)),
0, annulusIdx.data());
#endif
// drawCall
m_renderTypes[renderType].drawCall = [](const GLsizei size){
glDrawElementsInstanced(GL_TRIANGLE_STRIP, 2 * segments + 2, GL_UNSIGNED_SHORT, 0, size);
};
// preCall
m_renderTypes[renderType].preCall = tripleBufferPreCall;
/*
* TRAPEZOID
*/
renderType = RenderTypeName::TRAPEZOID;
#ifdef LEGACY_MODE
gl::Shader trapezoidVert(GL_VERTEX_SHADER);
trapezoidVert.addSourceFromString("#version 330 core\n");
trapezoidVert.addSourceFromString("const int NUM_MATRICES = " + std::to_string(m_maxNumObjects) + ";\n");
trapezoidVert.addSourceFromFile("shader/geometries/trapezoid_legacy.vert");
if (!trapezoidVert.compileSource()) {
LOG_ERROR("could not compile vertex shader!");
}
m_renderTypes[renderType].prog.attachShader(trapezoidVert);
m_renderTypes[renderType].prog.attachShader(frag);
m_renderTypes[renderType].ibo.bind(GL_ARRAY_BUFFER);
m_renderTypes[renderType].ibo.createMutableStorage(
static_cast<unsigned int>(quadIdx.size() * sizeof(GLubyte)),
GL_STATIC_DRAW, quadIdx.data());
m_renderTypes[renderType].ibo.unbind();
#else
gl::Shader trapezoidVert("shader/geometries/trapezoid.vert", "trapezoid_vert");
m_renderTypes[renderType].prog.attachShader(trapezoidVert);
m_renderTypes[renderType].prog.attachShader(frag);
m_renderTypes[renderType].ibo.createImmutableStorage(static_cast<unsigned int>(quadIdx.size() * sizeof(GLubyte)),
0, quadIdx.data());
#endif
// drawCall
m_renderTypes[renderType].drawCall = [](const GLsizei size){
glDrawElementsInstanced(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, 0, size);
};
// preCall
m_renderTypes[renderType].preCall = tripleBufferPreCall;
}
void ShapeGen::setupCUBE() {
//CUBE!
{
//Make a vbo containing the following vertices
//000 100 010 001 110 101 011 111
glBindBuffer(GL_ARRAY_BUFFER, vertBufIDs[0]);
float vertices0[8 * 4] = {
1.0f, 1.0f, 1.0f, 1.0f, //111 -> I
-1.0f, 1.0f, 1.0f, 1.0f, //011 -> II
-1.0f, -1.0f, 1.0f, 1.0f, //001 -> III
1.0f, -1.0f, 1.0f, 1.0f, //101 -> IV
1.0f, 1.0f, -1.0f, 1.0f, //110 -> V
-1.0f, 1.0f, -1.0f, 1.0f, //010 -> VI
-1.0f, -1.0f, -1.0f, 1.0f, //000 -> VII
1.0f, -1.0f, -1.0f, 1.0f //100 -> VIII
};
float vertices1[8 * 3 * 4];
for (int i = 0; i < 8; i++) {
//along x, along y, along z
for (int j = 0; j < 3; j++) {
//x, y, z, w
for (int k = 0; k < 4; k++) {
vertices1[i * 3 * 4 + j * 4 + k] = vertices0[i * 4 + k];
}
}
}
glBufferData(GL_ARRAY_BUFFER, 4 * 8 * 3 * sizeof(float), vertices1, GL_STATIC_DRAW);
}
{
glBindBuffer(GL_ARRAY_BUFFER, colBufIDs[0]);
float colors1[8 * 3 * 3];
for (int i = 0; i < 8 * 3 * 3; i++) {
colors1[i] = 1.0f;
}
/*
for (int i = 0; i < 8; i++) {
//along x, along y, along z
for (int j = 0; j < 3; j++) {
//x, y, z
for (int k = 0; k < 3; k++) {
//This should make it so that faces with normals along the x axis
// be red, y aligned ones will be green, and z aligned ones will be blue.
colors1[i * 3 * 3 + j * 3 + k] = ((float) (j == k)) * 0.7 + 0.2;
}
}
}*/
glBufferData(GL_ARRAY_BUFFER, 8 * 3 * 3 * sizeof(float), colors1, GL_STATIC_DRAW);
}
{
float normals0[24] = {
1.0f, 1.0f, 1.0f,
-1.0f, 1.0f, 1.0f,
-1.0f, -1.0f, 1.0f,
1.0f, -1.0f, 1.0f,
1.0f, 1.0f, -1.0f,
-1.0f, 1.0f, -1.0f,
-1.0f, -1.0f, -1.0f,
1.0f, -1.0f, -1.0f
};
//TODO: make the normals line up with
glBindBuffer(GL_ARRAY_BUFFER, normBufIDs[0]);
float normals1[8 * 3 * 4];
for (int i = 0; i < 8; i++) {
//directions
for (int j = 0; j < 3; j++) {
//dimensions
for (int k = 0; k < 4; k++) {
const int index = i * 3 * 4 + j * 4 + k;
if (j == k) {
normals1[index] = normals0[i * 3 + j];
} else {
normals1[index] = 0;
}
}
}
}
glBufferData(GL_ARRAY_BUFFER, 24 * sizeof(float), normals1, GL_STATIC_DRAW);
}
//Now we're entering IBO mode.
glEnableVertexAttribArray(posAttID);
glEnableVertexAttribArray(normAttID);
glEnableVertexAttribArray(colAttID);
glBindBuffer(GL_ARRAY_BUFFER, vertBufIDs[0]);
glVertexAttribPointer(posAttID, 4, GL_FLOAT, 0, 0, static_cast<GLvoid*>(0));
glBindBuffer(GL_ARRAY_BUFFER, colBufIDs[0]);
glVertexAttribPointer(colAttID, 3, GL_FLOAT, 0, 0, static_cast<GLvoid*>(0));
glBindBuffer(GL_ARRAY_BUFFER, normBufIDs[0]);
glVertexAttribPointer(normAttID, 4, GL_FLOAT, 0, 0, static_cast<GLvoid*>(0));
{
const int indCount = 3 * 2 * 6;
//x, then y, then z
//positive, then negative
//and finally the particular vertex
GLint octants[indCount] = {
1, 5, 4, 8, 5, 4, //x
2, 6, 3, 7, 6, 3,
2, 4, 1, 2, 4, 3, //y
6, 8, 7, 6, 8, 5,
3, 8, 7, 3, 8, 4, //z
2, 5, 1, 2, 5, 6
};
GLint indices[indCount];
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 6; k++) {
const int octantsIndex = i * 2 * 6 + j * 6 + k;
indices[octantsIndex] = cubeVert(octants[octantsIndex], i);
}
}
}
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indBufIDs[0]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, indCount * sizeof(GLint), indices, GL_STATIC_DRAW);
}
}
