Hurlu/forkkmuopengl
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

First step of the rework is done : now for manual MeshCreation from code

Browse Source
This commit is contained in:
Hurlu 2019-03-08 20:00:13 +09:00
parent 1bf24da18d
commit 8f595cab38
34 changed files with 763 additions and 1936 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

90
BaseGLProject/ADrawable.h
View File

@ -1,90 +0,0 @@
#pragma once
#include <queue>
#include "IDrawable.h"
enum Transformation
{
Rotation,
Translation,
Scaling
};
class ADrawable : IDrawable {
protected:
std::vector<std::pair<glm::vec4, Transformation>> _transformations;
Model _model;
void effectTransformations()
{
for (auto pair : _transformations)
{
switch (pair.second)
{
case(Rotation):
_model.glRotate(pair.first.w, pair.first.x, pair.first.y, pair.first.z);
break;
case(Translation):
_model.glTranslate(pair.first.x, pair.first.y, pair.first.z);
break;
case(Scaling):
_model.glScale(pair.first.x, pair.first.y, pair.first.z);
break;
}
}
}
public:
virtual void draw(ShaderProgram *shader, glm::mat4x4 proj_matrix, glm::mat4x4 view_matrix) = 0;
virtual DrawableType getType() = 0;
void addRotation(glm::vec4 vec) override
{
_transformations.emplace_back(vec, Rotation);
}
void addTranslation(glm::vec4 vec) override
{
_transformations.emplace_back(vec, Translation);
}
void addScaling(glm::vec4 vec) override
{
_transformations.emplace_back(vec, Scaling);
}
glm::vec4 translateToPivot(glm::vec3 pivot) override
{
glm::vec4 curr_pos = { 0, 0, 0, 0 };
glm::vec4 h_pivot = { pivot.x, pivot.y, pivot.z, 0 };
for (auto pair : _transformations)
{
if (pair.second == Translation)
curr_pos += pair.first;
}
addTranslation(h_pivot - curr_pos);
return curr_pos - h_pivot;
}
void removeLastTransformations(int n = 1) override
{
for (int i = 0; i < n; i++)
_transformations.pop_back();
}
glm::vec3 getPosition() override
{
glm::vec4 curr_pos = { 0, 0, 0, 0 };
for (auto pair : _transformations)
{
if (pair.second == Translation)
curr_pos += pair.first;
}
return curr_pos;
}
};

21
BaseGLProject/BaseGLProject.vcxproj
View File

@ -154,22 +154,17 @@
<ClCompile Include="imgui\imgui_impl_glfw.cpp" /> <ClCompile Include="imgui\imgui_impl_glfw.cpp" />
<ClCompile Include="imgui\imgui_impl_opengl3.cpp" /> <ClCompile Include="imgui\imgui_impl_opengl3.cpp" />
<ClCompile Include="imgui\imgui_widgets.cpp" /> <ClCompile Include="imgui\imgui_widgets.cpp" />
<ClCompile Include="LineSegment.cpp" /> <ClCompile Include="Light.cpp" />
<ClCompile Include="Models\Mesh.cpp" /> <ClCompile Include="Models\Mesh.cpp" />
<ClCompile Include="MyGLWindow.cpp" /> <ClCompile Include="MyGLWindow.cpp" />
<ClCompile Include="Plane.cpp" /> <ClCompile Include="Shader.cpp" />
<ClCompile Include="Source.cpp" /> <ClCompile Include="Source.cpp" />
<ClCompile Include="Sphere.cpp" />
<ClCompile Include="vboteapot.cpp" />
<ClCompile Include="Viewer.cpp" /> <ClCompile Include="Viewer.cpp" />
<ClCompile Include="WireCube.cpp" />
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<ClInclude Include="ADrawable.h" />
<ClInclude Include="CheckeredFloor.h" /> <ClInclude Include="CheckeredFloor.h" />
<ClInclude Include="ColorCube.h" /> <ClInclude Include="ColorCube.h" />
<ClInclude Include="Global.h" /> <ClInclude Include="Dataset.h" />
<ClInclude Include="IDrawable.h" />
<ClInclude Include="imgui\imconfig.h" /> <ClInclude Include="imgui\imconfig.h" />
<ClInclude Include="imgui\imgui.h" /> <ClInclude Include="imgui\imgui.h" />
<ClInclude Include="imgui\imgui_impl_glfw.h" /> <ClInclude Include="imgui\imgui_impl_glfw.h" />
@ -178,17 +173,15 @@
<ClInclude Include="imgui\imstb_rectpack.h" /> <ClInclude Include="imgui\imstb_rectpack.h" />
<ClInclude Include="imgui\imstb_textedit.h" /> <ClInclude Include="imgui\imstb_textedit.h" />
<ClInclude Include="imgui\imstb_truetype.h" /> <ClInclude Include="imgui\imstb_truetype.h" />
<ClInclude Include="LineSegment.h" /> <ClInclude Include="Light.h" />
<ClInclude Include="Loader.h" /> <ClInclude Include="Loader.h" />
<ClInclude Include="Material.h" />
<ClInclude Include="Models\Mesh.h" /> <ClInclude Include="Models\Mesh.h" />
<ClInclude Include="ModelView.h" /> <ClInclude Include="ModelView.h" />
<ClInclude Include="MyGLWindow.h" /> <ClInclude Include="MyGLWindow.h" />
<ClInclude Include="Plane.h" /> <ClInclude Include="SceneContext.h" />
<ClInclude Include="Sphere.h" /> <ClInclude Include="Shader.h" />
<ClInclude Include="teapotdata.h" />
<ClInclude Include="vboteapot.h" />
<ClInclude Include="Viewer.h" /> <ClInclude Include="Viewer.h" />
<ClInclude Include="WireCube.h" />
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<None Include="light.frag" /> <None Include="light.frag" />

63
BaseGLProject/BaseGLProject.vcxproj.filters
View File

@ -57,35 +57,20 @@
<ClCompile Include="imgui\imgui_widgets.cpp"> <ClCompile Include="imgui\imgui_widgets.cpp">
<Filter>imgui</Filter> <Filter>imgui</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="WireCube.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="LineSegment.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="Sphere.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="vboteapot.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="Models\Mesh.cpp"> <ClCompile Include="Models\Mesh.cpp">
<Filter>Models</Filter> <Filter>Models</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="Plane.cpp"> <ClCompile Include="Light.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="Shader.cpp">
<Filter>Source Files</Filter> <Filter>Source Files</Filter>
</ClCompile> </ClCompile>
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<ClInclude Include="ColorCube.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="ModelView.h"> <ClInclude Include="ModelView.h">
<Filter>Header Files</Filter> <Filter>Header Files</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="IDrawable.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="Loader.h"> <ClInclude Include="Loader.h">
<Filter>Header Files</Filter> <Filter>Header Files</Filter>
</ClInclude> </ClInclude>
@ -95,9 +80,6 @@
<ClInclude Include="Viewer.h"> <ClInclude Include="Viewer.h">
<Filter>Header Files</Filter> <Filter>Header Files</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="CheckeredFloor.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="imgui\imconfig.h"> <ClInclude Include="imgui\imconfig.h">
<Filter>imgui</Filter> <Filter>imgui</Filter>
</ClInclude> </ClInclude>
@ -122,31 +104,28 @@
<ClInclude Include="imgui\imstb_truetype.h"> <ClInclude Include="imgui\imstb_truetype.h">
<Filter>imgui</Filter> <Filter>imgui</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="WireCube.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="ADrawable.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="LineSegment.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="Sphere.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="teapotdata.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="vboteapot.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="Models\Mesh.h"> <ClInclude Include="Models\Mesh.h">
<Filter>Models</Filter> <Filter>Models</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="Global.h"> <ClInclude Include="ColorCube.h">
<Filter>Models</Filter>
</ClInclude>
<ClInclude Include="CheckeredFloor.h">
<Filter>Models</Filter>
</ClInclude>
<ClInclude Include="Light.h">
<Filter>Header Files</Filter> <Filter>Header Files</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="Plane.h"> <ClInclude Include="Dataset.h">
<Filter>Models</Filter>
</ClInclude>
<ClInclude Include="Shader.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="SceneContext.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="Material.h">
<Filter>Header Files</Filter> <Filter>Header Files</Filter>
</ClInclude> </ClInclude>
</ItemGroup> </ItemGroup>

198
BaseGLProject/CheckeredFloor.cpp
View File

@ -1,99 +1,99 @@
#include "CheckeredFloor.h" //#include "CheckeredFloor.h"
//
void CheckeredFloor::genVertices(std::vector<glm::vec4> &vertices, //void CheckeredFloor::genVertices(std::vector<glm::vec4> &vertices,
std::vector<glm::vec3> &colors) // std::vector<glm::vec3> &colors)
{ //{
float maxX = _size / 2.f, maxY = _size / 2.f; // float maxX = _size / 2.f, maxY = _size / 2.f;
float minX = -_size / 2.f, minY = -_size / 2.f; // float minX = -_size / 2.f, minY = -_size / 2.f;
float side_size = _size / (float)_squares; // float side_size = _size / (float)_squares;
int color = 1; // int color = 1;
//
for (float x = minX; x < maxX; x += side_size) // for (float x = minX; x < maxX; x += side_size)
{ // {
for (float y = minY; y < maxY; y += side_size) // for (float y = minY; y < maxY; y += side_size)
{ // {
color *= -1; // color *= -1;
glm::vec3 tile_color = (color > 0) ? _light_color : _dark_color; // glm::vec3 tile_color = (color > 0) ? _light_color : _dark_color;
//gen 1 carré // //gen 1 carré
vertices.emplace_back(x, 0, y, 1); //upleft // vertices.emplace_back(x, 0, y, 1); //upleft
vertices.emplace_back(x, 0, y + side_size, 1); //downleft // vertices.emplace_back(x, 0, y + side_size, 1); //downleft
vertices.emplace_back(x + side_size, 0, y + side_size, 1); //downright // vertices.emplace_back(x + side_size, 0, y + side_size, 1); //downright
//
vertices.emplace_back(x + side_size, 0, y + side_size, 1); //downright // vertices.emplace_back(x + side_size, 0, y + side_size, 1); //downright
vertices.emplace_back(x + side_size, 0, y, 1); //upright // vertices.emplace_back(x + side_size, 0, y, 1); //upright
vertices.emplace_back(x, 0, y, 1); //upleft // vertices.emplace_back(x, 0, y, 1); //upleft
//
//
//
for (int z = 0; z < 6; z++) // for (int z = 0; z < 6; z++)
colors.push_back(tile_color); // colors.push_back(tile_color);
} // }
color *= -1; // color *= -1;
} // }
} //}
//
void CheckeredFloor::setup() //void CheckeredFloor::setup()
{ //{
std::vector<glm::vec4> floor_vertices; // std::vector<glm::vec4> floor_vertices;
std::vector<glm::vec3> floor_colors; // std::vector<glm::vec3> floor_colors;
//
glGenVertexArrays(1, &_vaoHandle); // glGenVertexArrays(1, &_vaoHandle);
glBindVertexArray(_vaoHandle); // glBindVertexArray(_vaoHandle);
//
genVertices(floor_vertices, floor_colors); // genVertices(floor_vertices, floor_colors);
//
glGenBuffers(1, &_vbo_vertices); // glGenBuffers(1, &_vbo_vertices);
glBindBuffer(GL_ARRAY_BUFFER, _vbo_vertices); // glBindBuffer(GL_ARRAY_BUFFER, _vbo_vertices);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * floor_vertices.size() * 4, floor_vertices.data(), GL_STATIC_DRAW); // glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * floor_vertices.size() * 4, floor_vertices.data(), GL_STATIC_DRAW);
//
glVertexAttribPointer( // glVertexAttribPointer(
0, //attr number = 0 // 0, //attr number = 0
4, // 4,
GL_FLOAT, // GL_FLOAT,
GL_FALSE, // GL_FALSE,
0, // 0,
(void*)0); // (void*)0);
glEnableVertexAttribArray(0); //attr number = 0 // glEnableVertexAttribArray(0); //attr number = 0
//
//
glGenBuffers(1, &_vbo_colors); // glGenBuffers(1, &_vbo_colors);
glBindBuffer(GL_ARRAY_BUFFER, _vbo_colors); // glBindBuffer(GL_ARRAY_BUFFER, _vbo_colors);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * floor_colors.size() * 3, floor_colors.data(), GL_STATIC_DRAW); // glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * floor_colors.size() * 3, floor_colors.data(), GL_STATIC_DRAW);
//
glVertexAttribPointer( // glVertexAttribPointer(
1, // 1,
3, // 3,
GL_FLOAT, // GL_FLOAT,
GL_FALSE, // GL_FALSE,
0, // 0,
(void *)0); // (void *)0);
glEnableVertexAttribArray(1); // glEnableVertexAttribArray(1);
//
glBindVertexArray(0); // glBindVertexArray(0);
} //}
//
CheckeredFloor::CheckeredFloor(int size, int squares) : //CheckeredFloor::CheckeredFloor(int size, int squares) :
_size(size), _squares(squares) // _size(size), _squares(squares)
{ //{
setup(); // setup();
} //}
//
CheckeredFloor::~CheckeredFloor() //CheckeredFloor::~CheckeredFloor()
{ //{
} //}
//
void CheckeredFloor::draw(ShaderProgram * shader, glm::mat4x4 proj_matrix, glm::mat4x4 view_matrix) //void CheckeredFloor::draw(ShaderProgram * shader, glm::mat4x4 proj_matrix, glm::mat4x4 view_matrix)
{ //{
_model.glPushMatrix(); // _model.glPushMatrix();
effectTransformations(); // effectTransformations();
glBindVertexArray(_vaoHandle); // glBindVertexArray(_vaoHandle);
glm::mat4 mvpMatrix = proj_matrix * view_matrix * _model.getMatrix(); // glm::mat4 mvpMatrix = proj_matrix * view_matrix * _model.getMatrix();
glUniformMatrix4fv(shader->uniform("mvp"), 1, GL_FALSE, glm::value_ptr(mvpMatrix)); // glUniformMatrix4fv(shader->uniform("mvp"), 1, GL_FALSE, glm::value_ptr(mvpMatrix));
glDrawArrays(GL_TRIANGLES, 0, _squares * _squares * 6); // glDrawArrays(GL_TRIANGLES, 0, _squares * _squares * 6);
_model.glPopMatrix(); // _model.glPopMatrix();
} //}
//
DrawableType CheckeredFloor::getType() //DrawableType CheckeredFloor::getType()
{ //{
return DrawableType::CHECKERED_FLOOR; // return DrawableType::CHECKERED_FLOOR;
} //}

