Blunkall-Technologies/Archimedes
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

work on text

Browse Source
This commit is contained in:
Nathan
2026-02-22 22:48:26 -06:00
parent ce43c56ea6
commit a5c21ea30d
7 changed files with 480 additions and 162 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/include/utils/Objects/Body.h
View File

@@ -14,8 +14,8 @@ namespace Archimedes {
public:
Body(RenderTarget rt, glm::mat4 t = glm::mat4(1.0f)) : Object(t), mesh(rt) {};
Body(VertexBuffer vb, IndexArray ia, VertexLayout vl, Shader s, RenderMode rm = RenderMode::Triangles, glm::mat4 t = glm::mat4(1.0f))
: Object(t), mesh(vb, ia, vl, s, rm) {}
Body(VertexBuffer vb, IndexArray ia, VertexLayout vl, Shader s, std::optional<Texture> tex = std::nullopt, RenderMode rm = RenderMode::Triangles, glm::mat4 t = glm::mat4(1.0f))
: Object(t), mesh(vb, ia, vl, s, tex, rm) {}
Body() : Object(glm::mat4(1.0f)) {}

158
src/include/utils/Renderer/RenderTarget.h
View File

@@ -17,32 +17,72 @@ namespace Archimedes {
Polygon
};
class Texture {
public:
Texture() {}
Texture(std::vector<unsigned char> bin, size_t width, size_t height)
: bin(bin), width(width), height(height) {}
~Texture() {}
const void* getBin() { return bin.data(); }
void setActive(bool b) { active = b; }
const bool getActive() const { return active; }
size_t getWidth() { return width; }
size_t getHeight() { return height; }
unsigned int id;
private:
std::vector<unsigned char> bin;
bool active = false;
size_t width, height;
};
class LayoutElement {
public:
LayoutElement(unsigned int type, size_t count) : type(type), count(count) {}
enum class Type {
Float,
UInt,
Int,
Double
};
LayoutElement(Type type, size_t count, size_t stride, size_t offset)
: type(type), count(count), stride(stride), offset(offset) {}
~LayoutElement() {}
unsigned int getType() const { return type; }
size_t getSize() const { return size; }
Type getType() const { return type; }
size_t getCount() const { return count; }
size_t getStride() const { return stride; }
size_t getOffset() const { return offset; }
private:
unsigned int type;
size_t size;
Type type;
size_t count;
size_t stride;
size_t offset;
};
class VertexLayout {
public:
VertexLayout() {}
VertexLayout(std::vector<LayoutElement> elements) : elements(elements) {}
~VertexLayout() {}
const std::vector<LayoutElement>& getElements() const { return elements; }
std::vector<LayoutElement>& getElements() { return elements; }
private:
std::vector<LayoutElement> elements;
@@ -58,11 +98,15 @@ namespace Archimedes {
~VertexBuffer() {}
void setActive(bool b) { active = b; }
const bool getActive() const { return active; }
const void* getData() const { return data.data(); }
size_t getSize() const { return data.size() * sizeof(float); }
unsigned int id;
private:
bool active = false;
std::vector<float> data;
};
@@ -74,9 +118,12 @@ namespace Archimedes {
~VertexArray() {}
void setActive(bool b) { active = b; }
const bool getActive() const { return active; }
unsigned int id;
private:
bool active = false;
};
class IndexArray {
@@ -89,11 +136,15 @@ namespace Archimedes {
~IndexArray() {}
void setActive(bool b) { active = b; }
const bool getActive() const { return active; }
const void* getIndicies() const { return indices.data(); }
size_t getCount() const { return indices.size(); }
unsigned int id;
private:
bool active = false;
std::vector<unsigned int> indices;
};
@@ -118,14 +169,31 @@ namespace Archimedes {
void init(const std::string& vs, const std::string& fs, LoadType loadType) {
switch(loadType) {
case LoadType::FromSource:
this->vs = vs;
this->fs = fs;
this->shader = source { vs, fs };
break;
case LoadType::FromBin:
break;
case LoadType::FromFileSource:
this->vs = readSourceFile(vs);
this->fs = readSourceFile(fs);
this->shader = source {
readSourceFile(vs),
readSourceFile(fs)
};
break;
case LoadType::FromFileBin:
break;
default:
break;
}
}
void init(const std::vector<unsigned char>& vs, const std::vector<unsigned char>& fs, LoadType loadType) {
switch(loadType) {
case LoadType::FromSource:
break;
case LoadType::FromBin:
this->shader = bin { vs, fs };
break;
case LoadType::FromFileSource:
break;
case LoadType::FromFileBin:
break;
@@ -134,13 +202,31 @@ namespace Archimedes {
}
}
std::string getVSource() const { return vs; }
std::string getFSource() const { return fs; }
void setActive(bool b) { active = b; }
const bool getActive() const { return active; }
std::string getVSource() const { return std::get<source>(shader).vertex; }
std::string getFSource() const { return std::get<source>(shader).fragment; }
std::vector<unsigned char>& getVbin() { return std::get<bin>(shader).vertex; }
std::vector<unsigned char>& getFbin() { return std::get<bin>(shader).fragment; }
unsigned int id;
private:
std::string vs;
std::string fs;
struct source {
std::string vertex;
std::string fragment;
};
struct bin {
std::vector<unsigned char> vertex;
std::vector<unsigned char> fragment;
};
std::variant<source, bin> shader;
bool active = false;
std::string readSourceFile(const std::string& path) {
@@ -159,25 +245,38 @@ namespace Archimedes {
return s;
}
std::vector<unsigned char> readBinFile(const std::string& path) {
std::ifstream file(path, std::ios::binary);
if(!file.is_open()) {
return std::vector<unsigned char>();
}
std::vector<unsigned char> s;
s.reserve(10000);
while(!file.eof()) {
s.push_back(file.get());
}
return s;
}
};
class RenderTarget {
public:
RenderTarget(const std::vector<float> data, const std::vector<unsigned int> indices, VertexLayout layout, const std::string& vs, const std::string& fs, RenderMode rm = RenderMode::Triangles)
: vertexBuffer(data),
indexArray(indices),
layout(layout),
shader(vs, fs, Shader::LoadType::FromFileSource),
renderMode(rm) {
}
RenderTarget(VertexBuffer vb, IndexArray ia, VertexLayout vl, Shader s, RenderMode rm = RenderMode::Triangles)
RenderTarget(VertexBuffer vb, IndexArray ia, VertexLayout vl, Shader s, std::optional<Texture> t = std::nullopt, RenderMode rm = RenderMode::Triangles)
: vertexBuffer(vb),
indexArray(ia),
layout(vl),
shader(s),
texture(t),
renderMode(rm) {
}
@@ -186,6 +285,15 @@ namespace Archimedes {
~RenderTarget() {}
void setup(VertexBuffer vb, IndexArray ia, VertexLayout vl, Shader s, std::optional<Texture> t = std::nullopt, RenderMode rm = RenderMode::Triangles) {
vertexBuffer = vb;
indexArray = ia;
layout = vl;
shader = s;
texture = t;
renderMode = rm;
}
void setActive(bool b) { active = b; }
const bool getActive() const { return active; }
@@ -201,6 +309,8 @@ namespace Archimedes {
Shader shader;
std::optional<Texture> texture;
RenderMode renderMode;
bool active = false;

13
src/include/utils/Renderer/Renderer.h
View File

@@ -26,16 +26,11 @@ namespace Archimedes {
virtual void render() = 0;
virtual Shader createShader(const std::string& vs, const std::string& fs, const Shader::LoadType& lt) = 0;
virtual void setupShader(Shader& shader) = 0;
virtual RenderTarget createRenderTarget(
VertexBuffer vb,
IndexArray ia,
VertexLayout layout,
Shader& s
) = 0;
virtual void setupTexture(Texture& texture) = 0;
virtual void updateTexture(Texture& texture) = 0;
virtual void setupRenderTarget(RenderTarget& rt) = 0;

178
src/include/utils/Renderer/RendererImpl/RendererOpenGL/RendererOpenGL.h
View File

@@ -39,59 +39,6 @@ namespace Archimedes {
}
Shader createShader(const std::string& vs, const std::string& fs, const Shader::LoadType& lt) override {
Shader shader(vs, fs, lt);
std::string vss = shader.getVSource();
std::string fss = shader.getFSource();
const char* vsc = vss.c_str();
const char* fsc = fss.c_str();
unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertexShader, 1, &vsc, NULL);
glCompileShader(vertexShader);
// check for shader compile errors
int success;
char infoLog[512];
glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
if (!success)
{
glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infoLog << std::endl;
}
// fragment shader
unsigned int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragmentShader, 1, &fsc, NULL);
glCompileShader(fragmentShader);
// check for shader compile errors
glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
if (!success)
{
glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
std::cout << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" << infoLog << std::endl;
}
// link shaders
unsigned int shaderProgram = glCreateProgram();
glAttachShader(shaderProgram, vertexShader);
glAttachShader(shaderProgram, fragmentShader);
glLinkProgram(shaderProgram);
// check for linking errors
glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
if (!success) {
glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog);
std::cout << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << std::endl;
}
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);
shader.id = shaderProgram;
return shader;
}
void setupShader(Shader& shader) override {
std::string vss = shader.getVSource();
@@ -141,14 +88,16 @@ namespace Archimedes {
}
RenderTarget createRenderTarget(VertexBuffer vb, IndexArray ia, VertexLayout layout, Shader& s) override {
auto rt = RenderTarget(vb, ia, layout, s);
void setupTexture(Texture& texture) override {
glGenTextures(1, &texture.id);
updateTexture(texture);
}
setupRenderTarget(rt);
return rt;
};
void updateTexture(Texture& texture) override {
glBindTexture(GL_TEXTURE_2D, texture.id);
glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, texture.getWidth(), texture.getHeight(), 0, GL_ALPHA, GL_UNSIGNED_BYTE, texture.getBin());
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
}
void setupRenderTarget(RenderTarget& rt) override {
@@ -157,28 +106,87 @@ namespace Archimedes {
glGenBuffers(1, &rt.vertexBuffer.id);
glGenBuffers(1, &rt.indexArray.id);
rt.vertexArray.setActive(true);
rt.vertexBuffer.setActive(true);
rt.indexArray.setActive(true);
if(rt.texture.has_value()) {
glGenTextures(1, &rt.texture.value().id);
rt.texture.value().setActive(true);
}
updateRenderTarget(rt);
rt.setActive(true);
};
void updateRenderTarget(RenderTarget& rt) override {
if(rt.vertexArray.getActive()) {
glBindVertexArray(rt.vertexArray.id);
if(rt.vertexBuffer.getActive()) {
glBindBuffer(GL_ARRAY_BUFFER, rt.vertexBuffer.id);
glBufferData(GL_ARRAY_BUFFER, rt.vertexBuffer.getSize(), rt.vertexBuffer.getData(), GL_STATIC_DRAW);
}
if(rt.indexArray.getActive()) {
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, rt.indexArray.id);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, rt.indexArray.getCount() * sizeof(unsigned int), rt.indexArray.getIndicies(), GL_STATIC_DRAW);
}
if(rt.texture.has_value()) {
if(rt.texture.value().getActive()) {
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, rt.texture.value().id);
glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, rt.texture.value().getWidth(), rt.texture.value().getHeight(), 0, GL_ALPHA, GL_UNSIGNED_BYTE, rt.texture.value().getBin());
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
}
}
if(rt.shader.getActive()) {
glUseProgram(rt.shader.id);
}
unsigned int i = 0;
for(LayoutElement e : rt.layout.getElements()) {
switch(e.getType()) {
case LayoutElement::Type::Float:
glVertexAttribPointer(i, e.getCount(), GL_FLOAT, GL_FALSE, e.getStride(), (void*)e.getOffset());
glEnableVertexAttribArray(i);
break;
case LayoutElement::Type::Double:
glVertexAttribPointer(i, e.getCount(), GL_DOUBLE, GL_FALSE, e.getStride(), (void*)e.getOffset());
glEnableVertexAttribArray(i);
break;
case LayoutElement::Type::Int:
glVertexAttribPointer(i, e.getCount(), GL_INT, GL_FALSE, e.getStride(), (void*)e.getOffset());
glEnableVertexAttribArray(i);
break;
case LayoutElement::Type::UInt:
glVertexAttribPointer(i, e.getCount(), GL_UNSIGNED_INT, GL_FALSE, e.getStride(), (void*)e.getOffset());
glEnableVertexAttribArray(i);
break;
default:
break;
}
i++;
}
glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
glBindVertexArray(rt.vertexArray.id);
glBindBuffer(GL_ARRAY_BUFFER, rt.vertexBuffer.id);
glBufferData(GL_ARRAY_BUFFER, rt.vertexBuffer.getSize(), rt.vertexBuffer.getData(), GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, rt.indexArray.id);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, rt.indexArray.getCount() * sizeof(unsigned int), rt.indexArray.getIndicies(), GL_STATIC_DRAW);
glUseProgram(rt.shader.id);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
glEnableVertexAttribArray(0);
glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
};
void freeRenderTarget(RenderTarget& rt) override {
@@ -186,6 +194,12 @@ namespace Archimedes {
glDeleteVertexArrays(1, &rt.vertexArray.id);
glDeleteBuffers(1, &rt.vertexBuffer.id);
glDeleteBuffers(1, &rt.indexArray.id);
rt.vertexArray.setActive(false);
rt.vertexBuffer.setActive(false);
rt.indexArray.setActive(false);
rt.setActive(false);
};
void draw(
@@ -210,6 +224,18 @@ namespace Archimedes {
unsigned int colorLoc = glGetUniformLocation(rt.shader.id, "color");
glUniform4f(colorLoc, color.r, color.g, color.b, color.a);
if(rt.texture.has_value()) {
if(rt.texture.value().getActive()) {
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, rt.texture.value().id);
glUniform1i(glGetUniformLocation(rt.shader.id, "tex"), 0);
}
}
glBindVertexArray(rt.vertexArray.id);
switch(rt.renderMode) {