PulseStudio/VoxelEngine
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

assets-related refactor

Browse Source
This commit is contained in:
MihailRis
2024-04-10 17:44:17 +03:00
parent 216e38e411
commit befc9cf09c
14 changed files with 242 additions and 202 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/graphics/core/Atlas.cpp
+8 -3
View File
@@ -6,7 +6,7 @@
#include "ImageData.h"
Atlas::Atlas(ImageData* image, std::unordered_map<std::string, UVRegion> regions)
: texture(Texture::from(image)),
: texture(nullptr),
image(image),
regions(regions) {
}
@@ -14,6 +14,10 @@ Atlas::Atlas(ImageData* image, std::unordered_map<std::string, UVRegion> regions
Atlas::~Atlas() {
}
void Atlas::prepare() {
texture.reset(Texture::from(image.get()));
}
bool Atlas::has(const std::string& name) const {
return regions.find(name) != regions.end();
}
@@ -80,8 +84,9 @@ Atlas* AtlasBuilder::build(uint extrusion, uint maxResolution) {
}
float unitX = 1.0f / width;
float unitY = 1.0f / height;
regions[entry.name] = UVRegion(unitX * x, unitY * y,
unitX * (x + w), unitY * (y + h));
regions[entry.name] = UVRegion(
unitX * x, unitY * y, unitX * (x + w), unitY * (y + h)
);
}
return new Atlas(canvas.release(), regions);
}
src/graphics/core/Atlas.h
+2 -1
View File
@@ -20,6 +20,8 @@ public:
Atlas(ImageData* image, std::unordered_map<std::string, UVRegion> regions);
~Atlas();
void prepare();
bool has(const std::string& name) const;
const UVRegion& get(const std::string& name) const;
@@ -27,7 +29,6 @@ public:
ImageData* getImage() const;
};
struct atlasentry {
std::string name;
std::shared_ptr<ImageData> image;
src/graphics/core/Shader.cpp
+69 -74
View File
@@ -17,7 +17,7 @@ namespace fs = std::filesystem;
GLSLExtension* Shader::preprocessor = new GLSLExtension();
Shader::Shader(unsigned int id) : id(id){
Shader::Shader(uint id) : id(id){
}
Shader::~Shader(){
@@ -28,106 +28,101 @@ void Shader::use(){
glUseProgram(id);
}
void Shader::uniformMatrix(std::string name, glm::mat4 matrix){
GLuint transformLoc = glGetUniformLocation(id, name.c_str());
glUniformMatrix4fv(transformLoc, 1, GL_FALSE, glm::value_ptr(matrix));
uint Shader::getUniformLocation(const std::string& name) {
auto found = uniformLocations.find(name);
if (found == uniformLocations.end()) {
uint location = glGetUniformLocation(id, name.c_str());
uniformLocations.emplace(name, location);
return location;
}
return found->second;
}
void Shader::uniform1i(std::string name, int x){
GLuint transformLoc = glGetUniformLocation(id, name.c_str());
glUniform1i(transformLoc, x);
void Shader::uniformMatrix(const std::string& name, glm::mat4 matrix){
glUniformMatrix4fv(getUniformLocation(name), 1, GL_FALSE, glm::value_ptr(matrix));
}
void Shader::uniform1f(std::string name, float x){
GLuint transformLoc = glGetUniformLocation(id, name.c_str());
glUniform1f(transformLoc, x);
void Shader::uniform1i(const std::string& name, int x){
glUniform1i(getUniformLocation(name), x);
}
void Shader::uniform2f(std::string name, float x, float y){
GLuint transformLoc = glGetUniformLocation(id, name.c_str());
glUniform2f(transformLoc, x, y);
void Shader::uniform1f(const std::string& name, float x){
glUniform1f(getUniformLocation(name), x);
}
void Shader::uniform2f(std::string name, glm::vec2 xy){
GLuint transformLoc = glGetUniformLocation(id, name.c_str());
glUniform2f(transformLoc, xy.x, xy.y);
void Shader::uniform2f(const std::string& name, float x, float y){
glUniform2f(getUniformLocation(name), x, y);
}
void Shader::uniform2i(std::string name, glm::ivec2 xy){
GLuint transformLoc = glGetUniformLocation(id, name.c_str());
glUniform2i(transformLoc, xy.x, xy.y);
void Shader::uniform2f(const std::string& name, glm::vec2 xy){
glUniform2f(getUniformLocation(name), xy.x, xy.y);
}
void Shader::uniform3f(std::string name, float x, float y, float z){
GLuint transformLoc = glGetUniformLocation(id, name.c_str());
glUniform3f(transformLoc, x,y,z);
void Shader::uniform2i(const std::string& name, glm::ivec2 xy){
glUniform2i(getUniformLocation(name), xy.x, xy.y);
}
void Shader::uniform3f(std::string name, glm::vec3 xyz){
GLuint transformLoc = glGetUniformLocation(id, name.c_str());
glUniform3f(transformLoc, xyz.x, xyz.y, xyz.z);
void Shader::uniform3f(const std::string& name, float x, float y, float z){
glUniform3f(getUniformLocation(name), x,y,z);
}
void Shader::uniform3f(const std::string& name, glm::vec3 xyz){
glUniform3f(getUniformLocation(name), xyz.x, xyz.y, xyz.z);
}
inline auto shader_deleter = [](GLuint* shader) {
glDeleteShader(*shader);
};
inline const uint GL_LOG_LEN = 512;
// shader should be deleted after shader program linking
using glshader = std::unique_ptr<GLuint, decltype(shader_deleter)>;
glshader compile_shader(GLenum type, const GLchar* source, const std::string& file) {
GLint success;
GLuint shader = glCreateShader(type);
glShaderSource(shader, 1, &source, nullptr);
glCompileShader(shader);
glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
if (!success){
GLchar infoLog[GL_LOG_LEN];
glGetShaderInfoLog(shader, GL_LOG_LEN, nullptr, infoLog);
glDeleteShader(shader);
throw std::runtime_error(
"vertex shader compilation failed ("+file+"):\n"+std::string(infoLog)
);
}
return glshader(new GLuint(shader), shader_deleter);
}
Shader* Shader::create(
std::string vertexFile,
std::string fragmentFile,
std::string vertexCode,
std::string fragmentCode
const std::string& vertexFile,
const std::string& fragmentFile,
const std::string& vertexCode,
const std::string& fragmentCode
) {
vertexCode = preprocessor->process(fs::path(vertexFile), vertexCode);
fragmentCode = preprocessor->process(fs::path(fragmentFile), fragmentCode);
const GLchar* vCode = vertexCode.c_str();
const GLchar* fCode = fragmentCode.c_str();
const GLchar* vShaderCode = vertexCode.c_str();
const GLchar* fShaderCode = fragmentCode.c_str();
GLuint vertex, fragment;
GLint success;
GLchar infoLog[512];
// Vertex Shader
vertex = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertex, 1, &vShaderCode, nullptr);
glCompileShader(vertex);
glGetShaderiv(vertex, GL_COMPILE_STATUS, &success);
if (!success){
glGetShaderInfoLog(vertex, 512, nullptr, infoLog);
std::cerr << "SHADER::VERTEX: compilation failed: " << vertexFile << std::endl;
std::cerr << infoLog << std::endl;
return nullptr;
}
// Fragment Shader
fragment = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragment, 1, &fShaderCode, nullptr);
glCompileShader(fragment);
glGetShaderiv(fragment, GL_COMPILE_STATUS, &success);
if (!success){
glGetShaderInfoLog(fragment, 512, nullptr, infoLog);
std::cerr << "SHADER::FRAGMENT: compilation failed: " << vertexFile << std::endl;
std::cerr << infoLog << std::endl;
return nullptr;
}
glshader vertex = compile_shader(GL_VERTEX_SHADER, vCode, vertexFile);
glshader fragment = compile_shader(GL_FRAGMENT_SHADER, fCode, fragmentFile);
// Shader Program
GLint success;
GLuint id = glCreateProgram();
glAttachShader(id, vertex);
glAttachShader(id, fragment);
glAttachShader(id, *vertex);
glAttachShader(id, *fragment);
glLinkProgram(id);
glGetProgramiv(id, GL_LINK_STATUS, &success);
if (!success){
glGetProgramInfoLog(id, 512, nullptr, infoLog);
std::cerr << "SHADER::PROGRAM: linking failed" << std::endl;
std::cerr << infoLog << std::endl;
glDeleteShader(vertex);
glDeleteShader(fragment);
return nullptr;
GLchar infoLog[GL_LOG_LEN];
glGetProgramInfoLog(id, GL_LOG_LEN, nullptr, infoLog);
throw std::runtime_error(
"shader program linking failed:\n"+std::string(infoLog)
);
}
glDeleteShader(vertex);
glDeleteShader(fragment);
return new Shader(id);
}
src/graphics/core/Shader.h
+26 -15
View File
@@ -1,35 +1,46 @@
#ifndef GRAPHICS_CORE_SHADER_H_
#define GRAPHICS_CORE_SHADER_H_
#include <string>
#include <glm/glm.hpp>
#include "../../typedefs.h"
#include <string>
#include <unordered_map>
#include <glm/glm.hpp>
class GLSLExtension;
class Shader {
uint id;
std::unordered_map<std::string, uint> uniformLocations;
uint getUniformLocation(const std::string& name);
public:
static GLSLExtension* preprocessor;
Shader(unsigned int id);
Shader(uint id);
~Shader();
void use();
void uniformMatrix(std::string name, glm::mat4 matrix);
void uniform1i(std::string name, int x);
void uniform1f(std::string name, float x);
void uniform2f(std::string name, float x, float y);
void uniform2f(std::string name, glm::vec2 xy);
void uniform2i(std::string name, glm::ivec2 xy);
void uniform3f(std::string name, float x, float y, float z);
void uniform3f(std::string name, glm::vec3 xyz);
void uniformMatrix(const std::string&, glm::mat4 matrix);
void uniform1i(const std::string& name, int x);
void uniform1f(const std::string& name, float x);
void uniform2f(const std::string& name, float x, float y);
void uniform2f(const std::string& name, glm::vec2 xy);
void uniform2i(const std::string& name, glm::ivec2 xy);
void uniform3f(const std::string& name, float x, float y, float z);
void uniform3f(const std::string& name, glm::vec3 xyz);
/// @brief Create shader program using vertex and fragment shaders source.
/// @param vertexFile vertex shader file name
/// @param fragmentFile fragment shader file name
/// @param vertexSource vertex shader source code
/// @param fragmentSource fragment shader source code
/// @return linked shader program containing vertex and fragment shaders
static Shader* create(
std::string vertexFile,
std::string fragmentFile,
std::string vertexSource,
std::string fragmentSource
const std::string& vertexFile,
const std::string& fragmentFile,
const std::string& vertexSource,
const std::string& fragmentSource
);
};