62
BaseGLProject/CheckeredFloor.h
View File

@ -1,31 +1,31 @@
#pragma once //#pragma once
#define GLM_SWIZZLE //#define GLM_SWIZZLE
#define GLM_ENABLE_EXPERIMENTAL //#define GLM_ENABLE_EXPERIMENTAL
#include <glm/glm.hpp> //#include <glm/glm.hpp>
#include <glm/gtx/string_cast.hpp> //#include <glm/gtx/string_cast.hpp>
#include <vector> //#include <vector>
#include "ADrawable.h" //#include "ADrawable.h"
//
class CheckeredFloor : public ADrawable //class CheckeredFloor : public ADrawable
{ //{
private : //private :
GLuint _vaoHandle; // GLuint _vaoHandle;
GLuint _vbo_vertices, _vbo_colors; // GLuint _vbo_vertices, _vbo_colors;
//
void genVertices(std::vector<glm::vec4> &vertices, // void genVertices(std::vector<glm::vec4> &vertices,
std::vector<glm::vec3> &colors); // std::vector<glm::vec3> &colors);
void setup(); // void setup();
//
glm::vec3 _light_color = {.7f, .7f, .7f}; // glm::vec3 _light_color = {.7f, .7f, .7f};
glm::vec3 _dark_color = {.3f, .3f, .3f}; // glm::vec3 _dark_color = {.3f, .3f, .3f};
//
int _size; // int _size;
int _squares; // int _squares;
//
public : //public :
CheckeredFloor(int size, int squares); // CheckeredFloor(int size, int squares);
~CheckeredFloor(); // ~CheckeredFloor();
void draw(ShaderProgram *shader, glm::mat4x4 proj_matrix, glm::mat4x4 view_matrix) override; // void draw(ShaderProgram *shader, glm::mat4x4 proj_matrix, glm::mat4x4 view_matrix) override;
DrawableType getType() override; // DrawableType getType() override;
//
}; //};

422
BaseGLProject/ColorCube.cpp
View File

@ -1,211 +1,211 @@
#include "ColorCube.h" //#include "ColorCube.h"
//
glm::vec3 computeNormal(glm::vec3 p1, glm::vec3 p2, glm::vec3 p3) //glm::vec3 computeNormal(glm::vec3 p1, glm::vec3 p2, glm::vec3 p3)
{ //{
glm::vec3 v1 = p2 - p1; // glm::vec3 v1 = p2 - p1;
glm::vec3 v2 = p3 - p1; // glm::vec3 v2 = p3 - p1;
//
return glm::normalize(glm::cross(v1, v2)); // return glm::normalize(glm::cross(v1, v2));
} //}
//
void ColorCube::iboSetup() //void ColorCube::iboSetup()
{ //{
std::vector<glm::vec3> cube_vertices = // std::vector<glm::vec3> cube_vertices =
{ { -1.0, -1.0, 1.0}, // { { -1.0, -1.0, 1.0},
{ 1.0, -1.0, 1.0}, // { 1.0, -1.0, 1.0},
{ 1.0, 1.0, 1.0}, // { 1.0, 1.0, 1.0},
{ -1.0, 1.0, 1.0}, // { -1.0, 1.0, 1.0},
{ -1.0, -1.0, -1.0}, // { -1.0, -1.0, -1.0},
{ 1.0, -1.0, -1.0}, // { 1.0, -1.0, -1.0},
{ 1.0, 1.0, -1.0}, // { 1.0, 1.0, -1.0},
{ -1.0, 1.0, -1.0} }; // { -1.0, 1.0, -1.0} };
//
GLfloat cube_colors[] = { // GLfloat cube_colors[] = {
// front colors // // front colors
1.0, 0.0, 0.0, // 1.0, 0.0, 0.0,
0.0, 1.0, 0.0, // 0.0, 1.0, 0.0,
0.0, 0.0, 1.0, // 0.0, 0.0, 1.0,
1.0, 1.0, 1.0, // 1.0, 1.0, 1.0,
// back colors // // back colors
1.0, 0.0, 0.0, // 1.0, 0.0, 0.0,
0.0, 1.0, 0.0, // 0.0, 1.0, 0.0,
0.0, 0.0, 1.0, // 0.0, 0.0, 1.0,
1.0, 1.0, 1.0, // 1.0, 1.0, 1.0,
}; // };
//
GLushort cube_elements[] = { // GLushort cube_elements[] = {
0, 1, 2, 2, 3, 0, 1, 5, 6, // 0, 1, 2, 2, 3, 0, 1, 5, 6,
6, 2, 1, 7, 6, 5, 5, 4, 7, // 6, 2, 1, 7, 6, 5, 5, 4, 7,
4, 0, 3, 3, 7, 4, 4, 5, 1, // 4, 0, 3, 3, 7, 4, 4, 5, 1,
1, 0, 4, 3, 2, 6, 6, 7, 3, // 1, 0, 4, 3, 2, 6, 6, 7, 3,
}; // };
//
//
glGenVertexArrays(1, &_vaoHandle); // glGenVertexArrays(1, &_vaoHandle);
glBindVertexArray(_vaoHandle); // glBindVertexArray(_vaoHandle);
//
glGenBuffers(1, &_vbo_vertices); // glGenBuffers(1, &_vbo_vertices);
glBindBuffer(GL_ARRAY_BUFFER, _vbo_vertices); // glBindBuffer(GL_ARRAY_BUFFER, _vbo_vertices);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * cube_vertices.size() * 3, cube_vertices.data(), GL_STATIC_DRAW); // glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * cube_vertices.size() * 3, cube_vertices.data(), GL_STATIC_DRAW);
//
glVertexAttribPointer( // glVertexAttribPointer(
0, //attr number = 0 // 0, //attr number = 0
3, // 3,
GL_FLOAT, // GL_FLOAT,
GL_FALSE, // GL_FALSE,
0, // 0,
(void*)0); // (void*)0);
glEnableVertexAttribArray(0); //attr number = 0 // glEnableVertexAttribArray(0); //attr number = 0
//
glGenBuffers(1, &_vbo_colors); // glGenBuffers(1, &_vbo_colors);
glBindBuffer(GL_ARRAY_BUFFER, _vbo_colors); // glBindBuffer(GL_ARRAY_BUFFER, _vbo_colors);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 24, cube_colors, GL_STATIC_DRAW); // glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 24, cube_colors, GL_STATIC_DRAW);
//
glVertexAttribPointer( // glVertexAttribPointer(
1, // 1,
3, // 3,
GL_FLOAT, // GL_FLOAT,
GL_FALSE, // GL_FALSE,
0, // 0,
(void*)0); // (void*)0);
glEnableVertexAttribArray(1); // glEnableVertexAttribArray(1);
//
glGenBuffers(1, &_iboHandle); // glGenBuffers(1, &_iboHandle);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _iboHandle); // glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _iboHandle);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(cube_elements), cube_elements, GL_STATIC_DRAW); // glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(cube_elements), cube_elements, GL_STATIC_DRAW);
//
glBindVertexArray(0); // glBindVertexArray(0);
} //}
//
void ColorCube::vaoSetup() //void ColorCube::vaoSetup()
{ //{
std::vector<glm::vec3> cube_vertices = // std::vector<glm::vec3> cube_vertices =
{ { -1.0, -1.0, 1.0}, { 1.0, -1.0, 1.0}, { 1.0, 1.0, 1.0}, // { { -1.0, -1.0, 1.0}, { 1.0, -1.0, 1.0}, { 1.0, 1.0, 1.0},
{ 1.0, 1.0, 1.0}, { -1.0, 1.0, 1.0}, { -1.0, -1.0, 1.0}, // { 1.0, 1.0, 1.0}, { -1.0, 1.0, 1.0}, { -1.0, -1.0, 1.0},
{ 1.0, -1.0, 1.0}, { 1.0, -1.0, -1.0}, { 1.0, 1.0, -1.0}, // { 1.0, -1.0, 1.0}, { 1.0, -1.0, -1.0}, { 1.0, 1.0, -1.0},
{ 1.0, 1.0, -1.0}, { 1.0, 1.0, 1.0}, { 1.0, -1.0, 1.0}, // { 1.0, 1.0, -1.0}, { 1.0, 1.0, 1.0}, { 1.0, -1.0, 1.0},
{ -1.0, 1.0, -1.0}, { 1.0, 1.0, -1.0}, { 1.0, -1.0, -1.0}, // { -1.0, 1.0, -1.0}, { 1.0, 1.0, -1.0}, { 1.0, -1.0, -1.0},
{ 1.0, -1.0, -1.0}, { -1.0, -1.0, -1.0}, { -1.0, 1.0, -1.0}, // { 1.0, -1.0, -1.0}, { -1.0, -1.0, -1.0}, { -1.0, 1.0, -1.0},
{ -1.0, -1.0, -1.0}, { -1.0, -1.0, 1.0}, { -1.0, 1.0, 1.0}, // { -1.0, -1.0, -1.0}, { -1.0, -1.0, 1.0}, { -1.0, 1.0, 1.0},
{ -1.0, 1.0, 1.0}, { -1.0, 1.0, -1.0}, { -1.0, -1.0, -1.0}, // { -1.0, 1.0, 1.0}, { -1.0, 1.0, -1.0}, { -1.0, -1.0, -1.0},
{ -1.0, -1.0, -1.0}, { 1.0, -1.0, -1.0}, { 1.0, -1.0, 1.0}, // { -1.0, -1.0, -1.0}, { 1.0, -1.0, -1.0}, { 1.0, -1.0, 1.0},
{ 1.0, -1.0, 1.0}, { -1.0, -1.0, 1.0}, { -1.0, -1.0, -1.0}, // { 1.0, -1.0, 1.0}, { -1.0, -1.0, 1.0}, { -1.0, -1.0, -1.0},
{ -1.0, 1.0, 1.0}, { 1.0, 1.0, 1.0}, { 1.0, 1.0, -1.0}, // { -1.0, 1.0, 1.0}, { 1.0, 1.0, 1.0}, { 1.0, 1.0, -1.0},
{ 1.0, 1.0, -1.0}, { -1.0, 1.0, -1.0}, { -1.0, 1.0, 1.0} }; // { 1.0, 1.0, -1.0}, { -1.0, 1.0, -1.0}, { -1.0, 1.0, 1.0} };
//
std::vector<GLfloat> cube_colors = { // std::vector<GLfloat> cube_colors = {
1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, // 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0,
0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, // 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0,
0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, // 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0,
0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, // 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0,
1.0, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, // 1.0, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0,
0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0, // 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0,
1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0, // 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, // 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0,
1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, // 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0,
0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, // 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0,
1.0, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, // 1.0, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0,
0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 // 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0
}; // };
//
std::vector<glm::vec3> cube_normals; // std::vector<glm::vec3> cube_normals;
//
for (int i = 0; i < cube_vertices.size() - 2; i += 3) // for (int i = 0; i < cube_vertices.size() - 2; i += 3)
{ // {
glm::vec3 norm = computeNormal( // glm::vec3 norm = computeNormal(
cube_vertices[i], cube_vertices[i + 1], cube_vertices[i + 2]); // cube_vertices[i], cube_vertices[i + 1], cube_vertices[i + 2]);
cube_normals.push_back(norm); cube_normals.push_back(norm); cube_normals.push_back(norm); // cube_normals.push_back(norm); cube_normals.push_back(norm); cube_normals.push_back(norm);
} // }
//
//
glGenVertexArrays(1, &_vaoHandle); // glGenVertexArrays(1, &_vaoHandle);
glBindVertexArray(_vaoHandle); // glBindVertexArray(_vaoHandle);
//
glGenBuffers(1, &_vbo_vertices); // glGenBuffers(1, &_vbo_vertices);
glBindBuffer(GL_ARRAY_BUFFER, _vbo_vertices); // glBindBuffer(GL_ARRAY_BUFFER, _vbo_vertices);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * cube_vertices.size() * 3, cube_vertices.data(), GL_STATIC_DRAW); // glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * cube_vertices.size() * 3, cube_vertices.data(), GL_STATIC_DRAW);
//
glVertexAttribPointer( // glVertexAttribPointer(
0, //attr number = 0 // 0, //attr number = 0
3, // 3,
GL_FLOAT, // GL_FLOAT,
GL_FALSE, // GL_FALSE,
0, // 0,
(void*)0); // (void*)0);
glEnableVertexAttribArray(0); //attr number = 0 // glEnableVertexAttribArray(0); //attr number = 0
//
glGenBuffers(1, &_vbo_normals); // glGenBuffers(1, &_vbo_normals);
glBindBuffer(GL_ARRAY_BUFFER, _vbo_normals); // glBindBuffer(GL_ARRAY_BUFFER, _vbo_normals);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * cube_normals.size() * 3, cube_normals.data(), GL_STATIC_DRAW); // glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * cube_normals.size() * 3, cube_normals.data(), GL_STATIC_DRAW);
//
glVertexAttribPointer( // glVertexAttribPointer(
1, // 1,
3, // 3,
GL_FLOAT, // GL_FLOAT,
GL_FALSE, // GL_FALSE,
0, // 0,
(void*)0); // (void*)0);
glEnableVertexAttribArray(1); // glEnableVertexAttribArray(1);
//
glGenBuffers(1, &_vbo_colors); // glGenBuffers(1, &_vbo_colors);
glBindBuffer(GL_ARRAY_BUFFER, _vbo_colors); // glBindBuffer(GL_ARRAY_BUFFER, _vbo_colors);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * cube_colors.size(), cube_colors.data(), GL_STATIC_DRAW); // glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * cube_colors.size(), cube_colors.data(), GL_STATIC_DRAW);
//
glVertexAttribPointer( // glVertexAttribPointer(
2, // 2,
3, // 3,
GL_FLOAT, // GL_FLOAT,
GL_FALSE, // GL_FALSE,
0, // 0,
(void*)0); // (void*)0);
glEnableVertexAttribArray(2); // glEnableVertexAttribArray(2);
//
glBindVertexArray(0); // glBindVertexArray(0);
} //}
//
ColorCube::ColorCube(bool usingIBO) //ColorCube::ColorCube(bool usingIBO)
{ //{
ibo_used = usingIBO; // ibo_used = usingIBO;
if (usingIBO) // if (usingIBO)
iboSetup(); // iboSetup();
else // else
vaoSetup(); // vaoSetup();
} //}
//
//
void ColorCube::draw(ShaderProgram *shader, glm::mat4x4 proj_matrix, glm::mat4x4 view_matrix) //void ColorCube::draw(ShaderProgram *shader, glm::mat4x4 proj_matrix, glm::mat4x4 view_matrix)
{ //{
_model.glPushMatrix(); // _model.glPushMatrix();
effectTransformations(); // effectTransformations();
glBindVertexArray(_vaoHandle); // glBindVertexArray(_vaoHandle);
glm::mat4 mvpMatrix = proj_matrix * view_matrix * _model.getMatrix(); // glm::mat4 mvpMatrix = proj_matrix * view_matrix * _model.getMatrix();
glUniformMatrix4fv(shader->uniform("mvp"), 1, GL_FALSE, glm::value_ptr(mvpMatrix)); // glUniformMatrix4fv(shader->uniform("mvp"), 1, GL_FALSE, glm::value_ptr(mvpMatrix));
glm::mat4 modelview = view_matrix * _model.getMatrix(); // glm::mat4 modelview = view_matrix * _model.getMatrix();
_model.glPopMatrix(); // _model.glPopMatrix();
glUniform4fv(shader->uniform("LightLocation"), 1, glm::value_ptr(view_matrix * glm::vec4(50, 50, 50, 1))); // glUniform4fv(shader->uniform("LightLocation"), 1, glm::value_ptr(view_matrix * glm::vec4(50, 50, 50, 1)));
glUniformMatrix4fv(shader->uniform("ModelViewMatrix"), 1, GL_FALSE, glm::value_ptr(modelview)); // glUniformMatrix4fv(shader->uniform("ModelViewMatrix"), 1, GL_FALSE, glm::value_ptr(modelview));
glm::mat4 inverseModelView = glm::inverse(modelview); // glm::mat4 inverseModelView = glm::inverse(modelview);
glm::mat3 normalMatrix = glm::mat3(glm::transpose(inverseModelView)); // glm::mat3 normalMatrix = glm::mat3(glm::transpose(inverseModelView));
glUniformMatrix3fv(shader->uniform("NormalMatrix"), 1, GL_FALSE, glm::value_ptr(normalMatrix)); // glUniformMatrix3fv(shader->uniform("NormalMatrix"), 1, GL_FALSE, glm::value_ptr(normalMatrix));
//
if (ibo_used) // if (ibo_used)
{ // {
int size; // int size;
glGetBufferParameteriv(GL_ELEMENT_ARRAY_BUFFER, GL_BUFFER_SIZE, &size); // glGetBufferParameteriv(GL_ELEMENT_ARRAY_BUFFER, GL_BUFFER_SIZE, &size);
glDrawElements(GL_TRIANGLES, size / sizeof(GLushort), GL_UNSIGNED_SHORT, 0); // glDrawElements(GL_TRIANGLES, size / sizeof(GLushort), GL_UNSIGNED_SHORT, 0);
} // }
else // else
glDrawArrays(GL_TRIANGLES, 0, 36); // glDrawArrays(GL_TRIANGLES, 0, 36);
//
//
//
} //}
//
DrawableType ColorCube::getType() //DrawableType ColorCube::getType()
{ //{
return DrawableType::COLOR_CUBE; // return DrawableType::COLOR_CUBE;
} //}
//
ColorCube::~ColorCube() //ColorCube::~ColorCube()
{ //{
} //}

