We'll warp up all the classes
Mesh is a data set that almost always contains vertices, often contains indices, and somtimes contains texture.
the tree of our classes dependencies.
we will declare three vectors named vertices, indices and textures.
note that these are c++ vectors, instead of glm vectors (c++ vector is dynamic array)
1. store our VAO since we'll be initializing it using this class.
2. constructor simply input the vertices, indices, and textures
3. make Draw function that will take in a shader and a camera.
//Mesh.h
#ifndef MESH_CLASS_H
#define MESH_CLASS_H
#include<string>
#include"VAO.h"
#include"EBO.h"
#include"Camera.h"
#include"Texture.h"
class Mesh
{
public:
std::vector <Vertex> vertices;
std::vector <GLuint> indices;
std::vector <Texture> textures;
VAO VAO;
Mesh(std::vector <Vertex>& vertices, std::vector <GLuint>& indicies, std::vector <Texture>& textures);
void Draw(Shader& shader, Camera& camera);
};
#endifour vertices vector contains a structure named Vertex.
but we don't have one so far, so let's create one.
struct Vertex
give it three vec3s for the position, normal and color, and then a vec2 for the texture coordinates.
and then, patch up the VBO class constructor to accept a vector of Vertex structs instead of an array.
let's also include the c++ vector, and since we are using vectors instead of arrays.
now also get rid of the size input, since we can calculate that inside
//VBO.h
#ifndef VBO_CLASS_H
#define VBO_CLASS_H
#include<glad/glad.h>
class VBO
{
public:
GLuint ID;
VBO(GLfloat* vertices, GLsizeiptr size);
void Bind();
void Unbind();
void Delete();
};
#endif
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#ifndef VBO_CLASS_H
#define VBO_CLASS_H
#include<glm/glm.hpp>
#include<glad/glad.h>
#include<vector>
struct Vertex
{
glm::vec3 position;
glm::vec3 normal;
glm::vec3 color;
glm::vec2 texUV;
};
class VBO
{
public:
GLuint ID;
VBO(std::vector<Vertex>& vertices);
void Bind();
void Unbind();
void Delete();
};
#endifnow the vertices size and data is setted by c++ function, instead of parameter
//VBO.cpp
VBO::VBO(GLfloat* vertices, GLsizeiptr size)
{
glGenBuffers(1, &ID);
glBindBuffer(GL_ARRAY_BUFFER, ID);
glBufferData(GL_ARRAY_BUFFER, size, vertices, GL_STATIC_DRAW);
}
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
VBO::VBO(std::vector<Vertex>& vertices)
{
glGenBuffers(1, &ID);
glBindBuffer(GL_ARRAY_BUFFER, ID);
glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(Vertex), vertices.data(), GL_STATIC_DRAW);
}and EBO.h and cpp deal with same way
header file include the vecter and change the constructor's parameter. and then the cpp's constructor too
set mesh.cpp
remind that Mesh is a data set that contains vertices, often contains indices, and somtimes contains texture.
first, we will set the consturctor.
//mesh.cpp
#include"Mesh.h"
Mesh::Mesh(std::vector <Vertex>& vertices, std::vector <GLuint>& indicies, std::vector <Texture>& textures)
{
Mesh::vertices = vertices;
Mesh::indices = indicies;
Mesh::textures = textures;
VAO.Bind();
VBO VBO(vertices);
EBO EBO(indices);
VAO.LinkAttrib(VBO, 0, 3, GL_FLOAT, sizeof(Vertex), (void*)0);
VAO.LinkAttrib(VBO, 1, 3, GL_FLOAT, sizeof(Vertex), (void*)(3 * sizeof(float)));
VAO.LinkAttrib(VBO, 2, 3, GL_FLOAT, sizeof(Vertex), (void*)(6 * sizeof(float)));
VAO.LinkAttrib(VBO, 3, 2, GL_FLOAT, sizeof(Vertex), (void*)(9 * sizeof(float)));
VAO.Unbind();
VBO.Unbind();
EBO.Unbind();
}
for ordering, the shader's layout will be changed, it is important
Though, the other ordering isnt mandatory but it looks nice :)
//default.vert
#version 440 core
layout (location = 0) in vec3 aPos;
layout (location = 1) in vec3 aNormal;
layout (location = 2) in vec3 aColor;
layout (location = 3) in vec2 aTex;
out vec3 crntPos;
out vec3 Normal;
out vec3 color;
out vec2 texCoord;
uniform mat4 camMatrix;
uniform mat4 model;
void main()
{
crntPos = vec3(model * vec4(aPos, 1.0f));
Normal = aNormal;
color = aColor;
texCoord = aTex;
gl_Position = camMatrix * vec4(crntPos, 1.0);
}
Draw function
Now we'll have to do something a bit more complicated in order to properly load the textures,
since we won't always know how many textures a mesh has
1. we'll start by activating the shader, and binding the VAO as usual.
2. count the diffuse and specular map
3. go through all the textures, find out the texture's number and type
// Mesh.cpp
void Mesh::Draw(Shader& shader, Camera& camera)
{
shader.Activate();
VAO.Bind();
unsigned int numDiffuse = 0;
unsigned int numSpecular = 0;
for (unsigned int i = 0; i < textures.size(); i++)
{
std::string num;
std::string type = textures[i].type;
}
}
we don't know the type, we'll want to modify our texture class by changing the type variable to a const char array
cause we want to take a string as input. (like "diffuse", "specular")
//Texture.h
class Texture
{
public:
GLuint ID;
const char* type;
GLuint unit;
Texture(const char* image, const char* texType, GLuint slot, GLenum format, GLenum pixelType);
void texUnit(Shader& shader, const char* uniform, GLuint unit);
void Bind();
void Unbind();
void Delete();
};
//Texture.cpp
Texture::Texture(const char* image, const char* texType, GLuint slot, GLenum format, GLenum pixelType)
{
type = texType;
int widthImg, heightImg, numColCh;
stbi_set_flip_vertically_on_load(true);
unsigned char* bytes = stbi_load(image, &widthImg, &heightImg, &numColCh, 0);
glGenTextures(1, &ID);
glActiveTexture(GL_TEXTURE0 + slot);
unit = slot;
glBindTexture(GL_TEXTURE_2D, ID);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, widthImg, heightImg, 0, format, pixelType, bytes);
glGenerateMipmap(GL_TEXTURE_2D);
stbi_image_free(bytes);
glBindTexture(GL_TEXTURE_2D, 0);
}
now we take care of the uniform using our function texUnit, plugging in the shader
then a C string composed of our 'type' plus 'num', and the unit of our texture.
(our uniforms will be named "diffuse0" , ... ,"specular2" , etc.)
Then simply bind the texture.
// Mesh.cpp
void Mesh::Draw(Shader& shader, Camera& camera)
{
shader.Activate();
VAO.Bind();
unsigned int numDiffuse = 0;
unsigned int numSpecular = 0;
for (unsigned int i = 0; i < textures.size(); i++)
{
std::string num;
std::string type = textures[i].type;
if (type == "diffuse")
{
num = std::to_string(numDiffuse++);
}
else if (type == "specular")
{
num = std::to_string(numSpecular++);
}
textures[i].texUnit(shader, (type + num).c_str(), i);
textures[i].Bind();
}
glUniform3f(glGetUniformLocation(shader.ID, "camPos"), camera.Position.x, camera.Position.y, camera.Position.z);
camera.Matrix(shader, "camMatrix");
glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_INT, 0);
}
now we change our main.cpp file
our main function changed to look pretty simple by Mesh.cpp
1. the Texture changes to an array
2. the Shader changes to a vector (lightshader too)
//main.cpp
//Texture part
Texture planksTex("planks.png", GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE);
planksTex.texUnit(shaderProgram, "tex0", 0);
Texture planksSpec("planksSpec.png", GL_TEXTURE_2D, 1, GL_RED, GL_UNSIGNED_BYTE);
planksSpec.texUnit(shaderProgram, "tex1", 1);
>>
Texture textures[]
{
Texture("planks.png", "diffuse", 0, GL_RGBA, GL_UNSIGNED_BYTE),
Texture("planksSpec.png", "specular", 1, GL_RED, GL_UNSIGNED_BYTE)
};
//Shader part
Shader shaderProgram("default.vert", "default.frag");
// Generates Vertex Array Object and binds it
VAO VAO1;
VAO1.Bind();
// Generates Vertex Buffer Object and links it to vertices
VBO VBO1(vertices, sizeof(vertices));
// Generates Element Buffer Object and links it to indices
EBO EBO1(indices, sizeof(indices));
// Links VBO attributes such as coordinates and colors to VAO
VAO1.LinkAttrib(VBO1, 0, 3, GL_FLOAT, 11 * sizeof(float), (void*)0);
VAO1.LinkAttrib(VBO1, 1, 3, GL_FLOAT, 11 * sizeof(float), (void*)(3 * sizeof(float)));
VAO1.LinkAttrib(VBO1, 2, 2, GL_FLOAT, 11 * sizeof(float), (void*)(6 * sizeof(float)));
VAO1.LinkAttrib(VBO1, 3, 3, GL_FLOAT, 11 * sizeof(float), (void*)(8 * sizeof(float)));
// Unbind all to prevent accidentally modifying them
VAO1.Unbind();
VBO1.Unbind();
EBO1.Unbind();
>>
// Generates Shader object using shaders default.vert and default.frag
Shader shaderProgram("default.vert", "default.frag");
// Store mesh data in vectors for the mesh
std::vector <Vertex> verts(vertices, vertices + sizeof(vertices) / sizeof(Vertex));
std::vector <GLuint> ind(indices, indices + sizeof(indices) / sizeof(GLuint));
std::vector <Texture> tex(textures, textures + sizeof(textures) / sizeof(Texture));
// Create floor mesh
Mesh floor(verts, ind, tex);
// Mainloop
// Draw part
// Tells OpenGL which Shader Program we want to use
shaderProgram.Activate();
// Exports the camera Position to the Fragment Shader for specular lighting
glUniform3f(glGetUniformLocation(shaderProgram.ID, "camPos"), camera.Position.x, camera.Position.y, camera.Position.z);
// Export the camMatrix to the Vertex Shader of the pyramid
camera.Matrix(shaderProgram, "camMatrix");
// Binds textures so that they appear in the rendering
planksTex.Bind();
planksSpec.Bind();
// Bind the VAO so OpenGL knows to use it
VAO1.Bind();
// Draw primitives, number of indices, datatype of indices, index of indices
glDrawElements(GL_TRIANGLES, sizeof(indices) / sizeof(int), GL_UNSIGNED_INT, 0);
>>
// Draws different meshes
floor.Draw(shaderProgram, camera);