Linloir/qt-scene-editor
1
0
Fork 0
mirror of https://github.com/Linloir/SceneEditor.git synced 2025-12-17 07:28:12 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Implement shader and mesh classes

Browse Source
This commit is contained in:
Linloir 2022-12-12 21:23:57 +08:00
parent 64b4116979
commit 04ad073263
No known key found for this signature in database
GPG Key ID: 58EEB209A0F2C366
4 changed files with 194 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
FinalProject/mesh.cpp
View File

@ -1 +1,47 @@
#pragma once
#include "mesh.h"
#include "utils.h"
#include "logger.h"
Mesh::Mesh(const std::vector<Vertex>& vertices, const std::vector<unsigned int>& indices, const std::vector<Texture>& textures) {
_vertices = vertices;
_indices = indices;
_textures = textures;
setupMesh();
}
Mesh::Mesh(const std::vector<Vertex>& vertices, const std::vector<Texture>& textures) {
_vertices = vertices;
_textures = textures;
setupMesh();
}
void Mesh::render(const ShaderProgram& shader) const {
unsigned int diffuseNr = 1;
unsigned int specularNr = 1;
for (unsigned int i = 0; i < _textures.size(); i++) {
OPENGL_EXTRA_FUNCTIONS->glActiveTexture(GL_TEXTURE0 + i); // activate proper texture unit before binding
// retrieve texture number (the N in diffuse_textureN)
std::string number;
std::string name = _textures[i].type() == TextureType::DIFFUSE ? "texture_diffuse" : "texture_specular";
if (_textures[i].type() == TextureType::DIFFUSE)
number = std::to_string(diffuseNr++);
else if (_textures[i].type() == TextureType::SPECULAR)
number = std::to_string(specularNr++);
OPENGL_EXTRA_FUNCTIONS->glUniform1i(OPENGL_EXTRA_FUNCTIONS->glGetUniformLocation(shader.programId(), (name + number).c_str()), i);
_textures[i].bind();
}
OPENGL_EXTRA_FUNCTIONS->glActiveTexture(GL_TEXTURE0);
_vao.setActive();
glDrawElements(GL_TRIANGLES, _indices.size(), GL_UNSIGNED_INT, 0);
_vao.setInactive();
}
void Mesh::setupMesh() {
_vao = VertexArrayObject(_vertices, _indices);
}

7
FinalProject/mesh.h
View File

@ -16,8 +16,8 @@ private:
VertexArrayObject _vao;
public:
Mesh(std::vector<Vertex> vertices, std::vector<unsigned int> indices, std::vector<Texture> textures);
Mesh(std::vector<Vertex> vertices, std::vector<Texture> textures);
Mesh(const std::vector<Vertex>& vertices, const std::vector<unsigned int>& indices, const std::vector<Texture>& textures);
Mesh(const std::vector<Vertex>& vertices, const std::vector<Texture>& textures);
public:
inline std::vector<Vertex> vertices() const { return _vertices; }
@ -28,4 +28,7 @@ public:
public:
void render(const ShaderProgram& shader) const ;
private:
void setupMesh();
};

120
FinalProject/shader.cpp
View File