54
BaseGLProject/ColorCube.h
View File

@ -1,27 +1,27 @@
#include <iostream> //#include <iostream>
#include <string> //#include <string>
#include <vector> //#include <vector>
#include <glm/vec4.hpp> //#include <glm/vec4.hpp>
#include "ADrawable.h" // #include "ADrawable.h"
//
#pragma once //#pragma once
class ColorCube : public ADrawable //class ColorCube : public ADrawable
{ //{
private: //private:
GLuint _vaoHandle; // GLuint _vaoHandle;
GLuint _iboHandle; // GLuint _iboHandle;
GLuint _vbo_vertices, _vbo_colors, _vbo_normals; // GLuint _vbo_vertices, _vbo_colors, _vbo_normals;
//
bool ibo_used; // bool ibo_used;
//
void iboSetup(); // void iboSetup();
void vaoSetup(); // void vaoSetup();
//
public: //public:
ColorCube(bool usingIBO); // ColorCube(bool usingIBO);
//
void draw(ShaderProgram *shader, glm::mat4x4 proj_matrix, glm::mat4x4 view_matrix) override; // void draw(ShaderProgram *shader, glm::mat4x4 proj_matrix, glm::mat4x4 view_matrix) override;
DrawableType getType() override; // DrawableType getType() override;
~ColorCube(); // ~ColorCube();
}; //};
//

8
BaseGLProject/Dataset.h Normal file
View File

@ -0,0 +1,8 @@
#pragma once
class Dataset
{
public:
Dataset();
~Dataset();
};

8
BaseGLProject/Global.h
View File

@ -1,8 +0,0 @@
#pragma once
#include "glm/glm.hpp"
namespace global
{
static glm::vec4 LightLocation(50, 50, 50, 1);
static glm::vec3 LightIntensity(0.9, 0.9, 0.9);
}

34
BaseGLProject/IDrawable.h
View File

@ -1,34 +0,0 @@
#pragma once
#include "GL/glew.h"
#include "glm/gtc/type_ptr.hpp"
#include "Loader.h"
#include "ModelView.h"
enum DrawableType
{
COLOR_CUBE,
CHECKERED_FLOOR,
WIRE_CUBE,
LINE_SEGMENT,
SPHERE,
TEAPOT,
LOADED_MESH,
LIGHTED_PLANE
};
class IDrawable {
public:
virtual void addRotation(glm::vec4 vec) = 0;
virtual void addTranslation(glm::vec4 vec) = 0;
virtual void addScaling(glm::vec4 vec) = 0;
virtual void removeLastTransformations(int n) = 0;
virtual glm::vec3 getPosition() = 0;
virtual glm::vec4 translateToPivot(glm::vec3) = 0;
virtual void draw(ShaderProgram *shader, glm::mat4x4 proj_matrix, glm::mat4x4 view_matrix) = 0;
virtual DrawableType getType() = 0;
};

10
BaseGLProject/Light.cpp Normal file
View File

@ -0,0 +1,10 @@
#include "Light.h"
Light::Light(glm::vec3 intensity_, glm::vec4 location_) : location(location_), intensity(intensity_)
{
}
Light::~Light()
{
}

16
BaseGLProject/Light.h Normal file
View File

@ -0,0 +1,16 @@
#pragma once
#include "glm/vec3.hpp"
#include "glm/vec4.hpp"
class Light
{
public:
Light(glm::vec3 intensity, glm::vec4 location);
~Light();
bool activated = true;
glm::vec3 intensity;
glm::vec4 location;
};

69
BaseGLProject/LineSegment.cpp
View File

@ -1,69 +0,0 @@
#include "LineSegment.h"
#define GLM_ENABLE_EXPERIMENTAL
#include "glm/gtx/string_cast.hpp"
void LineSegment::setup()
{
std::vector<glm::vec3> seg_vertices =
{ { .0, -1.0f, .0}, {.0, 1.0f, .0} };
std::vector<glm::vec3> seg_colors =
{ { 1.f, .0, .0}, {1.f, .0, .0} };
glGenVertexArrays(1, &_vaoHandle);
glBindVertexArray(_vaoHandle);
glGenBuffers(1, &_vbo_vertices);
glBindBuffer(GL_ARRAY_BUFFER, _vbo_vertices);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * seg_vertices.size() * 3, seg_vertices.data(), GL_STATIC_DRAW);
glVertexAttribPointer(
0, //attr number = 0
3,
GL_FLOAT,
GL_FALSE,
0,
(void*)0);
glEnableVertexAttribArray(0); //attr number = 0
glGenBuffers(1, &_vbo_colors);
glBindBuffer(GL_ARRAY_BUFFER, _vbo_colors);
glBufferData(GL_ARRAY_BUFFER, seg_colors.size() * sizeof(GLfloat) * 3, seg_colors.data(), GL_STATIC_DRAW);
glVertexAttribPointer(
1,
3,
GL_FLOAT,
GL_FALSE,
0,
(void*)0);
glEnableVertexAttribArray(1);
}
LineSegment::LineSegment()
{
setup();
}
void LineSegment::draw(ShaderProgram *shader, glm::mat4x4 proj_matrix, glm::mat4x4 view_matrix)
{
_model.glPushMatrix();
effectTransformations();
glm::mat4 mvpMatrix = proj_matrix * view_matrix * _model.getMatrix();
glUniformMatrix4fv(shader->uniform("mvp"), 1, GL_FALSE, glm::value_ptr(mvpMatrix));
glLineWidth(4);
glBindVertexArray(_vaoHandle);
glDrawArrays(GL_LINES, 0, 2);
_model.glPopMatrix();
}
DrawableType LineSegment::getType()
{
return DrawableType::LINE_SEGMENT;
}
LineSegment::~LineSegment()
{
}

32
BaseGLProject/LineSegment.h
View File

@ -1,32 +0,0 @@
#pragma once
#pragma once
#include <iostream>
#include <string>
#include <vector>
#include <glm/vec4.hpp>
#include "ADrawable.h"
#pragma once
class LineSegment : public ADrawable
{
private:
ADrawable *_start;
ADrawable *_end;
GLuint _vaoHandle;
GLuint _iboHandle;
GLuint _vbo_vertices, _vbo_colors;
void setup();
public:
LineSegment();
void draw(ShaderProgram *shader, glm::mat4x4 proj_matrix, glm::mat4x4 view_matrix) override;
DrawableType getType() override;
~LineSegment();
};

2
BaseGLProject/Loader.h
View File

@ -38,7 +38,7 @@ private:
GLuint fragmentShaderId; GLuint fragmentShaderId;
// How many shaders are attached to the shader program // How many shaders are attached to the shader program
GLuint shaderCount; GLuint shaderCount;
// Map of attributes and their binding locations // Map of attributes and their binding locations
std::map<std::string, int> attributeMap; std::map<std::string, int> attributeMap;

11
BaseGLProject/Material.h Normal file
View File

@ -0,0 +1,11 @@
#pragma once
#include <glm/vec3.hpp>
struct Material
{
glm::vec3 ka;
glm::vec3 kd;
glm::vec3 ks;
float shininess;
};

180
BaseGLProject/Models/Mesh.cpp
View File

