Thomas McConkey

I added a table for submissions and a page to view individual submissions. My next task is to set up some CSS and do some refactoring and tweaks for permissions and authentication.

I added submission grading for Java. I plan to also offer an option to use Docker containers for grading for better security. There isn't a frontend interface to see submissions yet so here's a picture of the database lol:

Not much, but I have some basic pages set up for home and code submission:

I spent a lot of time on setting up Flask and Svelte, but so far I have user authentication, contest db models, and a setup script that works off of a .yaml file.

I added those section and panel collapse buttons, some color map options for more variety, and wrote a README.md.

I did a massive UI overhaul on the side panel where I added some tutorial text and preset buttons. I still do want to add some buttons that can optionally hide the side panel and its sections of text, but it's almost 4am and I should probably get some sleep lol.

I added support for implicit multiplication, panning, and zooming. The site does, so I kind of want to do a quick rewrite of this project as a desktop app just to see the performance difference.

You can now set the initial z value of the fractal with another math formula entry. I also added sliders for user defined variables. These sliders automatically pop up if there are variables detected in either the z(0) or f(z) math input areas.

I converted the AST into shader code so now different fractals can be rendered based off user input!

I implemented a lexer and parser to generate an Abstract Syntax Tree from the Mathquill Equation text entry (Mathquill is the library the Desmos Graphing Calculator uses). Right now it generates a new AST every time the user changes the equation.

I got a basic Julia Set shader working, and I sort of ported my entire codebase to Typescript... but the WebGPU code is a lot less verbose now and it's easier to integrate everything with the web since I don't have to compile to web assembly everytime.

Spent a bunch of time learning about buffers and shader uniforms in WebGPU. Having past experience with OpenGL definitely helps. Next, I want to get a web build with Emscripten working and hopefully render a basic Julia Set.

Now rendering a triangle! I am going to learn how to use buffers and uniforms in WebGPU next after which I will do some major code organization and try to get this running in the browser using Emscripten.

I got a color rendering to a window lol. It may not look like much, but it took me a long time to learn the basic setup for WebGPU using C++.

Alright, so I spent a lot of time writing a README.md, recording a demo video, and building and testing the project on Windows and macOS. I think I should be able to ship this project pretty soon!

Yeah, so I told myself I was going to write a README and record a demo video so I could get this project shipped today, but a little voice in my head told me to keep trying to get the Gray-Scott Reaction Diffusion model working (my first attempt failed last weekend). Surprisingly, I actually was able to figure it out, so now there's a cool, nonlinear pattern formation PDE in my program! Aside from that, I made some UI tweaks and added a pop up for when numerical instability occurs that resets the solver.

I added to the repository as a PDF the notes I took while learning finite element from online lectures on YouTube. I also wrote a cleaned up version of my derivations for the linear systems of each equation currently implemented in the program and added them to the repo as images.

Shorter devlog this time: Downgraded the project to OpenGL 3.3 Core, made a new icon, and replaced the old colormaps with some new ones.

I meant to split this into multiple devlogs but I forgot lol. I spent a lot of time revamping the GUI alongside ironing out bugs and adding error checking in some spots (like file loading).

I also decided not to write a GPU solver (definitely not because I am too lazy). This means that I can switch down to an older version of OpenGL that supports macOS since I no longer need compute shaders.

I spent way too long getting BVH (Bounding Volume Hierarchy) optimization to work so that mouse picking to draw on the mesh is now O(log n) instead of O(n). To speed up the solver even more, I am (hopefully) going to write a sparse matrix conjugate gradient solver with compute shaders to take advantage of the GPU for parallelism. Before that though, I need to clean up my code a bit as well as make an actual UI that isn't just buttons.

+added importing meshes through .obj so that you can solve PDEs on non-planar surfaces.

+added two new solvers: Wave Equation and Advection-Diffusion Equation.

+the surface is now a height map based on the value of the node at each vertex.

+the brush can now be dragged and time steps occur every frame.

Before I finalize this project and ship it, I still want to add BVH optimization for mouse picking, GPU solvers using compute shaders, and improve the UI.

It's been a while since I've worked on this project, but today I just did some refactoring including writing documentation to get reacquainted with the code base after a week long break.

I wrote this resource manager class (which right now is basically just a wrapper around std::unordered_map) which allows me to better manage things like shared shaders and meshes across the project.

It's been a few days since my last devlog since I've only been working a little less than an hour each day. However, I did get the CPU solver to work with the 2D Heat Equation with zeroed Dirichlet boundary conditions with the help of Eigen, a C++ Linear Algebra library.

Once a surface is created by triangulating a planar straight line graph (or, later on, importing a .obj file), the solver is initialized which sets up the stiffness and mass matrices using Eigen's sparse matrices (matrices where the entries are mostly zero).

From there, time stepping is performed using an implicit Euler scheme and the Conjugate Gradient method provided by Eigen, which works very efficiently with sparse matrices. Right now the time stepping is triggered by a button in the GUI but I plan to have it constantly run every frame so the user can see the propagation of the solution more smoothly.

I learned most of this from watching Professor Qiqi Wang's lectures on Numerical Methods which I found on YouTube (https://www.youtube.com/playlist?list=PLcqHTXprNMIOEwNpmNo7HWx68FzBTxTh3). I took a bunch of notes on paper, but I plan to digitize them so I can include them with the repository as a large part of the work on this project was understanding the fundamental procedures for FEM.

Surprisingly I finished quite a lot in only about 2.5 hours.
- I added the ability to designate closed regions as holes so that they do not get triangulated. You can see this in action at the beginning of the video.
- After that, I added these little sphere meshes that are rendered in the positions of the nodes and take on the color based off of a color map and the node's value (in this case it is Viridis from matplotlib which I copied from here https://www.shadertoy.com/view/Nd3fR2). I also plan to have an option where the height of the vertex changes depending on its value.
- Added a colored mesh where the colors are determined by interpolating the colors of its 3 vertices across each triangle's surface.
- Added a brush that sets the value of all the nodes of a triangle via mouse picking.

The next step after this is probably going to be implementing the FEM solver on the CPU for the 2D Heat Equation. Be warned though, the solver is going to be excruciatingly slow! I do plan to write a GPU accelerated solver later on once I get the CPU version working.

I added PSLG triangulation so now we are one step closer to the FEM solver (at least for planar surfaces). On top of that, I added some more GUI elements, namely a pop up window to catch invalid use of the triangulation button and a small window that appears in the top left of the viewport that displays controls for the current mode.

I added the ability to draw PSLG's (Planar Straight Line Graphs) on the XZ plane using the mouse.

To extend this, I plan to add a feature that allows users to import an image into the world as a 2D quad to act as a stencil to trace the PSLG over as well as have an option to export and import saved PSLG's to and from a file for convenience.

The next step from here is to triangulate this into a mesh suited for FEA using the triangle library I added earlier.

Added a little sidebar for the GUI that can be toggled on and off. This is where are all the sliders and other menu items will reside.

I spent some time refactoring the code to be more modular so I can avoid headaches later down the line lol

I set up an OpenGL C++ repository along with some other utility libraries such as triangle (2D triangulation library) and tinyobjloader.

After that, I started 3D rendering with an orbital camera that can rotate around a point, pan to move said point, and zoom in and out from the point. Also, you can switch between a perspective and orthographic projection (which will be useful when switching between the 3D and 2D mode).

Finally, I made it so that the orbit point and the grid (y=0) are drawn which creates a better sense of space in the scene.