@ -1 +1,121 @@
#pragma once
#include <GLM/gtc/type_ptr.hpp>
#include "shader.h"
#include "utils.h"
#include "logger.h"
inline void Shader::dispose() {
OPENGL_EXTRA_FUNCTIONS->glDeleteShader(_shaderId);
_shaderId = 0;
}
VertexShader::VertexShader(const std::string& source){
_shaderId = OPENGL_EXTRA_FUNCTIONS->glCreateShader(GL_VERTEX_SHADER);
compile(source);
}
void VertexShader::compile(const std::string& source) {
const char* sourcePtr = source.c_str();
OPENGL_EXTRA_FUNCTIONS->glShaderSource(_shaderId, 1, &sourcePtr, nullptr);
OPENGL_EXTRA_FUNCTIONS->glCompileShader(_shaderId);
}
FragmentShader::FragmentShader(const std::string& source){
_shaderId = OPENGL_EXTRA_FUNCTIONS->glCreateShader(GL_FRAGMENT_SHADER);
compile(source);
}
void FragmentShader::compile(const std::string& source) {
const char* sourcePtr = source.c_str();
OPENGL_EXTRA_FUNCTIONS->glShaderSource(_shaderId, 1, &sourcePtr, nullptr);
OPENGL_EXTRA_FUNCTIONS->glCompileShader(_shaderId);
}
GeometryShader::GeometryShader(const std::string& source) {
_shaderId = OPENGL_EXTRA_FUNCTIONS->glCreateShader(GL_GEOMETRY_SHADER);
compile(source);
}
void GeometryShader::compile(const std::string& source) {
const char* sourcePtr = source.c_str();
OPENGL_EXTRA_FUNCTIONS->glShaderSource(_shaderId, 1, &sourcePtr, nullptr);
OPENGL_EXTRA_FUNCTIONS->glCompileShader(_shaderId);
}
ShaderProgram::ShaderProgram() {
_programId = OPENGL_EXTRA_FUNCTIONS->glCreateProgram();
}
ShaderProgram::ShaderProgram(VertexShader vertexShader) {
_programId = OPENGL_EXTRA_FUNCTIONS->glCreateProgram();
OPENGL_EXTRA_FUNCTIONS->glAttachShader(_programId, vertexShader.shaderId());
OPENGL_EXTRA_FUNCTIONS->glLinkProgram(_programId);
vertexShader.dispose();
}
ShaderProgram::ShaderProgram(FragmentShader fragmentShader) {
_programId = OPENGL_EXTRA_FUNCTIONS->glCreateProgram();
OPENGL_EXTRA_FUNCTIONS->glAttachShader(_programId, fragmentShader.shaderId());
OPENGL_EXTRA_FUNCTIONS->glLinkProgram(_programId);
fragmentShader.dispose();
}
ShaderProgram::ShaderProgram(GeometryShader geometryShader) {
_programId = OPENGL_EXTRA_FUNCTIONS->glCreateProgram();
OPENGL_EXTRA_FUNCTIONS->glAttachShader(_programId, geometryShader.shaderId());
OPENGL_EXTRA_FUNCTIONS->glLinkProgram(_programId);
geometryShader.dispose();
}
ShaderProgram::ShaderProgram(VertexShader vertexShader, FragmentShader fragmentShader) {
_programId = OPENGL_EXTRA_FUNCTIONS->glCreateProgram();
OPENGL_EXTRA_FUNCTIONS->glAttachShader(_programId, vertexShader.shaderId());
OPENGL_EXTRA_FUNCTIONS->glAttachShader(_programId, fragmentShader.shaderId());
OPENGL_EXTRA_FUNCTIONS->glLinkProgram(_programId);
vertexShader.dispose();
fragmentShader.dispose();
}
ShaderProgram::ShaderProgram(VertexShader vertexShader, GeometryShader geometryShader) {
_programId = OPENGL_EXTRA_FUNCTIONS->glCreateProgram();
OPENGL_EXTRA_FUNCTIONS->glAttachShader(_programId, vertexShader.shaderId());
OPENGL_EXTRA_FUNCTIONS->glAttachShader(_programId, geometryShader.shaderId());
OPENGL_EXTRA_FUNCTIONS->glLinkProgram(_programId);
vertexShader.dispose();
geometryShader.dispose();
}
ShaderProgram::ShaderProgram(FragmentShader fragmentShader, GeometryShader geometryShader) {
_programId = OPENGL_EXTRA_FUNCTIONS->glCreateProgram();
OPENGL_EXTRA_FUNCTIONS->glAttachShader(_programId, fragmentShader.shaderId());
OPENGL_EXTRA_FUNCTIONS->glAttachShader(_programId, geometryShader.shaderId());
OPENGL_EXTRA_FUNCTIONS->glLinkProgram(_programId);
fragmentShader.dispose();
geometryShader.dispose();
}
ShaderProgram::ShaderProgram(VertexShader vertexShader, FragmentShader fragmentShader, GeometryShader geometryShader) {
_programId = OPENGL_EXTRA_FUNCTIONS->glCreateProgram();
OPENGL_EXTRA_FUNCTIONS->glAttachShader(_programId, vertexShader.shaderId());
OPENGL_EXTRA_FUNCTIONS->glAttachShader(_programId, fragmentShader.shaderId());
OPENGL_EXTRA_FUNCTIONS->glAttachShader(_programId, geometryShader.shaderId());
OPENGL_EXTRA_FUNCTIONS->glLinkProgram(_programId);
vertexShader.dispose();
fragmentShader.dispose();
geometryShader.dispose();
}
inline void ShaderProgram::setActive() {
OPENGL_EXTRA_FUNCTIONS->glUseProgram(_programId);
}
inline void ShaderProgram::setInactive() {
OPENGL_EXTRA_FUNCTIONS->glUseProgram(0);
}
inline void ShaderProgram::dispose() {
OPENGL_EXTRA_FUNCTIONS->glDeleteProgram(_programId);
_programId = 0;
}

51
FinalProject/shader.h
View File

@ -2,56 +2,52 @@
#include <string>
#include <vector>
#include <unordered_set>
#include <GLM/glm.hpp>
class Shader {
private:
int _shaderId = -1;
protected:
unsigned int _shaderId = -1;
public:
Shader();
Shader() {}
inline unsigned int shaderId() const { return _shaderId; }
inline void dispose();
protected:
virtual void compile(std::string sourceFilePath) = 0;
void dispose();
public:
bool operator == (const Shader& other) const;
virtual void compile(const std::string& sourceFilePath) = 0;
};
class VertexShader : public Shader {
public:
VertexShader();
VertexShader(std::string sourceFilePath);
VertexShader() {}
VertexShader(const std::string& sourceFilePath);
protected:
virtual void compile(std::string sourceFilePath) override;
virtual void compile(const std::string& sourceFilePath) override;
};
class FragmentShader : public Shader {
public:
FragmentShader();
FragmentShader(std::string sourceFilePath);
FragmentShader() {}
FragmentShader(const std::string& sourceFilePath);
protected:
virtual void compile(std::string sourceFilePath) override;
virtual void compile(const std::string& sourceFilePath) override;
};
class GeometryShader : public Shader {
public:
GeometryShader();
GeometryShader(std::string sourceFilePath);
GeometryShader() {}
GeometryShader(const std::string& sourceFilePath);
protected:
virtual void compile(std::string sourceFilePath) override;
virtual void compile(const std::string& sourceFilePath) override;
};
class ShaderProgram {
private:
VertexShader _vertexShader;
FragmentShader _fragmentShader;
GeometryShader _geometryShader;
unsigned int _programId = -1;
unsigned int _programId = 0;
public:
ShaderProgram();
@ -62,13 +58,12 @@ public:
ShaderProgram(VertexShader vertexShader, GeometryShader geometryShader);
ShaderProgram(FragmentShader fragmentShader, GeometryShader geometryShader);
ShaderProgram(VertexShader vertexShader, FragmentShader fragmentShader, GeometryShader geometryShader);
~ShaderProgram();
public:
bool operator == (const Shader& other);
template<typename UniformType>
void setUniform(std::string name, const std::vector<UniformType>& values);
inline void setActive();
inline void setInactive();
inline unsigned int programId() const { return _programId; }
inline void dispose();
};