@ -4,7 +4,6 @@
#include <vector> #include <vector>
#include <iostream> #include <iostream>
#include "Mesh.h" #include "Mesh.h"
#include "../Global.h"
#include <glm/vec3.hpp> #include <glm/vec3.hpp>
#include <glm/gtx/string_cast.hpp> #include <glm/gtx/string_cast.hpp>
@ -19,9 +18,6 @@
* Constructor, loading the specified aiMesh * Constructor, loading the specified aiMesh
**/ **/
Mesh::MeshEntry::MeshEntry(aiMesh *mesh, const aiScene* scene, Mesh * m) Mesh::MeshEntry::MeshEntry(aiMesh *mesh, const aiScene* scene, Mesh * m)
{ {
parent = m; parent = m;
@ -38,7 +34,7 @@ Mesh::MeshEntry::MeshEntry(aiMesh *mesh, const aiScene* scene, Mesh * m)
if (mesh->HasPositions()) { if (mesh->HasPositions()) {
float *vertices = new float[mesh->mNumVertices * 3]; float *vertices = new float[mesh->mNumVertices * 3];
for (int i = 0; i < mesh->mNumVertices; ++i) { for (unsigned int i = 0; i < mesh->mNumVertices; ++i) {
vertices[i * 3] = mesh->mVertices[i].x; vertices[i * 3] = mesh->mVertices[i].x;
vertices[i * 3 + 1] = mesh->mVertices[i].y; vertices[i * 3 + 1] = mesh->mVertices[i].y;
vertices[i * 3 + 2] = mesh->mVertices[i].z; vertices[i * 3 + 2] = mesh->mVertices[i].z;
@ -57,7 +53,7 @@ Mesh::MeshEntry::MeshEntry(aiMesh *mesh, const aiScene* scene, Mesh * m)
if (mesh->HasTextureCoords(0)) { if (mesh->HasTextureCoords(0)) {
float *texCoords = new float[mesh->mNumVertices * 2]; float *texCoords = new float[mesh->mNumVertices * 2];
for (int i = 0; i < mesh->mNumVertices; ++i) { for (unsigned int i = 0; i < mesh->mNumVertices; ++i) {
texCoords[i * 2] = mesh->mTextureCoords[0][i].x; texCoords[i * 2] = mesh->mTextureCoords[0][i].x;
texCoords[i * 2 + 1] = mesh->mTextureCoords[0][i].y; texCoords[i * 2 + 1] = mesh->mTextureCoords[0][i].y;
} }
@ -75,7 +71,7 @@ Mesh::MeshEntry::MeshEntry(aiMesh *mesh, const aiScene* scene, Mesh * m)
if (mesh->HasNormals()) { if (mesh->HasNormals()) {
float *normals = new float[mesh->mNumVertices * 3]; float *normals = new float[mesh->mNumVertices * 3];
for (int i = 0; i < mesh->mNumVertices; ++i) { for (unsigned int i = 0; i < mesh->mNumVertices; ++i) {
normals[i * 3] = mesh->mNormals[i].x; normals[i * 3] = mesh->mNormals[i].x;
normals[i * 3 + 1] = mesh->mNormals[i].y; normals[i * 3 + 1] = mesh->mNormals[i].y;
normals[i * 3 + 2] = mesh->mNormals[i].z; normals[i * 3 + 2] = mesh->mNormals[i].z;
@ -94,7 +90,7 @@ Mesh::MeshEntry::MeshEntry(aiMesh *mesh, const aiScene* scene, Mesh * m)
if (mesh->HasFaces()) { if (mesh->HasFaces()) {
unsigned int *indices = new unsigned int[mesh->mNumFaces * 3]; unsigned int *indices = new unsigned int[mesh->mNumFaces * 3];
for (int i = 0; i < mesh->mNumFaces; ++i) { for (unsigned int i = 0; i < mesh->mNumFaces; ++i) {
indices[i * 3] = mesh->mFaces[i].mIndices[0]; indices[i * 3] = mesh->mFaces[i].mIndices[0];
indices[i * 3 + 1] = mesh->mFaces[i].mIndices[1]; indices[i * 3 + 1] = mesh->mFaces[i].mIndices[1];
indices[i * 3 + 2] = mesh->mFaces[i].mIndices[2]; indices[i * 3 + 2] = mesh->mFaces[i].mIndices[2];
@ -157,18 +153,17 @@ Mesh::MeshEntry::~MeshEntry() {
**/ **/
void Mesh::MeshEntry::render() { void Mesh::MeshEntry::render() {
glBindVertexArray(vao); glBindVertexArray(vao);
int size; int size;
glGetBufferParameteriv(GL_ELEMENT_ARRAY_BUFFER, GL_BUFFER_SIZE, &size); glGetBufferParameteriv(GL_ELEMENT_ARRAY_BUFFER, GL_BUFFER_SIZE, &size);
glDrawElements(GL_TRIANGLES, size/ sizeof(unsigned int), GL_UNSIGNED_INT, NULL); glDrawElements(GL_TRIANGLES, size/ sizeof(unsigned int), GL_UNSIGNED_INT, NULL);
glBindVertexArray(0); glBindVertexArray(0);
} }
/** /**
* Mesh constructor, loads the specified filename if supported by Assimp * Mesh constructor, loads the specified filename if supported by Assimp
**/ **/
Mesh::Mesh(const char *filename, ShaderProgram * sh) Mesh::Mesh(const char *filename, Shader *sh)
{ {
shader = sh; shader = sh;
@ -185,11 +180,10 @@ Mesh::Mesh(const char *filename, ShaderProgram * sh)
return; return;
} }
for (int i = 0; i < scene->mNumMeshes; ++i) { for (unsigned int i = 0; i < scene->mNumMeshes; ++i) {
meshEntries.push_back(new Mesh::MeshEntry(scene->mMeshes[i], scene, this)); meshEntries.push_back(new Mesh::MeshEntry(scene->mMeshes[i], scene, this));
} }
} }
/** /**
@ -197,73 +191,28 @@ Mesh::Mesh(const char *filename, ShaderProgram * sh)
**/ **/
Mesh::~Mesh(void) Mesh::~Mesh(void)
{ {
for (int i = 0; i < meshEntries.size(); ++i) { for (unsigned int i = 0; i < meshEntries.size(); ++i) {
delete meshEntries.at(i); delete meshEntries.at(i);
} }
meshEntries.clear(); meshEntries.clear();
} }
/** void Mesh::draw(SceneContext ctx) {
* Renders all loaded MeshEntries
**/
DrawableType Mesh::getType()
{
return DrawableType::LOADED_MESH;
}
void Mesh::draw(ShaderProgram *, glm::mat4x4 proj_matrix, glm::mat4x4 view_matrix) { shader->enable();
for (unsigned int i = 0; i < meshEntries.size(); ++i) {
shader->use();
for (int i = 0; i < meshEntries.size(); ++i) {
MeshEntry * m = meshEntries[i]; MeshEntry * m = meshEntries[i];
// Moving the object to his set position
float shiness = meshEntries.at(i)->shininessStrength; model.glPushMatrix();
effectTransformations();
_model.glPushMatrix();
effectTransformations();
shader->addUniform("mvp");
shader->addUniform("NormalMatrix"); //Refer next slide : mat3
shader->addUniform("ModelViewMatrix"); //View*Model : mat4
glm::vec4 light_center(0, 10, 0, 0);
float radius = 10.0f;
float angle = 0;
static bool first_draw = true;
for (int i = 0; i < 5; i++)
{
std::string name = "Light[" + std::to_string(i) + "].Position";
shader->addUniform(name);
glm::vec4 position = glm::vec4(radius * cos(glm::radians(angle)), 10 ,radius * sin(glm::radians(angle)), 1);
glUniform4fv(shader->uniform(name), 1, glm::value_ptr(view_matrix * position));
angle += 360 / 5;
}
first_draw = false;
shader->addUniform("Light[0].Intensity");
glUniform3fv(shader->uniform("Light[0].Intensity"), 1, glm::value_ptr(glm::vec3(0.0f, 0.5f, 0.5f)));
shader->addUniform("Light[1].Intensity");
glUniform3fv(shader->uniform("Light[1].Intensity"), 1, glm::value_ptr(glm::vec3(0.0f, 0.0f, 0.5f)));
shader->addUniform("Light[2].Intensity");
glUniform3fv(shader->uniform("Light[2].Intensity"), 1, glm::value_ptr(glm::vec3(0.5f, 0.0f, 0.0f)));
shader->addUniform("Light[3].Intensity");
glUniform3fv(shader->uniform("Light[3].Intensity"), 1, glm::value_ptr(glm::vec3(0.0f, 0.5f, 0.0f)));
shader->addUniform("Light[4].Intensity");
glUniform3fv(shader->uniform("Light[4].Intensity"), 1, glm::value_ptr(glm::vec3(0.5f, 0.5f, 0.5f)));
glm::mat4 mvpMatrix = proj_matrix * view_matrix * _model.getMatrix();
glUniformMatrix4fv(shader->uniform("mvp"), 1, GL_FALSE, glm::value_ptr(mvpMatrix));
glm::mat4 modelview = view_matrix * _model.getMatrix();
glUniformMatrix4fv(shader->uniform("ModelViewMatrix"), 1, GL_FALSE, glm::value_ptr(modelview));
glm::mat4 inverseModelView = glm::inverse(modelview);
glm::mat3 normalMatrix = glm::mat3(glm::transpose(inverseModelView));
glUniformMatrix3fv(shader->uniform("NormalMatrix"), 1, GL_FALSE, glm::value_ptr(normalMatrix));
//Retrieving material data from the vertex
float shininess = meshEntries.at(i)->shininessStrength;
glm::vec3 diffuse = glm::vec3(meshEntries.at(i)->dcolor.r, meshEntries.at(i)->dcolor.g, meshEntries.at(i)->dcolor.b); glm::vec3 diffuse = glm::vec3(meshEntries.at(i)->dcolor.r, meshEntries.at(i)->dcolor.g, meshEntries.at(i)->dcolor.b);
glm::vec3 specular = glm::vec3(meshEntries.at(i)->scolor.r, meshEntries.at(i)->scolor.g, meshEntries.at(i)->scolor.b); glm::vec3 specular = glm::vec3(meshEntries.at(i)->scolor.r, meshEntries.at(i)->scolor.g, meshEntries.at(i)->scolor.b);
glm::vec3 ambient = glm::vec3(meshEntries.at(i)->acolor.r, meshEntries.at(i)->acolor.g, meshEntries.at(i)->acolor.b); glm::vec3 ambient = glm::vec3(meshEntries.at(i)->acolor.r, meshEntries.at(i)->acolor.g, meshEntries.at(i)->acolor.b);
@ -280,17 +229,92 @@ void Mesh::draw(ShaderProgram *, glm::mat4x4 proj_matrix, glm::mat4x4 view_matri
specular = glm::vec3(0.4, 0.4, 0.4); specular = glm::vec3(0.4, 0.4, 0.4);
} }
if (shiness == 0) if (shininess == 0)
shiness = 150.0f; shininess = 150.0f;
glUniform3fv(shader->uniform("Ka"), 1, glm::value_ptr(ambient)); shader->mat.ka = ambient;
glUniform3fv(shader->uniform("Kd"), 1, glm::value_ptr(diffuse)); shader->mat.kd = diffuse;
glUniform3fv(shader->uniform("Ks"), 1, glm::value_ptr(specular)); shader->mat.ks = specular;
glUniform1f(shader->uniform("Shininess"), shiness); shader->mat.shininess = shininess;
// Setting the space matrixes uniques to the object
ctx.mvpMatrix = ctx.projectionMatrix * ctx.viewMatrix * model.getMatrix();
ctx.modelViewMatrix = ctx.viewMatrix * model.getMatrix();
ctx.normalMatrix = glm::mat3(glm::transpose(glm::inverse(ctx.modelViewMatrix)));
//Sending the uniform data to the shader
shader->setUniforms(ctx);
meshEntries.at(i)->render(); meshEntries.at(i)->render();
_model.glPopMatrix(); model.glPopMatrix();
} }
shader->disable(); shader->disable();
} }
void Mesh::effectTransformations()
{
for (auto pair : _transformations)
{
switch (pair.second)
{
case(Rotation):
model.glRotate(pair.first.w, pair.first.x, pair.first.y, pair.first.z);
break;
case(Translation):
model.glTranslate(pair.first.x, pair.first.y, pair.first.z);
break;
case(Scaling):
model.glScale(pair.first.x, pair.first.y, pair.first.z);
break;
}
}
}
void Mesh::addRotation(glm::vec4 vec)
{
_transformations.emplace_back(vec, Rotation);
}
void Mesh::addTranslation(glm::vec4 vec)
{
_transformations.emplace_back(vec, Translation);
}
void Mesh::addScaling(glm::vec4 vec)
{
_transformations.emplace_back(vec, Scaling);
}
glm::vec4 Mesh::translateToPivot(glm::vec3 pivot)
{
glm::vec4 curr_pos = { 0, 0, 0, 0 };
glm::vec4 h_pivot = { pivot.x, pivot.y, pivot.z, 0 };
for (auto pair : _transformations)
{
if (pair.second == Translation)
curr_pos += pair.first;
}
addTranslation(h_pivot - curr_pos);
return curr_pos - h_pivot;
}
void Mesh::removeLastTransformations(int n = 1)
{
for (int i = 0; i < n; i++)
_transformations.pop_back();
}
glm::vec3 Mesh::getPosition()
{
glm::vec4 curr_pos = { 0, 0, 0, 0 };
for (auto pair : _transformations)
{
if (pair.second == Translation)
curr_pos += pair.first;
}
return curr_pos;
}

42
BaseGLProject/Models/Mesh.h
View File

@ -7,15 +7,24 @@
#include "assimp\scene.h" #include "assimp\scene.h"
#include "assimp\mesh.h" #include "assimp\mesh.h"
#include "../Loader.h" #include "../Shader.h"
#include "../ADrawable.h" #include "../SceneContext.h"
#include "../Dataset.h"
#include "../ModelView.h"
class Mesh : public ADrawable enum Transformation
{
Rotation,
Translation,
Scaling
};
class Mesh
{ {
public: public:
struct MeshEntry { struct MeshEntry {
static enum BUFFERS { enum BUFFERS {
VERTEX_BUFFER, TEXCOORD_BUFFER, NORMAL_BUFFER, INDEX_BUFFER VERTEX_BUFFER, TEXCOORD_BUFFER, NORMAL_BUFFER, INDEX_BUFFER
}; };
GLuint vao; GLuint vao;
@ -33,13 +42,24 @@ public:
}; };
public: public:
Mesh(const char *filename, ShaderProgram * sh); Mesh(const char *filename, Shader *sh);
~Mesh(void); Mesh(Dataset dataset, Shader *sh);
~Mesh(void);
std::vector<MeshEntry*> meshEntries; std::vector<MeshEntry*> meshEntries;
ShaderProgram * shader; private:
void draw(ShaderProgram *shader, glm::mat4x4 proj_matrix, glm::mat4x4 view_matrix); std::vector<std::pair<glm::vec4, Transformation>> _transformations;
DrawableType getType(); public:
Model model;
void effectTransformations();
void addRotation(glm::vec4 vec);
void addTranslation(glm::vec4 vec);
void addScaling(glm::vec4 vec);
glm::vec4 translateToPivot(glm::vec3);
void removeLastTransformations(int n);
glm::vec3 getPosition();
Shader *shader;
void draw(SceneContext ctx);
}; };

126
BaseGLProject/MyGLWindow.cpp
View File

@ -57,29 +57,26 @@ void MyGlWindow::setBgColor(float bgColor[3])
void MyGlWindow::setup() void MyGlWindow::setup()
{ {
_staticShader = new ShaderProgram(); _scnctx.lights.emplace("Light1", Light(glm::vec3(0.0f, 0.5f, 0.5f), glm::vec4(10, 10, 0, 1)));
_staticShader->initFromFiles("light.vert", "onelight.frag"); _scnctx.lights.emplace("Light2", Light(glm::vec3(0.0f, 0.0f, 0.5f), glm::vec4(3.09, 10, 9.51, 1)));
_lightShader = new ShaderProgram(); _scnctx.lights.emplace("Light3", Light(glm::vec3(0.5f, 0.0f, 0.0f), glm::vec4(-8.09, 10, 5.87, 1)));
_lightShader->initFromFiles("light.vert", "toon.frag"); _scnctx.lights.emplace("Light4", Light(glm::vec3(0.0f, 0.5f, 0.0f), glm::vec4(-8.09, 10, -5.87, 1)));
_scnctx.lights.emplace("Light5", Light(glm::vec3(0.5f, 0.5f, 0.5f), glm::vec4(3.09, 10, -9.51, 1)));
_static_drawables.push_back(new Plane(50, 16)); //shaders["ToonShader"] = Shader("light.vert", "toon.frag");
//// Removing useless specular component
//shaders["ToonShader"].uniformFlags &= ~ShaderFlags::KS_FLAG;
//shaders["ToonShader"].uniformFlags &= ~ShaderFlags::SHINE_FLAG;
/*_static_drawables.emplace_back(new CheckeredFloor(50, 16)); //meshes.emplace_back("teapot.obj", &shaders["ToonShader"]);
_light_drawables.push_back(new ColorCube(false));
_light_drawables.back()->addTranslation(glm::vec4(2, 1.1f, 0, 0)); ToonShader = new Shader("light.vert", "toon.frag");
_light_drawables.push_back(new Sphere(1, 50, 50));
_light_drawables.back()->addTranslation(glm::vec4(-2, 1.1f, 0, 0)); ToonShader->uniformFlags &= ~ShaderFlags::KS_FLAG;
_light_drawables.push_back(new VBOTeapot(64, glm::identity<glm::mat4x4>())); ToonShader->uniformFlags &= ~ShaderFlags::SHINE_FLAG;
_light_drawables.back()->addTranslation(glm::vec4(2, 0, -7, 0));
_light_drawables.back()->addRotation(glm::vec4(1, 0, 0, -90)); meshes.emplace_back("teapot.obj", ToonShader);
_light_drawables.push_back(new Mesh("bunny.obj", _lightShader));
_light_drawables.push_back(new Mesh("buddha.obj", _lightShader));
_light_drawables.back()->addTranslation(glm::vec4(0, 13, -15, 0));
_light_drawables.back()->addRotation(glm::vec4(0, 1, 0, -180));
_light_drawables.back()->addScaling(glm::vec4(30, 30, 30, 0));*/
_light_drawables.push_back(new Mesh("teapot.obj", _lightShader));
_light_drawables.back()->addTranslation(glm::vec4(0, 1, 0, 0));
_light_drawables.back()->addScaling(glm::vec4(1, 1, 1, 1));
} }
void MyGlWindow::draw() void MyGlWindow::draw()
@ -88,85 +85,24 @@ void MyGlWindow::draw()
glViewport(0, 0, m_width, m_height); glViewport(0, 0, m_width, m_height);
glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_TEST);
glEnable(GL_DEPTH_BUFFER); glEnable(GL_DEPTH_BUFFER);
glEnable(GL_BLEND);
//glEnable(GL_CULL_FACE);
//glCullFace(GL_BACK);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//setting the view data in the scene context
glm::vec3 eye(viewer.getViewPoint().x, viewer.getViewPoint().y, viewer.getViewPoint().z); glm::vec3 eye(viewer.getViewPoint().x, viewer.getViewPoint().y, viewer.getViewPoint().z);
glm::vec3 look(viewer.getViewCenter().x, viewer.getViewCenter().y, viewer.getViewCenter().z); glm::vec3 look(viewer.getViewCenter().x, viewer.getViewCenter().y, viewer.getViewCenter().z);
glm::vec3 up(viewer.getUpVector().x, viewer.getUpVector().y, viewer.getUpVector().z); glm::vec3 up(viewer.getUpVector().x, viewer.getUpVector().y, viewer.getUpVector().z);
glm::mat4 view = lookAt(eye, look, up); //Calculate view matrix from paramters of m_viewer glm::mat4 view = lookAt(eye, look, up); //Calculate view matrix from parameters of m_viewer
glm::mat4 projection = perspective(45.0f, m_width / m_height, 0.1f, 500.0f); glm::mat4 projection = perspective(45.0f, (float)m_width / (float)m_height, 0.1f, 500.0f);
_staticShader->use();
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
_staticShader->addUniform("mvp");
_staticShader->addUniform("Ka"); //Ambient Object Color :vec3
glUniform3fv(_staticShader->uniform("Ka"), 1, glm::value_ptr(glm::vec3(0.19225, 0.19225, 0.19225)));
_staticShader->addUniform("Kd"); //Diffuse Object Color :vec3
glUniform3fv(_staticShader->uniform("Kd"), 1, glm::value_ptr(glm::vec3(0.50754, 0.50754, 0.50754)));
_staticShader->addUniform("Ks"); //Specular Object Color :vec3
glUniform3fv(_staticShader->uniform("Ks"), 1, glm::value_ptr(glm::vec3(0.508273, 0.508273, 0.508273)));
_staticShader->addUniform("Shininess");
glUniform1f(_staticShader->uniform("Shininess"), 51.2);
_staticShader->addUniform("NormalMatrix"); //Refer next slide : mat3
_staticShader->addUniform("ModelViewMatrix"); //View*Model : mat4
/* Variable set for spot lighting */
_staticShader->addUniform("LightDirection");
_staticShader->addUniform("Exponent");
glUniform1f(_staticShader->uniform("Exponent"), 10);
_staticShader->addUniform("Cutoff");
glUniform1f(_staticShader->uniform("Cutoff"), 30);
_staticShader->addUniform("InnerCutoff");
glUniform1f(_staticShader->uniform("InnerCutoff"), 25);
/* END set */
for (ADrawable *drawable : _static_drawables)
drawable->draw(_staticShader, projection, view);
_staticShader->disable(); _scnctx.viewMatrix = view;
_scnctx.projectionMatrix = projection;
_lightShader->use(); static int i = 0;
glEnable(GL_CULL_FACE); for (auto it = meshes.begin(); it != meshes.end(); ++it)
glCullFace(GL_BACK); it->draw(_scnctx);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
_lightShader->addUniform("mvp");
_lightShader->addUniform("Ka"); //Ambient Object Color :vec3
glUniform3fv(_lightShader->uniform("Ka"), 1, glm::value_ptr(glm::vec3(0.19225, 0.19225, 0.19225)));
_lightShader->addUniform("Kd"); //Diffuse Object Color :vec3
glUniform3fv(_lightShader->uniform("Kd"), 1, glm::value_ptr(glm::vec3(0.50754, 0.50754, 0.50754)));
_lightShader->addUniform("Ks"); //Specular Object Color :vec3
glUniform3fv(_lightShader->uniform("Ks"), 1, glm::value_ptr(glm::vec3(0.508273, 0.508273, 0.508273)));
_lightShader->addUniform("Shininess");
glUniform1f(_lightShader->uniform("Shininess"), 51.2);
_lightShader->addUniform("NormalMatrix"); //Refer next slide : mat3
_lightShader->addUniform("ModelViewMatrix"); //View*Model : mat4
for (ADrawable *drawable : _light_drawables)
drawable->draw(_lightShader, projection, view);
_lightShader->disable();
}
void MyGlWindow::AddDrawable(ADrawable *d)
{
_static_drawables.push_back(d);
} }
void MyGlWindow::resize(int w, int h) void MyGlWindow::resize(int w, int h)

34
BaseGLProject/MyGLWindow.h
View File

@ -4,17 +4,11 @@
#include "GL/glew.h" #include "GL/glew.h"
#include <string> #include <string>
#include <vector> #include <vector>
#include "IDrawable.h" #include "Shader.h"
#include "ColorCube.h"
#include "Loader.h"
#include "ModelView.h" #include "ModelView.h"
#include "Viewer.h" #include "Viewer.h"
#include "CheckeredFloor.h" #include "Light.h"
#include "WireCube.h" #include "SceneContext.h"
#include "LineSegment.h"
#include "Sphere.h"
#include "vboteapot.h"
#include "Plane.h"
#include "Models/Mesh.h" #include "Models/Mesh.h"
struct vertexAttr { struct vertexAttr {
@ -24,21 +18,21 @@ struct vertexAttr {
class MyGlWindow { class MyGlWindow {
public: public:
MyGlWindow(int w, int h); MyGlWindow(int w, int h);
MyGlWindow();
~MyGlWindow(); ~MyGlWindow();
void draw(); void draw();
void setBgColor(float bgColor[3]); void setBgColor(float bgColor[3]);
std::map<std::string, Shader> shaders;
std::vector<Mesh> meshes;
std::map<std::string, float> floatValues;
void AddDrawable(ADrawable *);
void resize(int w, int h); void resize(int w, int h);
Viewer viewer; Viewer viewer;
private: private:
ShaderProgram *_staticShader; Shader *ToonShader;
ShaderProgram *_lightShader; SceneContext _scnctx;
int m_width; int m_width;
int m_height; int m_height;
@ -46,10 +40,8 @@ private:
GLuint _vaoHandle; GLuint _vaoHandle;
GLuint _iboHandle; GLuint _iboHandle;
std::vector<Mesh> _drawables;
std::vector<ADrawable *> _static_drawables; void setup();
std::vector<ADrawable *> _light_drawables;
void setup();
void setViewFromBox(glm::vec3 &eye, glm::vec3 &look, glm::vec3 &up);
}; };

129
BaseGLProject/Plane.cpp
View File

@ -1,129 +0,0 @@
#include "Plane.h"
Plane::Plane(int size, int numcell)
{
this->size = size;
this->ncell = numcell;
setup(size, numcell);
}
int nvert2;
void Plane::setup(float size, int nSquares)
{
std::vector<glm::vec3> vlists;
std::vector<glm::vec3> clists;
// parameters:
float maxX = size / 2, maxY = size / 2;
float minX = -size / 2, minY = -size / 2;
int x, y, v[3], i;
float xp, yp, xd, yd;
v[2] = 0;
xd = (maxX - minX) / ((float)nSquares);
yd = (maxY - minY) / ((float)nSquares);
for (x = 0, xp = minX; x < nSquares; x++, xp += xd) {
for (y = 0, yp = minY, i = x; y < nSquares; y++, i++, yp += yd) {
clists.push_back(glm::vec3(0, 1, 0));
clists.push_back(glm::vec3(0, 1, 0));
clists.push_back(glm::vec3(0, 1, 0));
clists.push_back(glm::vec3(0, 1, 0));
clists.push_back(glm::vec3(0, 1, 0));
clists.push_back(glm::vec3(0, 1, 0));
vlists.push_back(glm::vec3(xp, -0.1, yp));
vlists.push_back(glm::vec3(xp, -0.1, yp + yd));
vlists.push_back(glm::vec3(xp + xd, -0.1, yp + yd));
vlists.push_back(glm::vec3(xp, -0.1, yp));
vlists.push_back(glm::vec3(xp + xd, -0.1, yp + yd));
vlists.push_back(glm::vec3(xp + xd, -0.1, yp));
} // end of for j
}// end of for i
nvert2 = vlists.size();
//create vao
glGenVertexArrays(1, &vaoHandle);
glBindVertexArray(vaoHandle);
//create vbo for vertices
glGenBuffers(1, &vbo_cube_vertices);
glBindBuffer(GL_ARRAY_BUFFER, vbo_cube_vertices);
glBufferData(GL_ARRAY_BUFFER, sizeof(float)*vlists.size() * 3, vlists.data(), GL_STATIC_DRAW);
glVertexAttribPointer(
0, // attribute
3, // number of elements per vertex, here (x,y,z,1)
GL_FLOAT, // the type of each element
GL_FALSE, // take our values as-is
0, // no extra data between each position
0 // offset of first element
);
glEnableVertexAttribArray(0);
//create vbo for colors
glGenBuffers(1, &vbo_cube_colors);
glBindBuffer(GL_ARRAY_BUFFER, vbo_cube_colors);
glBufferData(GL_ARRAY_BUFFER, sizeof(float)*clists.size() * 3, clists.data(), GL_STATIC_DRAW);
glVertexAttribPointer(
1, // attribute
3, // number of elements per vertex, here (R,G,B)
GL_FLOAT, // the type of each element
GL_FALSE, // take our values as-is
0, // no extra data between each position
0 // offset of first element
);
glEnableVertexAttribArray(1);
vlists.clear();
clists.clear();
glBindVertexArray(0);
}
void Plane::resize(int size, int numcell)
{
setup(size, numcell);
}
void Plane::draw(ShaderProgram * shader, glm::mat4x4 proj_matrix, glm::mat4x4 view_matrix)
{
_model.glPushMatrix();
effectTransformations();
glBindVertexArray(vaoHandle);
glm::mat4 mvpMatrix = proj_matrix * view_matrix * _model.getMatrix();
glUniformMatrix4fv(shader->uniform("mvp"), 1, GL_FALSE, glm::value_ptr(mvpMatrix));
glm::mat4 modelview = view_matrix * _model.getMatrix();
shader->addUniform("LightLocation");
glUniform4fv(shader->uniform("LightLocation"), 1, glm::value_ptr(view_matrix * glm::vec4(0, 15, 0, 1)));
shader->addUniform("LightIntensity");
glUniform3fv(shader->uniform("LightIntensity"), 1, glm::value_ptr(glm::vec3(0.7, 0.7, 0.7)));
glUniformMatrix4fv(shader->uniform("ModelViewMatrix"), 1, GL_FALSE, glm::value_ptr(modelview));
glUniform4fv(shader->uniform("LightDirection"), 1, glm::value_ptr(view_matrix * glm::vec4(0, -15, 0, 1)));
glm::mat4 inverseModelView = glm::inverse(modelview);
glm::mat3 normalMatrix = glm::mat3(glm::transpose(inverseModelView));
glUniformMatrix3fv(shader->uniform("NormalMatrix"), 1, GL_FALSE, glm::value_ptr(normalMatrix));
glDrawArrays(GL_TRIANGLES, 0, nvert2 * 3);
glBindVertexArray(0);
_model.glPopMatrix();
}
DrawableType Plane::getType()
{
return DrawableType::LIGHTED_PLANE;
}

25
BaseGLProject/Plane.h
View File

@ -1,25 +0,0 @@
#pragma once
#include <GL/glew.h>
#include <GL/gl.h>
#include <glm/glm.hpp>
#include <vector>
#include "ADrawable.h"
#include "Loader.h"
class Plane : public ADrawable
{
public:
Plane(int size, int numcell);
virtual void draw(ShaderProgram * shader, glm::mat4x4 proj_matrix, glm::mat4x4 view_matrix) override;
virtual DrawableType getType() override;
void setup(float size, int nSquares);
void resize(int size, int numcell);
GLuint vaoHandle;
GLuint vbo_cube_vertices, vbo_cube_colors;
int size;
int ncell;
};

18
BaseGLProject/SceneContext.h Normal file
View File

@ -0,0 +1,18 @@
#pragma once
#include <map>
#include <glm/mat3x3.hpp>
#include <glm/mat4x4.hpp>
struct SceneContext
{
std::map<std::string, Light> lights;
std::map<std::string, float> floatValues;
glm::mat4x4 viewMatrix;
glm::mat4x4 projectionMatrix;
glm::mat4x4 mvpMatrix;
glm::mat4x4 modelViewMatrix;
glm::mat3x3 normalMatrix;
};

70
BaseGLProject/Shader.cpp Normal file
View File

@ -0,0 +1,70 @@
#include "Shader.h"
Shader::Shader(const std::string vtx_name, const std::string frag_name)
{
_program.initFromFiles(vtx_name, frag_name);
}
Shader::~Shader()
{
}
void Shader::enable()
{
_program.use();
}
void Shader::disable()
{
_program.disable();
}
void Shader::setMaterial(SceneContext ctx)
{
if ((uniformFlags & ShaderFlags::KA_FLAG) == ShaderFlags::KA_FLAG)
glUniform3fv(_program.addUniform("Ka"), 1, glm::value_ptr(mat.ka));
if ((uniformFlags & ShaderFlags::KD_FLAG) == ShaderFlags::KD_FLAG)
glUniform3fv(_program.addUniform("Kd"), 1, glm::value_ptr(mat.kd));
if ((uniformFlags & ShaderFlags::KS_FLAG) == ShaderFlags::KS_FLAG)
glUniform3fv(_program.addUniform("Ks"), 1, glm::value_ptr(mat.ks));
if ((uniformFlags & ShaderFlags::SHINE_FLAG) == ShaderFlags::SHINE_FLAG)
glUniform1f(_program.addUniform("Shininess"), mat.shininess);
}
void Shader::setCamera(SceneContext ctx)
{
if ((uniformFlags & ShaderFlags::MVP_FLAG) == ShaderFlags::MVP_FLAG)
glUniformMatrix4fv(_program.addUniform("mvp"), 1, GL_FALSE, glm::value_ptr(ctx.mvpMatrix));
if ((uniformFlags & ShaderFlags::NORMAL_MAT_FLAG) == ShaderFlags::NORMAL_MAT_FLAG)
glUniformMatrix3fv(_program.addUniform("NormalMatrix"), 1, GL_FALSE, glm::value_ptr(ctx.normalMatrix));
if ((uniformFlags & ShaderFlags::MODELVIEW_FLAG) == ShaderFlags::MODELVIEW_FLAG)
glUniformMatrix4fv(_program.addUniform("ModelViewMatrix"), 1, GL_FALSE, glm::value_ptr(ctx.modelViewMatrix));
}
void Shader::setLights(SceneContext ctx)
{
int i = 0;
if ((uniformFlags & ShaderFlags::LIGHTS_FLAG) != ShaderFlags::LIGHTS_FLAG)
return;
for (auto light: ctx.lights)
{
if (light.second.activated)
{
std::string lightname = "Light[" + std::to_string(i) + "].";
_program.addUniform(lightname + "Position");
glUniform4fv(_program.uniform(lightname + "Position"), 1, glm::value_ptr(ctx.viewMatrix * light.second.location));
_program.addUniform(lightname + "Intensity");
glUniform3fv(_program.uniform(lightname + "Intensity"), 1, glm::value_ptr(light.second.intensity));
i++;
}
}
_program.addUniform("LightCount");
glUniform1i(_program.uniform("LightCount"), i);
}
void Shader::setUniforms(SceneContext ctx)
{
setCamera(ctx);
setLights(ctx);
setMaterial(ctx);
}

50
BaseGLProject/Shader.h Normal file
View File

@ -0,0 +1,50 @@
#pragma once
#include <string>
#include <vector>
#include <memory>
#include <GL/glew.h>
#include "glm/gtc/type_ptr.hpp"
#include "Material.h"
#include "Light.h"
#include "SceneContext.h"
#include "Loader.h"
enum ShaderFlags
{
NO_UNIFORM = 0,
KD_FLAG = 1,
KA_FLAG = 2,
KS_FLAG = 4,
SHINE_FLAG = 8,
MVP_FLAG = 16,
NORMAL_MAT_FLAG = 32,
MODELVIEW_FLAG = 64,
LIGHTS_FLAG = 128,
};
class Shader
{
public:
Shader() {};
Shader(const std::string vtx_name, const std::string frag_name);
~Shader();
int uniformFlags = KD_FLAG | KA_FLAG | KS_FLAG | SHINE_FLAG | MVP_FLAG | NORMAL_MAT_FLAG | MODELVIEW_FLAG | LIGHTS_FLAG;
Material mat;
void enable();
void disable();
public:
void setUniforms(SceneContext ctx);
private:
void setMaterial(SceneContext ctx);
void setCamera(SceneContext ctx);
void setLights(SceneContext ctx);
private:
ShaderProgram _program;
};

191
BaseGLProject/Sphere.cpp
View File

@ -1,191 +0,0 @@
#include "Sphere.h"
#include <glm//gtc/constants.hpp>
#include <glm/vec3.hpp>
#include <glm/mat3x3.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/matrix_inverse.hpp>
Sphere::Sphere()
{
}
Sphere::~Sphere()
{
}
Sphere::Sphere(float rad, GLuint sl, GLuint st) :
radius(rad), slices(sl), stacks(st)
{
nVerts = (slices + 1) * (stacks + 1);
elements = (slices * 2 * (stacks - 1)) * 3;
// Verts
float * v = new float[3 * nVerts];
// Normals
float * n = new float[3 * nVerts];
// Tex coords
float * tex = new float[2 * nVerts]; //we don't use it now
// Index
unsigned int * el = new unsigned int[elements]; //index
// Generate the vertex data
generateVerts(v, n, tex, el);
//create vao, vbo and ibo here... (We didn't use std::vector here...)
glGenVertexArrays(1, &VAO);
glBindVertexArray(VAO);
glGenBuffers(1, &VBO_position);
glBindBuffer(GL_ARRAY_BUFFER, VBO_position);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 3 * nVerts, v, GL_STATIC_DRAW);
glVertexAttribPointer(
0, //attr number = 0
3,
GL_FLOAT,
GL_FALSE,
0,
(void*)0);
glEnableVertexAttribArray(0); //attr number = 0
glGenBuffers(1, &VBO_normal);
glBindBuffer(GL_ARRAY_BUFFER, VBO_normal);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 3 * nVerts, n, GL_STATIC_DRAW);
glVertexAttribPointer(
1,
3,
GL_FLOAT,
GL_FALSE,
0,
(void*)0);
glEnableVertexAttribArray(1);
glGenBuffers(1, &VBO_tex);
glBindBuffer(GL_ARRAY_BUFFER, VBO_tex);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 2 * nVerts, tex, GL_STATIC_DRAW);
glVertexAttribPointer(
2,
3,
GL_FLOAT,
GL_FALSE,
0,
(void*)0);
glEnableVertexAttribArray(2);
glGenBuffers(1, &IBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, elements * sizeof(GLuint), el, GL_STATIC_DRAW);
glBindVertexArray(0);
delete[] v;
delete[] n;
delete[] el;
delete[] tex;
}
void Sphere::draw(ShaderProgram *shader, glm::mat4x4 proj_matrix, glm::mat4x4 view_matrix)
{
_model.glPushMatrix();
effectTransformations();
glBindVertexArray(VAO);
glm::mat4 mvpMatrix = proj_matrix * view_matrix * _model.getMatrix();
glUniformMatrix4fv(shader->uniform("mvp"), 1, GL_FALSE, glm::value_ptr(mvpMatrix));
glm::mat4 modelview = view_matrix * _model.getMatrix();
glUniform4fv(shader->uniform("LightLocation"), 1, glm::value_ptr(view_matrix * glm::vec4(50, 50, 50, 1)));
glUniformMatrix4fv(shader->uniform("ModelViewMatrix"), 1, GL_FALSE, glm::value_ptr(modelview));
glm::mat4 inverseModelView = glm::inverse(modelview);
glm::mat3 normalMatrix = glm::mat3(glm::transpose(inverseModelView));
glUniformMatrix3fv(shader->uniform("NormalMatrix"), 1, GL_FALSE, glm::value_ptr(normalMatrix));
int size;
glGetBufferParameteriv(GL_ELEMENT_ARRAY_BUFFER, GL_BUFFER_SIZE, &size);
glDrawElements(GL_TRIANGLES, size / sizeof(GLuint), GL_UNSIGNED_INT, 0);
_model.glPopMatrix();
}
void Sphere::generateVerts(float * verts, float * norms, float * tex,
unsigned int * el)
{
// Generate positions and normals
GLfloat theta, phi;
GLfloat thetaFac = glm::two_pi<float>() / slices;
GLfloat phiFac = glm::pi<float>() / stacks;
GLfloat nx, ny, nz, s, t;
GLuint idx = 0, tIdx = 0;
for (GLuint i = 0; i <= slices; i++) {
theta = i * thetaFac;
s = (GLfloat)i / slices;
for (GLuint j = 0; j <= stacks; j++) {
phi = j * phiFac;
t = (GLfloat)j / stacks;
nx = sinf(phi) * cosf(theta);
ny = sinf(phi) * sinf(theta);
nz = cosf(phi);
verts[idx] = radius * nx; verts[idx + 1] = radius * ny; verts[idx + 2] = radius * nz;
norms[idx] = nx; norms[idx + 1] = ny; norms[idx + 2] = nz;
idx += 3;
tex[tIdx] = s;
tex[tIdx + 1] = t;
tIdx += 2;
}
}
// Generate the element list
idx = 0;
for (GLuint i = 0; i < slices; i++) {
GLuint stackStart = i * (stacks + 1);
GLuint nextStackStart = (i + 1) * (stacks + 1);
for (GLuint j = 0; j < stacks; j++) {
if (j == 0) {
el[idx] = stackStart;
el[idx + 1] = stackStart + 1;
el[idx + 2] = nextStackStart + 1;
idx += 3;
}
else if (j == stacks - 1) {
el[idx] = stackStart + j;
el[idx + 1] = stackStart + j + 1;
el[idx + 2] = nextStackStart + j;
idx += 3;
}
else {
el[idx] = stackStart + j;
el[idx + 1] = stackStart + j + 1;
el[idx + 2] = nextStackStart + j + 1;
el[idx + 3] = nextStackStart + j;
el[idx + 4] = stackStart + j;
el[idx + 5] = nextStackStart + j + 1;
idx += 6;
}
}
}
}
DrawableType Sphere::getType()
{
return DrawableType::SPHERE;
}
int Sphere::getVertexArrayHandle()
{
return this->VAO;
}

45
BaseGLProject/Sphere.h
View File

@ -1,45 +0,0 @@
#ifndef ___SPHERE_H
#define ___SPHERE_H
#include "GL/glew.h"
#include <GL/GL.h>
#include <glm/mat4x4.hpp>
#include <vector>
#include "ADrawable.h"
#include "Loader.h"
class Sphere : public ADrawable
{
public:
Sphere();
Sphere(float rad, GLuint sl, GLuint st);
~Sphere();
void draw(ShaderProgram *shader, glm::mat4x4 proj_matrix, glm::mat4x4 view_matrix);
int getVertexArrayHandle();
GLuint VAO, VBO_position, VBO_normal, VBO_tex, IBO;
private:
GLuint nVerts, elements;
float radius;
GLuint slices, stacks;
void generateVerts(float *, float *, float *, unsigned int *);
// Inherited via ADrawable
virtual DrawableType getType() override;
};
#endif

2
BaseGLProject/Viewer.cpp
View File

@ -200,6 +200,6 @@ void Viewer::getFrustrumInfo() {
m_imagePlaneHorizDir = glm::normalize(m_imagePlaneHorizDir); m_imagePlaneHorizDir = glm::normalize(m_imagePlaneHorizDir);
// Get the view plane width and height at the view center. // Get the view plane width and height at the view center.
m_displayHeight = 2.0 * glm::length(m_viewCenter-m_viewPoint) * tan(0.5*m_fieldOfView); m_displayHeight = float(2.0 * glm::length(m_viewCenter-m_viewPoint) * tan(0.5*m_fieldOfView));
m_displayWidth = m_displayHeight * m_aspectRatio; m_displayWidth = m_displayHeight * m_aspectRatio;
} }

67
BaseGLProject/WireCube.cpp
View File

@ -1,67 +0,0 @@
#include "WireCube.h"
void WireCube::setup()
{
_cube_vertices =
{ { -1.0, -1.0, 1.0}, { 1.0, -1.0, 1.0}, { 1.0, 1.0, 1.0},
{ -1.0, 1.0, 1.0}, { 1.0, 1.0, 1.0}, { -1.0, -1.0, 1.0},
{ -1.0, -1.0, -1.0}, { 1.0, -1.0, -1.0}, { 1.0, 1.0, -1.0},
{ -1.0, 1.0, -1.0}, { 1.0, 1.0, -1.0}, { -1.0, -1.0, -1.0},
{ -1.0, 1.0, -1.0}, { 1.0, 1.0, -1.0}, { 1.0, 1.0, 1.0},
{ -1.0, 1.0, 1.0}, { -1.0, 1.0, -1.0}, { 1.0, 1.0, -1.0},
{ -1.0, -1.0, -1.0}, { 1.0, -1.0, -1.0}, { 1.0, -1.0, 1.0},
{ -1.0, -1.0, 1.0}, { -1.0, -1.0, -1.0}, { 1.0, -1.0, -1.0},
{ -1.0, -1.0, -1.0}, { -1.0, -1.0, 1.0}, { -1.0, 1.0, 1.0},
{ -1.0, 1.0, -1.0}, { -1.0, -1.0, -1.0}, { -1.0, -1.0, 1.0},
{ 1.0, -1.0, -1.0}, { 1.0, -1.0, 1.0}, { 1.0, 1.0, 1.0},
{ 1.0, 1.0, -1.0}, { 1.0, -1.0, -1.0}, { 1.0, -1.0, 1.0}};
glGenVertexArrays(1, &_vaoHandle);
glBindVertexArray(_vaoHandle);
glGenBuffers(1, &_vbo_vertices);
glBindBuffer(GL_ARRAY_BUFFER, _vbo_vertices);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * _cube_vertices.size() * 3, _cube_vertices.data(), GL_STATIC_DRAW);
glVertexAttribPointer(
0, //attr number = 0
3,
GL_FLOAT,
GL_FALSE,
0,
(void*)0);
glEnableVertexAttribArray(0); //attr number = 0
}
WireCube::WireCube()
{
setup();
}
void WireCube::draw(ShaderProgram * shader, glm::mat4x4 proj_matrix, glm::mat4x4 view_matrix)
{
_model.glPushMatrix();
effectTransformations();
glm::mat4 mvpMatrix = proj_matrix * view_matrix * _model.getMatrix();
glUniformMatrix4fv(shader->uniform("mvp"), 1, GL_FALSE, glm::value_ptr(mvpMatrix));
glLineWidth(2);
glBindVertexArray(_vaoHandle);
for (int i = 0; i < _cube_vertices.size() * 3; i += 3)
glDrawArrays(GL_LINE_LOOP, i, 3);
_model.glPopMatrix();
}
DrawableType WireCube::getType()
{
return DrawableType::WIRE_CUBE;
}
WireCube::~WireCube()
{
}

27
BaseGLProject/WireCube.h
View File

@ -1,27 +0,0 @@
#pragma once
#include <iostream>
#include <string>
#include <vector>
#include <glm/vec4.hpp>
#include "ADrawable.h"
#pragma once
class WireCube : public ADrawable
{
private:
GLuint _vaoHandle;
GLuint _vbo_vertices, _vbo_colors;
std::vector<glm::vec3> _cube_vertices;
void setup();
public:
WireCube();
void draw(ShaderProgram *shader, glm::mat4x4 proj_matrix, glm::mat4x4 view_matrix) override;
DrawableType getType() override;
~WireCube();
};

206
BaseGLProject/teapotdata.h
View File

@ -1,206 +0,0 @@
#ifndef TEAPOTDATA_H
#define TEAPOTDATA_H
/* Copyright (c) Mark J. Kilgard, 1994. */
/**
(c) Copyright 1993, Silicon Graphics, Inc.
ALL RIGHTS RESERVED
Permission to use, copy, modify, and distribute this software
for any purpose and without fee is hereby granted, provided
that the above copyright notice appear in all copies and that
both the copyright notice and this permission notice appear in
supporting documentation, and that the name of Silicon
Graphics, Inc. not be used in advertising or publicity
pertaining to distribution of the software without specific,
written prior permission.
THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU
"AS-IS" AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR
OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. IN NO
EVENT SHALL SILICON GRAPHICS, INC. BE LIABLE TO YOU OR ANYONE
ELSE FOR ANY DIRECT, SPECIAL, INCIDENTAL, INDIRECT OR
CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER,
INCLUDING WITHOUT LIMITATION, LOSS OF PROFIT, LOSS OF USE,
SAVINGS OR REVENUE, OR THE CLAIMS OF THIRD PARTIES, WHETHER OR
NOT SILICON GRAPHICS, INC. HAS BEEN ADVISED OF THE POSSIBILITY
OF SUCH LOSS, HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
ARISING OUT OF OR IN CONNECTION WITH THE POSSESSION, USE OR
PERFORMANCE OF THIS SOFTWARE.
US Government Users Restricted Rights
Use, duplication, or disclosure by the Government is subject to
restrictions set forth in FAR 52.227.19(c)(2) or subparagraph
(c)(1)(ii) of the Rights in Technical Data and Computer
Software clause at DFARS 252.227-7013 and/or in similar or
successor clauses in the FAR or the DOD or NASA FAR
Supplement. Unpublished-- rights reserved under the copyright
laws of the United States. Contractor/manufacturer is Silicon
Graphics, Inc., 2011 N. Shoreline Blvd., Mountain View, CA
94039-7311.
OpenGL(TM) is a trademark of Silicon Graphics, Inc.
*/
/* Rim, body, lid, and bottom data must be reflected in x and
y; handle and spout data across the y axis only. */
namespace Teapot {
static int patchdata[][16] =
{
/* rim */
{102, 103, 104, 105, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
/* body */
{12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27},
{24, 25, 26, 27, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40},
/* lid */
{96, 96, 96, 96, 97, 98, 99, 100, 101, 101, 101, 101, 0, 1, 2, 3,},
{0, 1, 2, 3, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117},
/* bottom */
{118, 118, 118, 118, 124, 122, 119, 121, 123, 126, 125, 120, 40, 39, 38, 37},
/* handle */
{41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56},
{53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 28, 65, 66, 67},
/* spout */
{68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83},
{80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95}
};
static float cpdata[][3] =
{
{0.2f, 0.f, 2.7f},
{0.2f, -0.112f, 2.7f},
{0.112f, -0.2f, 2.7f},
{0.f, -0.2f, 2.7f},
{1.3375f, 0.f, 2.53125f},
{1.3375f, -0.749f, 2.53125f},
{0.749f, -1.3375f, 2.53125f},
{0.f, -1.3375f, 2.53125f},
{1.4375f, 0.f, 2.53125f},
{1.4375f, -0.805f, 2.53125f},
{0.805f, -1.4375f, 2.53125f},
{0.f, -1.4375f, 2.53125f},
{1.5f, 0.f, 2.4f},
{1.5f, -0.84f, 2.4f},
{0.84f, -1.5f, 2.4f},
{0.f, -1.5f, 2.4f},
{1.75f, 0.f, 1.875f},
{1.75f, -0.98f, 1.875f},
{0.98f, -1.75f, 1.875f},
{0.f, -1.75f, 1.875f},
{2.f, 0.f, 1.35f},
{2.f, -1.12f, 1.35f},
{1.12f, -2.f, 1.35f},
{0.f, -2.f, 1.35f},
{2.f, 0.f, 0.9f},
{2.f, -1.12f, 0.9f},
{1.12f, -2.f, 0.9f},
{0.f, -2.f, 0.9f},
{-2.f, 0.f, 0.9f},
{2.f, 0.f, 0.45f},
{2.f, -1.12f, 0.45f},
{1.12f, -2.f, 0.45f},
{0.f, -2.f, 0.45f},
{1.5f, 0.f, 0.225f},
{1.5f, -0.84f, 0.225f},
{0.84f, -1.5f, 0.225f},
{0.f, -1.5f, 0.225f},
{1.5f, 0.f, 0.15f},
{1.5f, -0.84f, 0.15f},
{0.84f, -1.5f, 0.15f},
{0.f, -1.5f, 0.15f},
{-1.6f, 0.f, 2.025f},
{-1.6f, -0.3f, 2.025f},
{-1.5f, -0.3f, 2.25f},
{-1.5f, 0.f, 2.25f},
{-2.3f, 0.f, 2.025f},
{-2.3f, -0.3f, 2.025f},
{-2.5f, -0.3f, 2.25f},
{-2.5f, 0.f, 2.25f},
{-2.7f, 0.f, 2.025f},
{-2.7f, -0.3f, 2.025f},
{-3.f, -0.3f, 2.25f},
{-3.f, 0.f, 2.25f},
{-2.7f, 0.f, 1.8f},
{-2.7f, -0.3f, 1.8f},
{-3.f, -0.3f, 1.8f},
{-3.f, 0.f, 1.8f},
{-2.7f, 0.f, 1.575f},
{-2.7f, -0.3f, 1.575f},
{-3.f, -0.3f, 1.35f},
{-3.f, 0.f, 1.35f},
{-2.5f, 0.f, 1.125f},
{-2.5f, -0.3f, 1.125f},
{-2.65f, -0.3f, 0.9375f},
{-2.65f, 0.f, 0.9375f},
{-2.f, -0.3f, 0.9f},
{-1.9f, -0.3f, 0.6f},
{-1.9f, 0.f, 0.6f},
{1.7f, 0.f, 1.425f},
{1.7f, -0.66f, 1.425f},
{1.7f, -0.66f, 0.6f},
{1.7f, 0.f, 0.6f},
{2.6f, 0.f, 1.425f},
{2.6f, -0.66f, 1.425f},
{3.1f, -0.66f, 0.825f},
{3.1f, 0.f, 0.825f},
{2.3f, 0.f, 2.1f},
{2.3f, -0.25f, 2.1f},
{2.4f, -0.25f, 2.025f},
{2.4f, 0.f, 2.025f},
{2.7f, 0.f, 2.4f},
{2.7f, -0.25f, 2.4f},
{3.3f, -0.25f, 2.4f},
{3.3f, 0.f, 2.4f},
{2.8f, 0.f, 2.475f},
{2.8f, -0.25f, 2.475f},
{3.525f, -0.25f, 2.49375f},
{3.525f, 0.f, 2.49375f},
{2.9f, 0.f, 2.475f},
{2.9f, -0.15f, 2.475f},
{3.45f, -0.15f, 2.5125f},
{3.45f, 0.f, 2.5125f},
{2.8f, 0.f, 2.4f},
{2.8f, -0.15f, 2.4f},
{3.2f, -0.15f, 2.4f},
{3.2f, 0.f, 2.4f},
{0.f, 0.f, 3.15f},
{0.8f, 0.f, 3.15f},
{0.8f, -0.45f, 3.15f},
{0.45f, -0.8f, 3.15f},
{0.f, -0.8f, 3.15f},
{0.f, 0.f, 2.85f},
{1.4f, 0.f, 2.4f},
{1.4f, -0.784f, 2.4f},
{0.784f, -1.4f, 2.4f},
{0.f, -1.4f, 2.4f},
{0.4f, 0.f, 2.55f},
{0.4f, -0.224f, 2.55f},
{0.224f, -0.4f, 2.55f},
{0.f, -0.4f, 2.55f},
{1.3f, 0.f, 2.55f},
{1.3f, -0.728f, 2.55f},
{0.728f, -1.3f, 2.55f},
{0.f, -1.3f, 2.55f},
{1.3f, 0.f, 2.4f},
{1.3f, -0.728f, 2.4f},
{0.728f, -1.3f, 2.4f},
{0.f, -1.3f, 2.4f},
{0.f, 0.f, 0.f},
{1.425f, -0.798f, 0.f},
{1.5f, 0.f, 0.075f},
{1.425f, 0.f, 0.f},
{0.798f, -1.425f, 0.f},
{0.f, -1.5f, 0.075f},
{0.f, -1.425f, 0.f},
{1.5f, -0.84f, 0.075f},
{0.84f, -1.5f, 0.075f}
};
}
#endif // TEAPOTDATA_H

9
BaseGLProject/toon.frag
View File

@ -13,8 +13,8 @@ struct LightInfo {
vec3 Intensity; vec3 Intensity;
}; };
uniform LightInfo Light[5]; uniform LightInfo Light[64];
uniform int LightCount;
in vec3 fNormal; in vec3 fNormal;
in vec3 pos; in vec3 pos;
@ -26,7 +26,7 @@ void main()
vec3 ambient; vec3 ambient;
ambient = Ka * Light[0].Intensity; ambient = Ka * Light[0].Intensity;
for (int i=0; i<5; i++) for (int i=0; i< LightCount; i++)
{ {
vec3 L = normalize(Light[i].Position.xyz - pos); vec3 L = normalize(Light[i].Position.xyz - pos);
vec3 N = fNormal; vec3 N = fNormal;
@ -44,8 +44,9 @@ void main()
vec3 diffuse = Kd * Light[i].Intensity * max(dot(L, N), 0.0) * value; vec3 diffuse = Kd * Light[i].Intensity * max(dot(L, N), 0.0) * value;
// Not needed for cartoon shader // Not needed for cartoon shader
vec3 specular = Ks * Light[i].Intensity * pow(max(dot(H, N), 0.0), Shininess); //vec3 specular = Ks * Light[i].Intensity * pow(max(dot(H, N), 0.0), Shininess);
//dirty trick to stay with the same shader params
finalColor = finalColor + diffuse; finalColor = finalColor + diffuse;
} }

326
BaseGLProject/vboteapot.cpp
View File

@ -1,326 +0,0 @@
#include "vboteapot.h"
#include "teapotdata.h"
#include <GL/glew.h>
#include <GL/gl.h>
#include <cstdio>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/matrix_inverse.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <glm/gtc/constants.hpp>
//set grid = 64, lidTransform = 4x4 identity matrix
VBOTeapot::VBOTeapot(int grid, mat4 lidTransform)
{
int verts = 32 * (grid + 1) * (grid + 1);
faces = grid * grid * 32;
float * v = new float[ verts * 3 ]; //vertex positions : vec3
float * n = new float[ verts * 3 ]; //vertex normals : vec3
float * tc = new float[ verts * 2 ]; //texture coordinates : vec2 (we don't use it at this point)
unsigned int * el = new unsigned int[faces * 6]; //indices for IBO
generatePatches(v, n, tc, el, grid);
glGenVertexArrays(1, &VAO);
glBindVertexArray(VAO);
glGenBuffers(1, &VBO_position);
glBindBuffer(GL_ARRAY_BUFFER, VBO_position);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 3 * verts, v, GL_STATIC_DRAW);
glVertexAttribPointer(
0, //attr number = 0
3,
GL_FLOAT,
GL_FALSE,
0,
(void*)0);
glEnableVertexAttribArray(0); //attr number = 0
glGenBuffers(1, &VBO_normal);
glBindBuffer(GL_ARRAY_BUFFER, VBO_normal);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 3 * verts, n, GL_STATIC_DRAW);
glVertexAttribPointer(
1,
3,
GL_FLOAT,
GL_FALSE,
0,
(void*)0);
glEnableVertexAttribArray(1);
glGenBuffers(1, &VBO_tex);
glBindBuffer(GL_ARRAY_BUFFER, VBO_tex);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 2 * verts, tc, GL_STATIC_DRAW);
glVertexAttribPointer(
2,
3,
GL_FLOAT,
GL_FALSE,
0,
(void*)0);
glEnableVertexAttribArray(2);
glGenBuffers(1, &IBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, faces * 6 * sizeof(GLuint), el, GL_STATIC_DRAW);
glBindVertexArray(0);
delete [] v;
delete [] n;
delete [] el;
delete [] tc;
}
void VBOTeapot::draw(ShaderProgram * shader, glm::mat4x4 proj_matrix, glm::mat4x4 view_matrix)
{
_model.glPushMatrix();
effectTransformations();
glBindVertexArray(VAO);
glm::mat4 mvpMatrix = proj_matrix * view_matrix * _model.getMatrix();
glUniformMatrix4fv(shader->uniform("mvp"), 1, GL_FALSE, glm::value_ptr(mvpMatrix));
glm::mat4 modelview = view_matrix * _model.getMatrix();
glUniform4fv(shader->uniform("LightLocation"), 1, glm::value_ptr(view_matrix * glm::vec4(50, 50, 50, 1)));
glUniformMatrix4fv(shader->uniform("ModelViewMatrix"), 1, GL_FALSE, glm::value_ptr(modelview));
glm::mat4 inverseModelView = glm::inverse(modelview);
glm::mat3 normalMatrix = glm::mat3(glm::transpose(inverseModelView));
glUniformMatrix3fv(shader->uniform("NormalMatrix"), 1, GL_FALSE, glm::value_ptr(normalMatrix));
int size;
glGetBufferParameteriv(GL_ELEMENT_ARRAY_BUFFER, GL_BUFFER_SIZE, &size);
glDrawElements(GL_TRIANGLES, size / sizeof(GLuint), GL_UNSIGNED_INT, 0);
_model.glPopMatrix();
}
DrawableType VBOTeapot::getType()
{
return DrawableType::TEAPOT;
}
void VBOTeapot::generatePatches(float * v, float * n, float * tc, unsigned int* el, int grid) {
float * B = new float[4*(grid+1)]; // Pre-computed Bernstein basis functions
float * dB = new float[4*(grid+1)]; // Pre-computed derivitives of basis functions
int idx = 0, elIndex = 0, tcIndex = 0;
// Pre-compute the basis functions (Bernstein polynomials)
// and their derivatives
computeBasisFunctions(B, dB, grid);
// Build each patch
// The rim
buildPatchReflect(0, B, dB, v, n, tc, el, idx, elIndex, tcIndex, grid, true, true);
// The body
buildPatchReflect(1, B, dB, v, n, tc, el, idx, elIndex, tcIndex, grid, true, true);
buildPatchReflect(2, B, dB, v, n, tc, el, idx, elIndex, tcIndex, grid, true, true);
// The lid
buildPatchReflect(3, B, dB, v, n, tc, el, idx, elIndex, tcIndex, grid, true, true);
buildPatchReflect(4, B, dB, v, n, tc, el, idx, elIndex, tcIndex, grid, true, true);
// The bottom
buildPatchReflect(5, B, dB, v, n, tc, el, idx, elIndex, tcIndex, grid, true, true);
// The handle
buildPatchReflect(6, B, dB, v, n, tc, el, idx, elIndex, tcIndex, grid, false, true);
buildPatchReflect(7, B, dB, v, n, tc, el, idx, elIndex, tcIndex, grid, false, true);
// The spout
buildPatchReflect(8, B, dB, v, n, tc, el, idx, elIndex, tcIndex, grid, false, true);
buildPatchReflect(9, B, dB, v, n, tc, el, idx, elIndex, tcIndex, grid, false, true);
delete [] B;
delete [] dB;
}
void VBOTeapot::moveLid(int grid, float *v, mat4 lidTransform) {
int start = 3 * 12 * (grid+1) * (grid+1);
int end = 3 * 20 * (grid+1) * (grid+1);
for( int i = start; i < end; i+=3 )
{
vec4 vert = vec4(v[i], v[i+1], v[i+2], 1.0f );
vert = lidTransform * vert;
v[i] = vert.x;
v[i+1] = vert.y;
v[i+2] = vert.z;
}
}
void VBOTeapot::buildPatchReflect(int patchNum,
float *B, float *dB,
float *v, float *n,
float *tc, unsigned int *el,
int &index, int &elIndex, int &tcIndex, int grid,
bool reflectX, bool reflectY)
{
vec3 patch[4][4];
vec3 patchRevV[4][4];
getPatch(patchNum, patch, false);
getPatch(patchNum, patchRevV, true);
// Patch without modification
buildPatch(patch, B, dB, v, n, tc, el,
index, elIndex, tcIndex, grid, mat3(1.0f), true);
// Patch reflected in x
if( reflectX ) {
buildPatch(patchRevV, B, dB, v, n, tc, el,
index, elIndex, tcIndex, grid, mat3(vec3(-1.0f, 0.0f, 0.0f),
vec3(0.0f, 1.0f, 0.0f),
vec3(0.0f, 0.0f, 1.0f) ), false );
}
// Patch reflected in y
if( reflectY ) {
buildPatch(patchRevV, B, dB, v, n, tc, el,
index, elIndex, tcIndex, grid, mat3(vec3(1.0f, 0.0f, 0.0f),
vec3(0.0f, -1.0f, 0.0f),
vec3(0.0f, 0.0f, 1.0f) ), false );
}
// Patch reflected in x and y
if( reflectX && reflectY ) {
buildPatch(patch, B, dB, v, n, tc, el,
index, elIndex, tcIndex, grid, mat3(vec3(-1.0f, 0.0f, 0.0f),
vec3(0.0f, -1.0f, 0.0f),
vec3(0.0f, 0.0f, 1.0f) ), true );
}
}
void VBOTeapot::buildPatch(vec3 patch[][4],
float *B, float *dB,
float *v, float *n, float *tc,
unsigned int *el,
int &index, int &elIndex, int &tcIndex, int grid, mat3 reflect,
bool invertNormal)
{
int startIndex = index / 3;
float tcFactor = 1.0f / grid;
for( int i = 0; i <= grid; i++ )
{
for( int j = 0 ; j <= grid; j++)
{
vec3 pt = reflect * evaluate(i,j,B,patch);
vec3 norm = reflect * evaluateNormal(i,j,B,dB,patch);
if( invertNormal )
norm = -norm;
v[index] = pt.x;
v[index+1] = pt.y;
v[index+2] = pt.z;
n[index] = norm.x;
n[index+1] = norm.y;
n[index+2] = norm.z;
tc[tcIndex] = i * tcFactor;
tc[tcIndex+1] = j * tcFactor;
index += 3;
tcIndex += 2;
}
}
for( int i = 0; i < grid; i++ )
{
int iStart = i * (grid+1) + startIndex;
int nextiStart = (i+1) * (grid+1) + startIndex;
for( int j = 0; j < grid; j++)
{
el[elIndex] = iStart + j;
el[elIndex+1] = nextiStart + j + 1;
el[elIndex+2] = nextiStart + j;
el[elIndex+3] = iStart + j;
el[elIndex+4] = iStart + j + 1;
el[elIndex+5] = nextiStart + j + 1;
elIndex += 6;
}
}
}
void VBOTeapot::getPatch( int patchNum, vec3 patch[][4], bool reverseV )
{
for( int u = 0; u < 4; u++) { // Loop in u direction
for( int v = 0; v < 4; v++ ) { // Loop in v direction
if( reverseV ) {
patch[u][v] = vec3(
Teapot::cpdata[Teapot::patchdata[patchNum][u*4+(3-v)]][0],
Teapot::cpdata[Teapot::patchdata[patchNum][u*4+(3-v)]][1],
Teapot::cpdata[Teapot::patchdata[patchNum][u*4+(3-v)]][2]
);
} else {
patch[u][v] = vec3(
Teapot::cpdata[Teapot::patchdata[patchNum][u*4+v]][0],
Teapot::cpdata[Teapot::patchdata[patchNum][u*4+v]][1],
Teapot::cpdata[Teapot::patchdata[patchNum][u*4+v]][2]
);
}
}
}
}
void VBOTeapot::computeBasisFunctions( float * B, float * dB, int grid ) {
float inc = 1.0f / grid;
for( int i = 0; i <= grid; i++ )
{
float t = i * inc;
float tSqr = t * t;
float oneMinusT = (1.0f - t);
float oneMinusT2 = oneMinusT * oneMinusT;
B[i*4 + 0] = oneMinusT * oneMinusT2;
B[i*4 + 1] = 3.0f * oneMinusT2 * t;
B[i*4 + 2] = 3.0f * oneMinusT * tSqr;
B[i*4 + 3] = t * tSqr;
dB[i*4 + 0] = -3.0f * oneMinusT2;
dB[i*4 + 1] = -6.0f * t * oneMinusT + 3.0f * oneMinusT2;
dB[i*4 + 2] = -3.0f * tSqr + 6.0f * t * oneMinusT;
dB[i*4 + 3] = 3.0f * tSqr;
}
}
vec3 VBOTeapot::evaluate( int gridU, int gridV, float *B, vec3 patch[][4] )
{
vec3 p(0.0f,0.0f,0.0f);
for( int i = 0; i < 4; i++) {
for( int j = 0; j < 4; j++) {
p += patch[i][j] * B[gridU*4+i] * B[gridV*4+j];
}
}
return p;
}
vec3 VBOTeapot::evaluateNormal( int gridU, int gridV, float *B, float *dB, vec3 patch[][4] )
{
vec3 du(0.0f,0.0f,0.0f);
vec3 dv(0.0f,0.0f,0.0f);
for( int i = 0; i < 4; i++) {
for( int j = 0; j < 4; j++) {
du += patch[i][j] * dB[gridU*4+i] * B[gridV*4+j];
dv += patch[i][j] * B[gridU*4+i] * dB[gridV*4+j];
}
}
return glm::normalize( glm::cross( du, dv ) );
}

52
BaseGLProject/vboteapot.h
View File

@ -1,52 +0,0 @@
#ifndef VBOTEAPOT_H
#define VBOTEAPOT_H
#include <GL/glew.h>
#include <GL/gl.h>
#include <glm/glm.hpp>
#include "ADrawable.h"
#include "Loader.h"
using glm::vec4;
using glm::vec3;
using glm::mat3;
using glm::mat4;
class VBOTeapot : public ADrawable
{
private:
GLuint VAO, VBO_position, VBO_normal, VBO_tex, IBO;
unsigned int faces;
void generatePatches(float * v, float * n, float *tc, unsigned int* el, int grid);
void buildPatchReflect(int patchNum,
float *B, float *dB,
float *v, float *n, float *, unsigned int *el,
int &index, int &elIndex, int &, int grid,
bool reflectX, bool reflectY);
void buildPatch(vec3 patch[][4],
float *B, float *dB,
float *v, float *n,float *, unsigned int *el,
int &index, int &elIndex, int &, int grid, mat3 reflect, bool invertNormal);
void getPatch( int patchNum, vec3 patch[][4], bool reverseV );
void computeBasisFunctions( float * B, float * dB, int grid );
vec3 evaluate( int gridU, int gridV, float *B, vec3 patch[][4] );
vec3 evaluateNormal( int gridU, int gridV, float *B, float *dB, vec3 patch[][4] );
void moveLid(int,float *,mat4);
public:
VBOTeapot(int grid, mat4 lidTransform);
// Inherited via ADrawable
virtual void draw(ShaderProgram * shader, glm::mat4x4 proj_matrix, glm::mat4x4 view_matrix) override;
virtual DrawableType getType() override;
};
#endif // VBOTEAPOT_H