// Build a GLSL program from source code
Program buildProgram(const GLchar* vsSrc, const GLchar* fsSrc) {
Shader vs(GL_VERTEX_SHADER);
vs.setSource(vsSrc);
if(!vs.compile()) {
throw std::runtime_error("Compilation error for vertex shader: " + vs.getInfoLog());
}
Shader fs(GL_FRAGMENT_SHADER);
fs.setSource(fsSrc);
if(!fs.compile()) {
throw std::runtime_error("Compilation error for fragment shader: " + fs.getInfoLog());
}
Program program;
program.attachShader(vs);
program.attachShader(fs);
if(!program.link()) {
throw std::runtime_error("Link error: " + program.getInfoLog());
}
return program;
}
// Load source code from files and build a GLSL program
Program * loadProgram(const FilePath& vsFile, const FilePath& fsFile) {
Shader vs = loadShader(GL_VERTEX_SHADER, vsFile);
Shader fs = loadShader(GL_FRAGMENT_SHADER, fsFile);
if(!vs.compile()) {
throw std::runtime_error("Compilation error for vertex shader (from file " + std::string(vsFile) + "): " + vs.getInfoLog());
}
if(!fs.compile()) {
throw std::runtime_error("Compilation error for fragment shader (from file " + std::string(fsFile) + "): " + fs.getInfoLog());
}
Program * program = new Program;
program->attachShader(vs);
program->attachShader(fs);
if(!program->link()) {
throw std::runtime_error("Link error (for files " + vsFile.str() + " and " + fsFile.str() + "): " + program->getInfoLog());
}
return program;
}
int main(int, char**)
{
int width = 1080;
int height = 900;
if (!glfwInit()){ std::cout << "ERROR: glfwInit failed\n"; return -1; }
GLFWwindow* window = glfwCreateWindow(width, height, "mesh", NULL, NULL);
if (!window){ std::cout << "ERROR: window was not created\n"; return -1; }
glfwMakeContextCurrent(window);
glewExperimental = GL_TRUE;
glewInit();
versionPrint();
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
//glEnable(GL_CULL_FACE);
GUI gui;
gui.Init(window, false);
float vertices[] = {
-0.5, -0.5, 0,
-0.5, 0.5, 0,
0.5, 0.5, 0,
/////////////////////
-0.5, -0.5, 0,
0.5, 0.5, 0,
0.5, -0.5, 0
};
//////////////////////////////////
//OBJECT LOADING
std::string resourcePath = "../../../resources/";
//std::string inputfile = resourcePath + "teapot/teapot.obj";
//std::string mtlfile = resourcePath + "teapot/teapot.mtl";
//std::string inputfile = resourcePath + "sphere/sphere.obj";
//std::string mtlfile = resourcePath + "sphere/sphere.mtl";
std::string inputfile = resourcePath + "dragon/dragon.obj";
//std::string inputfile = resourcePath + "monkey/monkey.obj";
//std::string mtlfile = resourcePath + "monkey/monkey.mtl";
std::vector<tinyobj::shape_t> shapes;
std::vector<tinyobj::material_t> materials;
std::string err;
if (!tinyobj::LoadObj(shapes, materials, err, inputfile.c_str()))
std::cerr << err << std::endl;
std::cout << "# of shapes : " << shapes.size() << std::endl;
std::cout << "# of materials : " << materials.size() << std::endl;
//OBJECT LOADING
//////////////////////////////////
glm::vec3 cpos = glm::vec3(0.0f, 0.0f, 10.0f);
glm::mat4 view;
view = glm::lookAt( cpos,
glm::vec3(0.0f, 0.0f, 0.0f),
glm::vec3(0.0f, 1.0f, 0.0f));
glm::mat4 projection = glm::perspective(45.0f, (float)width/(float)height, 0.01f, 1000.0f);
glm::mat4 model = glm::mat4();
float s = 1.0f;
model = glm::scale(model, glm::vec3(s, s, s));
std::string shaderPath = "../../../source/shaders/";
Program shaderProgram;
Shader vshader(shaderPath + "vertexShader.glsl", GL_VERTEX_SHADER);
Shader fshader(shaderPath + "fragmentShader.glsl", GL_FRAGMENT_SHADER);
shaderProgram.attachShader(&vshader);
shaderProgram.attachShader(&fshader);
shaderProgram.linkProgram();
GLuint elems;
glGenBuffers(1, &elems);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elems);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, shapes[0].mesh.indices.size() * sizeof(unsigned int), &(shapes[0].mesh.indices[0]), GL_STATIC_DRAW);
GLuint vbo;
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, shapes[0].mesh.positions.size() * sizeof(float), &(shapes[0].mesh.positions[0]), GL_STATIC_DRAW);
GLuint nbo;
glGenBuffers(1, &nbo);
glBindBuffer(GL_ARRAY_BUFFER, nbo);
glBufferData(GL_ARRAY_BUFFER, shapes[0].mesh.normals.size() * sizeof(float), &(shapes[0].mesh.normals[0]), GL_STATIC_DRAW);
GLuint vao;
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glEnableVertexAttribArray(0);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, NULL);
glEnableVertexAttribArray(1);
glBindBuffer(GL_ARRAY_BUFFER, nbo);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, NULL);
GLuint ModelMatrixHandle = glGetUniformLocation(shaderProgram.getID(), "ModelMatrix");
GLuint ViewMatrixHandle = glGetUniformLocation(shaderProgram.getID(), "ViewMatrix");
GLuint ProjectionMatrixHandle = glGetUniformLocation(shaderProgram.getID(), "ProjectionMatrix");
glUniformMatrix4fv(ModelMatrixHandle, 1, GL_FALSE, glm::value_ptr(model));
glUniformMatrix4fv(ViewMatrixHandle, 1, GL_FALSE, glm::value_ptr(view));
glUniformMatrix4fv(ProjectionMatrixHandle, 1, GL_FALSE, glm::value_ptr(projection));
glClearColor(0.3, 0.3, 0.3, 1.0);
while (!glfwWindowShouldClose(window)){
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
shaderProgram.use();
glBindVertexArray(vao);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elems);
model = glm::rotate(model, 0.0001f, glm::vec3(0, 1, 0));
glUniformMatrix4fv(ModelMatrixHandle, 1, GL_FALSE, glm::value_ptr(model));
glUniformMatrix4fv(ViewMatrixHandle, 1, GL_FALSE, glm::value_ptr(view));
glUniformMatrix4fv(ProjectionMatrixHandle, 1, GL_FALSE, glm::value_ptr(projection));
glDrawElements(GL_TRIANGLES, shapes[0].mesh.indices.size(),GL_UNSIGNED_INT,(void*)0);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
gui.Render(&shapes);
glfwSwapBuffers(window);
glfwPollEvents();
}
return 0;
}
int main() {
Graphics::Window window("title", Vector2<int>(1800, 960));
FileSystem fs;
this_thread::sleep_for(std::chrono::seconds(1));
auto cube = MeshLoader::loadOBJ(&fs.getFile("scene/monkey.obj"));
Transformation camera;
Projection projection(0.01f, 1000.0f, 45, window.getAspect());
Transformation model;
Transformation light_t;
camera.setPosition({0 , 0 , .7f});
GLenum err;
// TEST
// cbuffer is deleted after being passed as rvalue
auto tex = TextureLoader::loadTexture(fs.getFile("textures/box.bmp"));
if (tex == nullptr || cube == nullptr) {
return 1;
}
GLuint vbo = 0;
GLuint sampler = 0;
cube->bind();
Shader vert(fs.getFile("shaders/shader.vert"), GL_VERTEX_SHADER);
Shader frag(fs.getFile("shaders/shader.frag"), GL_FRAGMENT_SHADER);
if ((err = glGetError()) != GL_NO_ERROR)
return err;
Program program;
program.attachShader(vert);
program.attachShader(frag);
program.link();
program.use();
VertexArray vao;
vao.bind();
vao.setVertexAttribute(program, "in_normal", cube->getObjects().at(0).normalSize(), GL_FLOAT, GL_FALSE, cube->getObjects().at(0).stride(), cube->getObjects().at(0).normalOffset());
vao.setVertexAttribute(program, "position", cube->getObjects().at(0).vertexSize(), GL_FLOAT, GL_FALSE, cube->getObjects().at(0).stride(), cube->getObjects().at(0).vertexOffset());
vao.setVertexAttribute(program, "in_tex", cube->getObjects().at(0).texCoordSize(), GL_FLOAT, GL_FALSE, cube->getObjects().at(0).stride(), cube->getObjects().at(0).texCoordOffset());
vao.unbind();
program.setUniform("world_pos", Vector3<float>(.5, 0, 0));
glActiveTexture(GL_TEXTURE0);
tex->bind();
LightPoint point;
point.position = { 2, 0, 0 };
point.color = { 1, 1, 1 };
point.intensity = 0.4f;
point.attenuation = 10;
light_t.setPosition(Vector3<float>(2, 1, 0));
Lighting lights;
LightPoint& light = lights.attachLight(point);
lights.setAmbient(Vector3<float>(1.0f, 1.0f, 1.0f));
float pos = 0;
Vector3<float> rotation(0);
while (false) {
window.startFrame();
vao.bind();
//camera.rotate({ 0, 0, 0.01f });
//window.getMouse().getMousePosition<float>(&light.position.x, &light.position.y);
light_t.setPosition(light.position);
model.setScale({ 0.1f, 0.1f, 0.1f });
model.setPosition({ 0, -0.5f, 0 });
std::this_thread::sleep_for(std::chrono::milliseconds(16));
program.setUniform("model", model.getMatrix());
program.setUniform("view", camera.getMatrix());
program.setUniform("projection", projection.getPerspective());
lights.bindLights(program);
program.setUniform("normal_matrix", model.getNormalMatrix());
cube->bind();
for (const auto& obj : cube->getObjects()){
program.setUniform("has_normal", obj.hasNormals());
program.setUniform("has_tex_coord", obj.hasTexCoord());
glDrawElements(obj.getMode(), obj.size, GL_UNSIGNED_INT, obj.p_start);
}
vao.unbind();
if (window.getKeyboard().isKeyDown(KEY::KEY_W) != KEY_PRESSED::RELEASED)
rotation.x += 0.1f;
if (window.getKeyboard().isKeyDown(KEY::KEY_D) != KEY_PRESSED::RELEASED)
rotation.y += 0.1f;
model.setRotation(rotation);
window.endFrame();
}
}
int main() {
Graphics::Window window("scene", { 800, 600 });
Util::FileSystem fs;
fs.setRootDir("");
auto scene = MeshLoader::loadOBJ(&fs.getFile("scene/scene.obj"));
auto tex = TextureLoader::loadTexture(&fs.getFile("scene/Wall.bmp"));
Shader vert(fs.getFile("shaders/shader.vert"), GL_VERTEX_SHADER);
Shader frag(fs.getFile("shaders/shader.frag"), GL_FRAGMENT_SHADER);
GLuint err = 0;
if ((err = glGetError()) != GL_NO_ERROR)
return err;
Program program;
program.attachShader(vert);
program.attachShader(frag);
program.link();
program.use();
// Get a good error if this hasn't been bound.
scene->bind();
VertexArray vao;
vao.bind();
vao.setVertexAttribute(program, "in_normal", scene->normalSize(), GL_FLOAT, GL_FALSE, scene->stride(), scene->normalOffset());
vao.setVertexAttribute(program, "position", scene->vertexSize(), GL_FLOAT, GL_FALSE, scene->stride(), scene->vertexOffset());
vao.setVertexAttribute(program, "in_tex", scene->texCoordSize(), GL_FLOAT, GL_FALSE, scene->stride(), scene->texCoordOffset());
vao.unbind();
program.setUniform("has_normal", scene->hasNormals());
program.setUniform("has_tex_coord", scene->hasTexCoord());
program.setUniform("world_pos", Vector3<float>(.5, 0, 0));
glActiveTexture(GL_TEXTURE0);
tex->bind();
LightPoint point;
point.position = { 2, 0, 0 };
point.color = { 1, 1, 1 };
point.intensity = 10;
point.attenuation = 10;
Lighting lights;
LightPoint& light = lights.attachLight(point);
lights.setAmbient(Vector3<float>(1.0f, 1.0f, 1.0f));
while (true /*window.isExitRequested()*/) {
window.startFrame();
for (const auto& obj : scene->getObjects()) {
glDrawElements(scene->getMode(), obj.size, GL_UNSIGNED_INT, obj.p_start);
}
window.endFrame();
}
}