diff options
Diffstat (limited to 'themes')
26 files changed, 428 insertions, 296 deletions
diff --git a/themes/.cache/clangd/index/LeafParticleRender.cpp.C2E152FEB0B3916C.idx b/themes/.cache/clangd/index/LeafParticleRender.cpp.C2E152FEB0B3916C.idx Binary files differindex 6f82b75..1023991 100644 --- a/themes/.cache/clangd/index/LeafParticleRender.cpp.C2E152FEB0B3916C.idx +++ b/themes/.cache/clangd/index/LeafParticleRender.cpp.C2E152FEB0B3916C.idx diff --git a/themes/.cache/clangd/index/LeafParticleRender.h.A0C89D6CC01BA1D6.idx b/themes/.cache/clangd/index/LeafParticleRender.h.A0C89D6CC01BA1D6.idx Binary files differindex 000789c..6578f1f 100644 --- a/themes/.cache/clangd/index/LeafParticleRender.h.A0C89D6CC01BA1D6.idx +++ b/themes/.cache/clangd/index/LeafParticleRender.h.A0C89D6CC01BA1D6.idx diff --git a/themes/.cache/clangd/index/Renderer2d.cpp.DF430723818BC87C.idx b/themes/.cache/clangd/index/Renderer2d.cpp.DF430723818BC87C.idx Binary files differindex 85448f2..01bf4da 100644 --- a/themes/.cache/clangd/index/Renderer2d.cpp.DF430723818BC87C.idx +++ b/themes/.cache/clangd/index/Renderer2d.cpp.DF430723818BC87C.idx diff --git a/themes/.cache/clangd/index/Renderer2d.h.F1518A7EF7C2E747.idx b/themes/.cache/clangd/index/Renderer2d.h.F1518A7EF7C2E747.idx Binary files differindex 99ffa12..d005647 100644 --- a/themes/.cache/clangd/index/Renderer2d.h.F1518A7EF7C2E747.idx +++ b/themes/.cache/clangd/index/Renderer2d.h.F1518A7EF7C2E747.idx diff --git a/themes/.cache/clangd/index/Snowflake.cpp.3E4BE700DA4CDAC9.idx b/themes/.cache/clangd/index/Snowflake.cpp.3E4BE700DA4CDAC9.idx Binary files differindex ba4783e..16294ae 100644 --- a/themes/.cache/clangd/index/Snowflake.cpp.3E4BE700DA4CDAC9.idx +++ b/themes/.cache/clangd/index/Snowflake.cpp.3E4BE700DA4CDAC9.idx diff --git a/themes/.cache/clangd/index/Snowflake.h.CAD2EF1A1EEC6A99.idx b/themes/.cache/clangd/index/Snowflake.h.CAD2EF1A1EEC6A99.idx Binary files differindex 3f61437..2f0ad76 100644 --- a/themes/.cache/clangd/index/Snowflake.h.CAD2EF1A1EEC6A99.idx +++ b/themes/.cache/clangd/index/Snowflake.h.CAD2EF1A1EEC6A99.idx diff --git a/themes/.cache/clangd/index/TreeShape.cpp.3271E9D39A039C82.idx b/themes/.cache/clangd/index/TreeShape.cpp.3271E9D39A039C82.idx Binary files differindex aa36592..f531d9b 100644 --- a/themes/.cache/clangd/index/TreeShape.cpp.3271E9D39A039C82.idx +++ b/themes/.cache/clangd/index/TreeShape.cpp.3271E9D39A039C82.idx diff --git a/themes/.cache/clangd/index/TreeShape.h.68863A800A0A4201.idx b/themes/.cache/clangd/index/TreeShape.h.68863A800A0A4201.idx Binary files differindex 39cf36c..dbbe718 100644 --- a/themes/.cache/clangd/index/TreeShape.h.68863A800A0A4201.idx +++ b/themes/.cache/clangd/index/TreeShape.h.68863A800A0A4201.idx diff --git a/themes/.cache/clangd/index/list.h.94D5DE92B51D5CD7.idx b/themes/.cache/clangd/index/list.h.94D5DE92B51D5CD7.idx Binary files differnew file mode 100644 index 0000000..0133a7f --- /dev/null +++ b/themes/.cache/clangd/index/list.h.94D5DE92B51D5CD7.idx diff --git a/themes/LeafParticleRender.cpp b/themes/LeafParticleRender.cpp index 3ab46a0..0c6fbca 100644 --- a/themes/LeafParticleRender.cpp +++ b/themes/LeafParticleRender.cpp @@ -9,7 +9,7 @@ const i32 verticesPerLeaf = 6; const f32 leafRadius = 3.f; const i32 fallChanceMax = 100; -inline void updateLeaf(Renderer2dVertex* vertices, Vector2 position, Vector4 color, f32 scale) { +inline void updateLeaf(Vertex2D* vertices, Vector2 position, Vector4 color, f32 scale) { f32 radius = scale * leafRadius; Vector2 bottomLeft = Vector2(-radius, -radius) + position; Vector2 bottomRight = Vector2(radius, -radius) + position; @@ -31,7 +31,7 @@ void LeafParticleRender::load(Renderer2d *renderer, TreeShapeLoadResult* lr) { numVertices = ld.numLeaves * verticesPerLeaf; updateData = new LeafParticleUpdateData[numLeaves]; - vertices = new Renderer2dVertex[numVertices]; + vertices = new Vertex2D[numVertices]; for (i32 leafIdx = 0; leafIdx < numLeaves; leafIdx++) { i32 randomBranch = randomIntBetween(0, lr->numBranches); @@ -50,17 +50,17 @@ void LeafParticleRender::load(Renderer2d *renderer, TreeShapeLoadResult* lr) { glGenBuffers(1, &vbo); glBindBuffer(GL_ARRAY_BUFFER, vbo); - glBufferData(GL_ARRAY_BUFFER, numVertices * sizeof(Renderer2dVertex), &vertices[0], GL_DYNAMIC_DRAW); + glBufferData(GL_ARRAY_BUFFER, numVertices * sizeof(Vertex2D), &vertices[0], GL_DYNAMIC_DRAW); glEnableVertexAttribArray(renderer->attributes.position); - glVertexAttribPointer(renderer->attributes.position, 2, GL_FLOAT, GL_FALSE, sizeof(Renderer2dVertex), (GLvoid *)0); + glVertexAttribPointer(renderer->attributes.position, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex2D), (GLvoid *)0); glEnableVertexAttribArray(renderer->attributes.color); - glVertexAttribPointer(renderer->attributes.color, 4, GL_FLOAT, GL_FALSE, sizeof(Renderer2dVertex), (GLvoid *)offsetof(Renderer2dVertex, color)); + glVertexAttribPointer(renderer->attributes.color, 4, GL_FLOAT, GL_FALSE, sizeof(Vertex2D), (GLvoid *)offsetof(Vertex2D, color)); for (i32 idx = 0; idx < 4; idx++) { glEnableVertexAttribArray(renderer->attributes.vMatrix + idx); - glVertexAttribPointer(renderer->attributes.vMatrix + idx, 4, GL_FLOAT, GL_FALSE, sizeof(Renderer2dVertex), (GLvoid *)(offsetof(Renderer2dVertex, vMatrix) + (idx * 16))); + glVertexAttribPointer(renderer->attributes.vMatrix + idx, 4, GL_FLOAT, GL_FALSE, sizeof(Vertex2D), (GLvoid *)(offsetof(Vertex2D, vMatrix) + (idx * 16))); } glBindBuffer(GL_ARRAY_BUFFER, 0); @@ -150,7 +150,7 @@ void LeafParticleRender::render(Renderer2d *renderer) { setShaderMat4(renderer->uniforms.model, model); glBindBuffer(GL_ARRAY_BUFFER, vbo); - glBufferSubData(GL_ARRAY_BUFFER, 0, numVertices * sizeof(Renderer2dVertex), &vertices[0]); + glBufferSubData(GL_ARRAY_BUFFER, 0, numVertices * sizeof(Vertex2D), &vertices[0]); glBindVertexArray(vao); glDrawArrays(GL_TRIANGLES, 0, numVertices); diff --git a/themes/LeafParticleRender.h b/themes/LeafParticleRender.h index 230cee8..713d9f6 100644 --- a/themes/LeafParticleRender.h +++ b/themes/LeafParticleRender.h @@ -20,7 +20,7 @@ enum LeafParticleState { struct LeafParticleUpdateData { LeafParticleState state = LeafParticleState::Remerging; - Renderer2dVertex* vertexToFollow = NULL; + Vertex2D* vertexToFollow = NULL; Vector4 color = Vector4(1.f, 0.f, 0.f, 0.f); f32 scale = 1.f; @@ -32,7 +32,7 @@ struct LeafParticleUpdateData { f32 resetTime = 0.f; - Renderer2dVertex* vertexPtr = NULL; + Vertex2D* vertexPtr = NULL; }; struct LeafParticleRender { @@ -43,7 +43,7 @@ struct LeafParticleRender { i32 numLeaves = 0; LeafParticleUpdateData* updateData = NULL; - Renderer2dVertex* vertices = NULL; + Vertex2D* vertices = NULL; // Render data u32 vao; diff --git a/themes/List.h b/themes/List.h deleted file mode 100644 index 00a466a..0000000 --- a/themes/List.h +++ /dev/null @@ -1,222 +0,0 @@ -#pragma once -#include <cstdlib> -#include <cstring> -#include "Logger.h" - -#define FOREACH(list) \ - for (size_t idx = 0; idx < list.numElements; idx++) \ - if (auto value = list.getValue(idx)) \ - - -template <typename T> -struct List { - T* data = nullptr; - size_t capacity = 0; - size_t numElements = 0; - bool growDynamically = true; - - void allocate(size_t size); - void add(T* element); - void add(T& element); - void add(T&& element); - bool grow(size_t newSize); - void set(T* value, size_t index); - void remove(size_t index); - void clear(); - void deallocate(); - bool isEmpty() { - return data == nullptr || numElements == 0; - } - T* getValue(int index) const; - T& operator[](int idx) const; - void binarySort(int (*f)(T *first, T* second)); - void setFromArray(T* arry, int size) { - allocate(size); - memcpy(data, arry, size * sizeof(T)); - numElements = size; - } - void remove(int index) { - if (index >= numElements) { - logger_error("Cannot remove element at index: %d", index); - return; - } - - - if (index == numElements - 1) { - numElements--; - return; - } - - memmove(data[index], data[index + 1], sizeof(T) * (numElements - index)); - numElements--; - } -}; - -template <typename T> -void List<T>::allocate(size_t size) { - if (size == 0 || size == capacity) { - numElements = 0; - return; - } - - if (data != nullptr) { - deallocate(); - } - - data = static_cast<T*>(malloc(sizeof(T) * size)); - capacity = size; - numElements = 0; -} - -template <typename T> -bool List<T>::grow(size_t newSize) { - if (!growDynamically) { - return false; - } - - if (newSize == 0) { - return false; - } - - T* newData = static_cast<T*>(malloc(sizeof(T) * newSize)); - - if (data != nullptr) { - memcpy(newData, data, numElements * sizeof(T)); - delete data; - } - - data = newData; - capacity = newSize; - return true; -} - -template <typename T> -void List<T>::set(T* value, size_t index) { - if (index >= capacity && !grow(index * 2)) { - return; - } - - memcpy(&data[index], value, sizeof(T)); -} - -template <typename T> -void List<T>::add(T* element) { - if (data == nullptr) { - allocate(2); - } - - if (element == nullptr) { - logger_error("Element not defined"); - return; - } - - size_t newNumElements = numElements + 1; - if (newNumElements > capacity) { - if (!grow(2 * capacity)) { - logger_error("Trying to add to list but unable to grow the array"); - return; - } - } - - memcpy(&data[numElements], element, sizeof(T)); - numElements = newNumElements; -} - -template <typename T> -void List<T>::add(T& element) { - if (data == nullptr) { - allocate(2); - } - - size_t newNumElements = numElements + 1; - if (newNumElements > capacity) { - if (!grow(2 * capacity)) { - logger_error("Trying to add to list but unable to grow the array"); - return; - } - } - - memcpy(&data[numElements], &element, sizeof(T)); - numElements = newNumElements; -} - -template <typename T> -void List<T>::add(T&& element) { - if (data == nullptr) { - allocate(2); - } - - size_t newNumElements = numElements + 1; - if (newNumElements > capacity) { - if (!grow(2 * capacity)) { - logger_error("Trying to add to list but unable to grow the array"); - return; - } - } - - memcpy(&data[numElements], &element, sizeof(T)); - numElements = newNumElements; -} - -template <typename T> -void List<T>::remove(size_t idx) { - if (idx >= numElements) { - logger_error("Index is outside of the list: %d >= %d", idx, numElements); - return; - } - - for (; idx < numElements - 1; idx++) { - data[idx] = data[idx + 1]; - } - - numElements--; -} - -template <typename T> -void List<T>::deallocate() { - if (data != nullptr) { - free(data); - data = nullptr; - } - - capacity = 0; - numElements = 0; -} - -template <typename T> -void List<T>::clear() { - numElements = 0; -} - -template <typename T> -T* List<T>::getValue(int idx) const { - return &data[idx]; -} - -template <typename T> -T& List<T>::operator[](int idx) const { - return data[idx]; -} - -template <typename T> -void List<T>::binarySort(int (*f)(T *first, T* second)) { - if (data == nullptr) { - return; - } - - for (size_t idx = 0; idx < numElements - 1; idx++) { - int minIdx = idx; - T firstValue = data[idx]; - - for (int innerIdx = idx + 1; innerIdx < numElements; innerIdx++) {\ - T secondValue = data[innerIdx]; - if (f(&firstValue, &secondValue) > 0) { - minIdx= innerIdx; - } - } - - T temp = data[minIdx]; - memmove(&data[minIdx], &data[idx], sizeof(T)); - memmove(&data[idx], &temp, sizeof(T)); - } -} diff --git a/themes/Renderer2d.cpp b/themes/Renderer2d.cpp index 8c1af63..0d4eca2 100644 --- a/themes/Renderer2d.cpp +++ b/themes/Renderer2d.cpp @@ -6,7 +6,7 @@ // Note: In the 'transform' attribute, the transform.x is the scale, // transform.y is the rotation, and transform.zw is the translatiob. -const char* renderer2dVertexShader = +const char* Vertex2DShader = "attribute vec2 position; \n" "attribute vec4 color; \n" "attribute mat4 vMatrix; \n" @@ -40,7 +40,7 @@ EM_BOOL onScreenSizeChanged(int eventType, const EmscriptenUiEvent *uiEvent, voi void Renderer2d::load(WebglContext* inContext) { context = inContext; printf("Compiling Renderer2d shader...\n"); - shader = loadShader(renderer2dVertexShader, renderer2dFragmentShader); + shader = loadShader(Vertex2DShader, renderer2dFragmentShader); useShader(shader); attributes.position = getShaderAttribute(shader, "position"); @@ -75,7 +75,7 @@ void Renderer2d::unload() { } -void Renderer2dShape::load(Renderer2dVertex* inVertices, u32 inNumVertices, Renderer2d* renderer) { +void Mesh2D::load(Vertex2D* inVertices, u32 inNumVertices, Renderer2d* renderer) { numVertices = inNumVertices; useShader(renderer->shader); @@ -84,24 +84,24 @@ void Renderer2dShape::load(Renderer2dVertex* inVertices, u32 inNumVertices, Rend glGenBuffers(1, &vbo); glBindBuffer(GL_ARRAY_BUFFER, vbo); - glBufferData(GL_ARRAY_BUFFER, inNumVertices * sizeof(Renderer2dVertex), &inVertices[0], GL_STATIC_DRAW); + glBufferData(GL_ARRAY_BUFFER, inNumVertices * sizeof(Vertex2D), &inVertices[0], GL_STATIC_DRAW); glEnableVertexAttribArray(renderer->attributes.position); - glVertexAttribPointer(renderer->attributes.position, 2, GL_FLOAT, GL_FALSE, sizeof(Renderer2dVertex), (GLvoid *)0); + glVertexAttribPointer(renderer->attributes.position, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex2D), (GLvoid *)0); glEnableVertexAttribArray(renderer->attributes.color); - glVertexAttribPointer(renderer->attributes.color, 4, GL_FLOAT, GL_FALSE, sizeof(Renderer2dVertex), (GLvoid *)offsetof(Renderer2dVertex, color)); + glVertexAttribPointer(renderer->attributes.color, 4, GL_FLOAT, GL_FALSE, sizeof(Vertex2D), (GLvoid *)offsetof(Vertex2D, color)); for (i32 idx = 0; idx < 4; idx++) { glEnableVertexAttribArray(renderer->attributes.vMatrix + idx); - glVertexAttribPointer(renderer->attributes.vMatrix + idx, 4, GL_FLOAT, GL_FALSE, sizeof(Renderer2dVertex), (GLvoid *)(offsetof(Renderer2dVertex, vMatrix) + (idx * 16))); + glVertexAttribPointer(renderer->attributes.vMatrix + idx, 4, GL_FLOAT, GL_FALSE, sizeof(Vertex2D), (GLvoid *)(offsetof(Vertex2D, vMatrix) + (idx * 16))); } glBindBuffer(GL_ARRAY_BUFFER, 0); glBindVertexArray(0); } -void Renderer2dShape::render(Renderer2d* renderer, GLenum drawType) { +void Mesh2D::render(Renderer2d* renderer, GLenum drawType) { setShaderMat4(renderer->uniforms.model, model); glBindVertexArray(vao); @@ -109,7 +109,7 @@ void Renderer2dShape::render(Renderer2d* renderer, GLenum drawType) { glBindVertexArray(0); } -void Renderer2dShape::unload() { +void Mesh2D::unload() { glDeleteVertexArrays(1, &vao); glDeleteBuffers(1, &vbo); } diff --git a/themes/Renderer2d.h b/themes/Renderer2d.h index 30769db..82af673 100644 --- a/themes/Renderer2d.h +++ b/themes/Renderer2d.h @@ -29,19 +29,19 @@ struct Renderer2d { void unload(); }; -struct Renderer2dVertex { +struct Vertex2D { Vector2 position; Vector4 color; Mat4x4 vMatrix; }; -struct Renderer2dShape { +struct Mesh2D { u32 vao; u32 vbo; u32 numVertices = 0; Mat4x4 model; - void load(Renderer2dVertex* vertices, u32 numVertices, Renderer2d* renderer); + void load(Vertex2D* vertices, u32 numVertices, Renderer2d* renderer); void render(Renderer2d* renderer, GLenum drawType = GL_TRIANGLES); void unload(); }; diff --git a/themes/Renderer2d_Frag.glsl b/themes/Renderer2d_Frag.glsl deleted file mode 100644 index c50e626..0000000 --- a/themes/Renderer2d_Frag.glsl +++ /dev/null @@ -1,4 +0,0 @@ -varying lowp vec4 VertexColor; -void main() { - gl_FragColor = VertexColor; -};
\ No newline at end of file diff --git a/themes/Renderer2d_Vertex.glsl b/themes/Renderer2d_Vertex.glsl deleted file mode 100644 index f3ab653..0000000 --- a/themes/Renderer2d_Vertex.glsl +++ /dev/null @@ -1,10 +0,0 @@ -attribute vec2 position; -attribute vec4 color; -uniform mat4 projection; -uniform mat4 model; -varying lowp vec4 VertexColor; -void main() { - vec4 fragmentPosition = projection * model * vec4(position, 1, 1); - gl_Position = fragmentPosition; - VertexColor = color; -};
\ No newline at end of file diff --git a/themes/Renderer3d.cpp b/themes/Renderer3d.cpp new file mode 100644 index 0000000..0106f10 --- /dev/null +++ b/themes/Renderer3d.cpp @@ -0,0 +1,73 @@ +#include "Renderer3d.h" +#include "Shader.h" +#include "mathlib.h" +#include "WebglContext.h" +#include "Logger.h" + +// Note: In the 'transform' attribute, the transform.x is the scale, +// transform.y is the rotation, and transform.zw is the translatiob. +const char* vertexShader = +"attribute vec4 position; \n" +"attribute vec4 color; \n" +"uniform mat4 projection; \n" +"uniform mat4 model; \n" +"varying lowp vec4 VertexColor; \n" +"void main() { \n" +" vec4 fragmentPosition = projection * model * position; \n" +" gl_Position = fragmentPosition; \n" +" VertexColor = color; \n" +"}"; + +const char* fragmentShader = +"varying lowp vec4 VertexColor; \n" +"void main() { \n" +" gl_FragColor = VertexColor; \n" +"}"; + +EM_BOOL onScreenSizeChanged_3D(int eventType, const EmscriptenUiEvent *uiEvent, void *userData) { + Renderer3D* renderer = (Renderer3D*)userData; + + EMSCRIPTEN_RESULT result = emscripten_set_canvas_element_size( renderer->context->query, uiEvent->documentBodyClientWidth, uiEvent->documentBodyClientHeight); + if (result != EMSCRIPTEN_RESULT_SUCCESS) { + logger_error("Failed to resize element at query: %s\n", renderer->context->query); + } + //renderer->projection = Mat4x4().getOrthographicMatrix(0, renderer->context->width, 0, renderer->context->height); + + return true; +} + +void Renderer3D::load(WebglContext* inContext) { + context = inContext; + printf("Compiling Renderer2d shader...\n"); + shader = loadShader(vertexShader, fragmentShader); + + useShader(shader); + attributes.position = getShaderAttribute(shader, "position"); + attributes.color = getShaderAttribute(shader, "color"); + uniforms.projection = getShaderUniform(shader, "projection"); + uniforms.model = getShaderUniform(shader, "model"); + projection = Mat4x4().getPerspectiveProjection(0.1, 100.f, DEG_TO_RAD(60.f), static_cast<f32>(context->width) / static_cast<f32>(context->height)); + + logger_info("Renderer2d shader compiled.\n"); + + emscripten_set_resize_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, this, false, onScreenSizeChanged_3D); +} + +void Renderer3D::render() { + glEnable(GL_DEPTH_TEST); + glDepthFunc(GL_LEQUAL); + glDepthMask(GL_TRUE); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + glEnable(GL_BLEND); + glClearColor(clearColor.x, clearColor.y, clearColor.z, clearColor.w); + glClearDepth(1.0f); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); + useShader(shader); + setShaderMat4(uniforms.projection, projection); +} + +void Renderer3D::unload() { + glClearColor(0.f, 0.f, 0.f, 0.f); + glClear(GL_COLOR_BUFFER_BIT); + glDeleteProgram(shader); +} diff --git a/themes/Renderer3d.h b/themes/Renderer3d.h new file mode 100644 index 0000000..add41d7 --- /dev/null +++ b/themes/Renderer3d.h @@ -0,0 +1,46 @@ +#ifndef RENDERER3D_H +#define RENDERER3D_H +#include "mathlib.h" +#include "list.h" +#include "types.h" +#include <string> + +struct Vertex3d { + Vector4 position; + Vector4 color; +}; + +struct Mesh3d { + u32 vao; + u32 vbo; + u32 ebo; + matte::List<Vertex3d> vertices; + matte::List<u32> indices; + Mat4x4 model; +}; + +struct WebglContext; +struct Renderer3D { + WebglContext* context = NULL; + Mat4x4 projection; + u32 shader; + Vector4 clearColor; + + struct { + i32 position; + i32 color; + } attributes; + + struct { + i32 projection; + i32 model; + } uniforms; + + void load(WebglContext* context); + void render(); + void unload(); +}; + +Mesh3d Mesh3d_fromObj(std::string content); + +#endif
\ No newline at end of file diff --git a/themes/Snowflake.cpp b/themes/Snowflake.cpp index 7379ba3..1e1e648 100644 --- a/themes/Snowflake.cpp +++ b/themes/Snowflake.cpp @@ -1,11 +1,11 @@ #include "Snowflake.h" #include "Renderer2d.h" #include "mathlib.h" -#include "List.h" +#include "list.h" const Vector4 snowColor = Vector4(1.0, 0.98, 0.98, 1); -inline void generateSnowflakeShape(List<Renderer2dVertex>* vertices, i32 numArms, f32 radius, f32 innerRadius) { +inline void generateSnowflakeShape(matte::List<Vertex2D>* vertices, i32 numArms, f32 radius, f32 innerRadius) { f32 dx = ((2 * PI) / numArms) / 3.0; for (i32 centerIdx = 0; centerIdx < (3 * numArms); centerIdx+=3) { f32 degreeStart = dx * centerIdx; @@ -83,13 +83,13 @@ void SnowflakeParticleRenderer::load(SnowflakeLoadParameters params, Renderer2d* glGenBuffers(1, &vbo); glBindBuffer(GL_ARRAY_BUFFER, vbo); - glBufferData(GL_ARRAY_BUFFER, vertices.numElements * sizeof(Renderer2dVertex), &vertices.data[0], GL_DYNAMIC_DRAW); + glBufferData(GL_ARRAY_BUFFER, vertices.numElements * sizeof(Vertex2D), &vertices.data[0], GL_DYNAMIC_DRAW); glEnableVertexAttribArray(renderer->attributes.position); - glVertexAttribPointer(renderer->attributes.position, 2, GL_FLOAT, GL_FALSE, sizeof(Renderer2dVertex), (GLvoid *)0); + glVertexAttribPointer(renderer->attributes.position, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex2D), (GLvoid *)0); glEnableVertexAttribArray(renderer->attributes.color); - glVertexAttribPointer(renderer->attributes.color, 4, GL_FLOAT, GL_FALSE, sizeof(Renderer2dVertex), (GLvoid *)offsetof(Renderer2dVertex, color)); + glVertexAttribPointer(renderer->attributes.color, 4, GL_FLOAT, GL_FALSE, sizeof(Vertex2D), (GLvoid *)offsetof(Vertex2D, color)); for (i32 idx = 0; idx < 4; idx++) { i32 offset = (4 * sizeof(f32)) * idx; @@ -98,8 +98,8 @@ void SnowflakeParticleRenderer::load(SnowflakeLoadParameters params, Renderer2d* 4, GL_FLOAT, GL_FALSE, - sizeof(Renderer2dVertex), - (GLvoid *)(offsetof(Renderer2dVertex, vMatrix) + offset)); + sizeof(Vertex2D), + (GLvoid *)(offsetof(Vertex2D, vMatrix) + offset)); //glVertexAttribDivisor(renderer->attributes.vMatrix + idx, 1); } @@ -169,7 +169,7 @@ void SnowflakeParticleRenderer::render(Renderer2d* renderer) { setShaderMat4(renderer->uniforms.model, model); glBindBuffer(GL_ARRAY_BUFFER, vbo); - glBufferSubData(GL_ARRAY_BUFFER, 0, numVertices * sizeof(Renderer2dVertex), &vertices.data[startVertex->vtxIdx]); + glBufferSubData(GL_ARRAY_BUFFER, 0, numVertices * sizeof(Vertex2D), &vertices.data[startVertex->vtxIdx]); glBindVertexArray(vao); glDrawArrays(GL_TRIANGLES, 0, numVertices); diff --git a/themes/Snowflake.h b/themes/Snowflake.h index 6e0934e..248034c 100644 --- a/themes/Snowflake.h +++ b/themes/Snowflake.h @@ -1,9 +1,9 @@ #include "types.h" #include "mathlib.h" -#include "List.h" +#include "list.h" struct Renderer2d; -struct Renderer2dVertex; +struct Vertex2D; struct SnowflakeLoadParameters { i32 maxSnowflakes = 1000; @@ -45,7 +45,7 @@ struct SnowflakeParticleRenderer { u32 vao; u32 vbo; Mat4x4 model; - List<Renderer2dVertex> vertices; + matte::List<Vertex2D> vertices; void load(SnowflakeLoadParameters params, Renderer2d* renderer); void update(f32 dtSeconds); diff --git a/themes/TreeShape.cpp b/themes/TreeShape.cpp index dfbf875..a3ae8f7 100644 --- a/themes/TreeShape.cpp +++ b/themes/TreeShape.cpp @@ -5,7 +5,7 @@ #include <cfloat> #include <ctime> -void TreeBranchLoadData::fillVertices(Renderer2dVertex* vertices, int branchTier) { +void TreeBranchLoadData::fillVertices(Vertex2D* vertices, int branchTier) { bottomLeft = Vector2 { position.x - width / 2.f, position.y }.rotateAround(rotation, position); bottomRight = Vector2 { position.x + width / 2.f, position.y }.rotateAround(rotation, position); topLeft = (Vector2 { position.x - width / 2.f, position.y + height }).rotateAround(rotation, position); @@ -33,7 +33,7 @@ TreeShapeLoadResult TreeShape::load(Renderer2d* renderer) { TreeBranchLoadData* generationData = new TreeBranchLoadData[numBranches]; updateData = new TreeBranchUpdateData[numBranches]; - vertices = new Renderer2dVertex[numVertices]; + vertices = new Vertex2D[numVertices]; // The load result will contain information that we can pass on to our leaf renderer. TreeShapeLoadResult lr; @@ -51,17 +51,17 @@ TreeShapeLoadResult TreeShape::load(Renderer2d* renderer) { glGenBuffers(1, &vbo); glBindBuffer(GL_ARRAY_BUFFER, vbo); - glBufferData(GL_ARRAY_BUFFER, numVertices * sizeof(Renderer2dVertex), &vertices[0], GL_DYNAMIC_DRAW); + glBufferData(GL_ARRAY_BUFFER, numVertices * sizeof(Vertex2D), &vertices[0], GL_DYNAMIC_DRAW); glEnableVertexAttribArray(renderer->attributes.position); - glVertexAttribPointer(renderer->attributes.position, 2, GL_FLOAT, GL_FALSE, sizeof(Renderer2dVertex), (GLvoid *)0); + glVertexAttribPointer(renderer->attributes.position, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex2D), (GLvoid *)0); glEnableVertexAttribArray(renderer->attributes.color); - glVertexAttribPointer(renderer->attributes.color, 4, GL_FLOAT, GL_FALSE, sizeof(Renderer2dVertex), (GLvoid *)offsetof(Renderer2dVertex, color)); + glVertexAttribPointer(renderer->attributes.color, 4, GL_FLOAT, GL_FALSE, sizeof(Vertex2D), (GLvoid *)offsetof(Vertex2D, color)); for (i32 idx = 0; idx < 4; idx++) { glEnableVertexAttribArray(renderer->attributes.vMatrix + idx); - glVertexAttribPointer(renderer->attributes.vMatrix + idx, 4, GL_FLOAT, GL_FALSE, sizeof(Renderer2dVertex), (GLvoid *)(offsetof(Renderer2dVertex, vMatrix) + (idx * 16))); + glVertexAttribPointer(renderer->attributes.vMatrix + idx, 4, GL_FLOAT, GL_FALSE, sizeof(Vertex2D), (GLvoid *)(offsetof(Vertex2D, vMatrix) + (idx * 16))); glVertexAttribDivisor(renderer->attributes.vMatrix + idx, 1); } @@ -77,7 +77,7 @@ const f32 ninetyDegreeRotation = PI / 2.f; void TreeShape::createBranch(TreeLoadData* ld, TreeBranchLoadData* generationData, i32 numBranches, i32* branchIndex, i32 branchLevel, f32 width, f32 height, Vector2 position, f32 rotation, - TreeBranchUpdateData* parent, Renderer2dVertex* vertices, TreeShapeLoadResult* lr) { + TreeBranchUpdateData* parent, Vertex2D* vertices, TreeShapeLoadResult* lr) { TreeBranchLoadData* branchLoadData = &generationData[*branchIndex]; branchLoadData->width = width; branchLoadData->height = height; @@ -196,7 +196,7 @@ void TreeShape::render(Renderer2d* renderer) { setShaderMat4(renderer->uniforms.model, model); glBindBuffer(GL_ARRAY_BUFFER, vbo); - glBufferSubData(GL_ARRAY_BUFFER, 0, numVertices * sizeof(Renderer2dVertex), &vertices[0]); + glBufferSubData(GL_ARRAY_BUFFER, 0, numVertices * sizeof(Vertex2D), &vertices[0]); glBindVertexArray(vao); glDrawArrays(GL_TRIANGLES, 0, numVertices); diff --git a/themes/TreeShape.h b/themes/TreeShape.h index 49ea083..32b00d3 100644 --- a/themes/TreeShape.h +++ b/themes/TreeShape.h @@ -27,7 +27,7 @@ struct TreeBranchLoadData { Vector2 topRight; Vector2 topMidpoint; - void fillVertices(Renderer2dVertex* vertices, int branchTier); + void fillVertices(Vertex2D* vertices, int branchTier); }; struct TreeBranchUpdateData { @@ -36,7 +36,7 @@ struct TreeBranchUpdateData { f32 period = 0; f32 amplitude = 0; Vector2 currentOffset; - Renderer2dVertex* vertices = NULL; + Vertex2D* vertices = NULL; TreeBranchUpdateData* branchToFollow = NULL; }; @@ -51,7 +51,7 @@ struct TreeShapeLoadResult { struct TreeShape { // Update data TreeBranchUpdateData* updateData = NULL; - Renderer2dVertex* vertices = NULL; + Vertex2D* vertices = NULL; f32 timeElapsedSeconds = 0.f; f32 animateTimePerTier = 1.f; f32 animateStaggerPerTier = 0.2f; @@ -66,7 +66,7 @@ struct TreeShape { TreeShapeLoadResult load(Renderer2d* renderer); void createBranch(TreeLoadData* ld, TreeBranchLoadData* branchList, i32 numBranches, i32* branchIndex, i32 branchLevel, f32 width, f32 height, - Vector2 position, f32 rotation, TreeBranchUpdateData* parent, Renderer2dVertex* vertices, TreeShapeLoadResult* lr); + Vector2 position, f32 rotation, TreeBranchUpdateData* parent, Vertex2D* vertices, TreeShapeLoadResult* lr); void update(f32 dtSeconds); void render(Renderer2d* renderer); void unload(); diff --git a/themes/a.out.wasm b/themes/a.out.wasm Binary files differdeleted file mode 100755 index 83398bf..0000000 --- a/themes/a.out.wasm +++ /dev/null diff --git a/themes/dist/output.wasm b/themes/dist/output.wasm Binary files differindex bf3e6ba..1c12a60 100755 --- a/themes/dist/output.wasm +++ b/themes/dist/output.wasm diff --git a/themes/list.h b/themes/list.h new file mode 100644 index 0000000..0c5b0a1 --- /dev/null +++ b/themes/list.h @@ -0,0 +1,243 @@ +#pragma once +#include <cstdlib> +#include <cstring> +#include "Logger.h" + +#define FOREACH(list) \ + for (i32 idx = 0; idx < list.numElements; idx++) \ + if (auto value = &list[idx]) \ + +namespace matte { + template <typename T> + struct List { + T* data = nullptr; + size_t capacity = 0; + size_t numElements = 0; + bool growDynamically = true; + + void allocate(size_t size); + void add(T& element); + void add(T&& element); + void add(T* element); + bool grow(size_t newSize); + void set(T& value, size_t index); + void set(T&& value, size_t index); + void set(T* value, size_t index); + void remove(size_t index); + void clear(); + void deallocate(); + bool isEmpty() { + return data == nullptr || numElements == 0; + } + T& getValue(int index) const; + T& operator[](int idx) const; + void binarySort(int (*f)(const T& first, const T& second)); + void setFromArray(T* arry, int size) { + allocate(size); + memcpy(data, arry, size * sizeof(T)); + numElements = size; + } + void remove(int index) { + if (index >= numElements) { + logger_error("Cannot remove element at index: %d", index); + return; + } + + + if (index == numElements - 1) { + numElements--; + return; + } + + memmove(&data[index], &data[index + 1], sizeof(T) * (numElements - index)); + numElements--; + } + }; + + template <typename T> + void List<T>::allocate(size_t size) { + if (size == 0 || size == capacity) { + numElements = 0; + return; + } + + if (data != nullptr) { + deallocate(); + } + + data = static_cast<T*>(malloc(sizeof(T) * size)); + capacity = size; + numElements = 0; + } + + template <typename T> + bool List<T>::grow(size_t newSize) { + if (!growDynamically) { + return false; + } + + if (newSize == 0) { + return false; + } + + T* newData = static_cast<T*>(malloc(sizeof(T) * newSize)); + + if (data != nullptr) { + memcpy(newData, data, numElements * sizeof(T)); + delete data; + } + + data = newData; + capacity = newSize; + return true; + } + + template <typename T> + void List<T>::set(T& value, size_t index) { + if (index >= capacity && !grow(index * 2)) { + return; + } + + memcpy(&data[index], value, sizeof(T)); + } + + template <typename T> + void List<T>::set(T&& value, size_t index) { + if (index >= capacity && !grow(index * 2)) { + return; + } + + data[index] = value; + } + + template <typename T> + void List<T>::set(T* value, size_t index) { + if (index >= capacity && !grow(index * 2)) { + return; + } + + memcpy(&data[index], value, sizeof(T)); + } + + template <typename T> + void List<T>::add(T* element) { + if (data == nullptr) { + allocate(2); + } + + if (element == nullptr) { + logger_error("Element not defined"); + return; + } + + size_t newNumElements = numElements + 1; + if (newNumElements > capacity) { + if (!grow(2 * capacity)) { + logger_error("Trying to add to list but unable to grow the array"); + return; + } + } + + memcpy(&data[numElements], element, sizeof(T)); + numElements = newNumElements; + } + + template <typename T> + void List<T>::add(T& element) { + if (data == nullptr) { + allocate(2); + } + + size_t newNumElements = numElements + 1; + if (newNumElements > capacity) { + if (!grow(2 * capacity)) { + logger_error("Trying to add to list but unable to grow the array"); + return; + } + } + + memcpy(&data[numElements], &element, sizeof(T)); + numElements = newNumElements; + } + + template <typename T> + void List<T>::add(T&& element) { + if (data == nullptr) { + allocate(2); + } + + size_t newNumElements = numElements + 1; + if (newNumElements > capacity) { + if (!grow(2 * capacity)) { + logger_error("Trying to add to list but unable to grow the array"); + return; + } + } + + memcpy(&data[numElements], &element, sizeof(T)); + numElements = newNumElements; + } + + template <typename T> + void List<T>::remove(size_t idx) { + if (idx >= numElements) { + logger_error("Index is outside of the list: %d >= %d", idx, numElements); + return; + } + + for (; idx < numElements - 1; idx++) { + data[idx] = data[idx + 1]; + } + + numElements--; + } + + template <typename T> + void List<T>::deallocate() { + if (data != nullptr) { + free(data); + data = nullptr; + } + + capacity = 0; + numElements = 0; + } + + template <typename T> + void List<T>::clear() { + numElements = 0; + } + + template <typename T> + T& List<T>::getValue(int idx) const { + return data[idx]; + } + + template <typename T> + T& List<T>::operator[](int idx) const { + return data[idx]; + } + + template <typename T> + void List<T>::binarySort(int (*f)(const T& first, const T& second)) { + if (data == nullptr) { + return; + } + + for (size_t idx = 0; idx < numElements - 1; idx++) { + int minIdx = idx; + T firstValue = data[idx]; + + for (int innerIdx = idx + 1; innerIdx < numElements; innerIdx++) {\ + T secondValue = data[innerIdx]; + if (f(data[idx], data[innerIdx]) > 0) { + minIdx= innerIdx; + } + } + + T temp = data[minIdx]; + memmove(&data[minIdx], &data[idx], sizeof(T)); + memmove(&data[idx], &temp, sizeof(T)); + } + } +}
\ No newline at end of file diff --git a/themes/main.cpp b/themes/main.cpp index ad78f31..d3966af 100644 --- a/themes/main.cpp +++ b/themes/main.cpp @@ -1,7 +1,7 @@ -#include "Renderer2d.h" #include "WebglContext.h" #include "MainLoop.h" #include "Renderer2d.h" +#include "Renderer3d.h" #include "types.h" #include "TreeShape.h" #include "LeafParticleRender.h" @@ -37,9 +37,9 @@ struct WinterTheme { }; struct SpringTheme { - void load(Renderer2d* renderer); + void load(Renderer3D* renderer); void update(f32 dtSeconds); - void render(Renderer2d* renderer); + void render(Renderer3D* renderer); void unload(); }; @@ -52,7 +52,8 @@ EM_BOOL selectWinter(int eventType, const EmscriptenMouseEvent* mouseEvent, void EM_BOOL selectSpring(int eventType, const EmscriptenMouseEvent* mouseEvent, void* userData); WebglContext context; -Renderer2d renderer; +Renderer2d renderer2d; +Renderer3D renderer3d; MainLoop mainLoop; Theme activeTheme = Theme::Default; AutumnTheme autumnTheme; @@ -79,18 +80,20 @@ void load(Theme theme) { unload(); // Try and unload before we load, so that we start fresh activeTheme = theme; - renderer.load(&context); mainLoop.run(update); switch (activeTheme) { case Theme::Autumn: - autumnTheme.load(&renderer); + renderer2d.load(&context); + autumnTheme.load(&renderer2d); break; case Theme::Winter: - winterTheme.load(&renderer); + renderer2d.load(&context); + winterTheme.load(&renderer2d); break; case Theme::Spring: - springTheme.load(&renderer); + renderer3d.load(&context); + springTheme.load(&renderer3d); break; default: break; @@ -114,16 +117,18 @@ void update(f32 dtSeconds, void* userData) { } // -- Render - renderer.render(); switch (activeTheme) { case Theme::Autumn: - autumnTheme.render(&renderer); + renderer2d.render(); + autumnTheme.render(&renderer2d); break; case Theme::Winter: - winterTheme.render(&renderer); + renderer2d.render(); + winterTheme.render(&renderer2d); break; case Theme::Spring: - springTheme.render(&renderer); + renderer3d.render(); + springTheme.render(&renderer3d); break; default: break; @@ -148,7 +153,8 @@ void unload() { activeTheme = Theme::Default; if (mainLoop.isRunning) { mainLoop.stop(); - renderer.unload(); + renderer2d.unload(); + renderer3d.unload(); } } @@ -231,7 +237,7 @@ void onBunnyFail(emscripten_fetch_t *fetch) { emscripten_fetch_close(fetch); // Also free data on failure. } -void SpringTheme::load(Renderer2d* renderer) { +void SpringTheme::load(Renderer3D* renderer) { renderer->clearColor = Vector4(160, 231, 160, 255.f).toNormalizedColor(); emscripten_fetch_attr_t attr; @@ -246,7 +252,7 @@ void SpringTheme::load(Renderer2d* renderer) { void SpringTheme::update(f32 dtSeconds) { } -void SpringTheme::render(Renderer2d* renderer) { +void SpringTheme::render(Renderer3D* renderer) { } void SpringTheme::unload() { |