This contains many personal projects, class projects, and some just for fun.

This project was made to learn more about vulkan, using the GPU, raytracing, and bounding volume hierarchies (BVHs). It also doubled as a thesis-equivalent project for my graduation from UNO w/ a Master of Science in CS. The main goal was to take a GPU-based raytracer and add a GPU constructed bounding volume hierarchy to decrease the impact of larger poly-counts on performance. This involved implementing the raytracer based on my previous projects (see Ritis and CPU-based raytracer) and then implementing Tero Karras' "Maximizing Parallelism in the Construction of BVHs, Octrees, and k-d Trees" .

To implement this, a pipeline was created to construct an Axis-Aligned Bounding Box (AABB) which contained all the center points of the primitives (triangles and spheres) (the average of the triangle's 3 vertices was used as the center point). Then all center points were converted into Morton Codes with 10 bits per axis, so 30 bit integers. These were then sorted using a radix sort (was able to use the very cool function subgroupExclusiveAdd (see this for details)). Then the BVH was constructed using a 2-step method: First construct all the leaf nodes (1 per primitive) then construct every internal node. No recursive dependencies! After all that, AABBs were made for every node and the BVH was ready for traversal.

There are many ways to further improve this. The most obvious and likely simplest would be including a BRDF to improve approximation of the Rendering Equation, as that term is currently ignored. Importance sampling would also improve the program in a similar way. Other ideas I learned about on the way such as ray-reordering methods would likely go far in fully-utilizing the GPU. Other things that would improve performance include:

• Utilizing the swapchain. A swapchain was used but semaphores and fences block processing multiple frames at once. Replicating resources would resolve this issue.
• Expanding some shaders to work with multiple workgroups. For complexity, computing the enclosing AABB (inherently a reduction operation) and radix sort were both done with a single workgroup.
• Write only modifications to model and primitive buffers. Currently, to replicate a game engine-like environment, modification to objects between frames is allowed. This means transfering those modifications must be done every frame. As it currently operates, all buffer contents are rewritten every frame.
• Improve randomization. Much to my suprise as I worked on this, GLSL didn't appear to have a random number generator available. I found a resource online to help implement one (as random number generation is a rather intricate and involved space), however it would generate a new random number based on a random value from the CPU. This works fine in a lot of cases, but not in this one. My raytracer fired 1 ray per pixel everytime it was invoked. To fire more than one per pixel, the shader was run twice. This could be easily done while avoiding returning to the CPU between invocations. However, this means each shader invocation has the same random seed. This resulted in rays fired from one pixel all behaving the same. To solve, this I used the alpha channel of the output image to store randomization data in a float that the next invocation could use to set it's random seed. I doubt this is a great way to achieve this. CUDA seems to have random number generation available. Perhaps OpenCL does as well.

side note: Vulkan does provide a raytracing pipeline that would almost certainly outperform the results I achieved, but I wouldn't have learned as much if I used it.

Proposal

Defense

Worked alongside Dr. Brian Ricks, Dr. Robin Gandhi, Dr. Christian Haas, Dr. Yonas Kassa, and, recently inducted, Dr. Akshay Kale. I created a visualization program which attempted to construct a region within model space, an N-dimensional space where N input parameters (the inputs to the machine learning model) would uniquely identify a coordinate, at which, the result of the model resided. This region was condensed down into a 2-dimensional plane. The goal was to identify decision boundaries, the lines that separate a region where a model decided one option from another. We are currently working to publish this work.

This project was really fun and challenging. We had to create a device that would take in information which would be used to fill in specifc ovals on an ES&S (Election Systems and Software) 11x8.5" ballot. The ballots would then be used for testing the physical election machines ES&S produce. Being test ballots, these essentially looked like a Scantron form.

I mimicked this view in a .NET framework Windows app. The Windows app would then communicate over USB (using a custom written driver (included in the LPC5512 code)) to a PCB designed by the team. The board needed to be programed to interact with a servo motor to move the pen up and down, 2 stepper motors to drive the arms of an XY-plotter, an IR sensor to attempt Localization, a 7-segment display for displaying Error Codes, and 5 buttons.

I wrote all of the code in the 2 linked repos to accomplish this. The rest of the team worked on the other aspects, such as project management, designing and ordering the PCB and components, and designing power circuitry.

Video Demonstration

Capstone Presentation

Report

My co-worker, Gus, and I made this one. It was a request by the U.S. State Department to create a site that shows university partnerships between the United States and India. I did most of the map work and a large portion of the frontend, while Gus handled almost all of the backend and some frontend.

Perhaps my favorite part of this work was a challenge I was given. The team wanted to create a nice visualization where a dotted line from one US state to one Indian Province. It was to appear, sit for a bit, then remove itself, then repeat. The first task was creating the lines. We can randomly select a state and a province and a properly placed center point was added to the map. But now we have 2 points and need to create a parabola that fits within the screen. With just 2 points, there are an infinite number of parabola to choose from. I created a fake third point and used it to solve a system of equations. These three points uniquely define a parabola of the form:

ax² + bx + c = y

Solving for the coefficients a, b, and c with points (x1, y1), (x2, y2), and (x3, y3) results in these indimidating lines of code

With these coefficients, a large sampling of points can be generated and used to create a path on the svg. Apply a few css effects and you get the entering and exiting lines.

This project follows along w/ a tutorial. It creates an editor and underlying engine.

Far from useful at the moment, but currently in progress.

This project follows along w/ a tutorial and served as my introduction into vulkan. It's capable of rendering models via .OBJ files and supports point lights.

Need to go back and add support for textures to explore how Vulkan deals with those.

My team at the Attic was responsible for rewriting the UNePlan software for UNeTech, an offshoot company of the University of Nebraska Medical Center. It's a strategic planning tool. We actually encapsulate a tree in the db. The backend is Django and the frontend is Vue 2.

I can't show the actual repo/code, as it is now their product, but here's their website.

Alongside playing with 3DSMax, CSCI 4620 also had us create a raytracer which could parse .obj files and render an image of a scene. I worked with OpenCV to get this working. The professor programed in Java, but I got permission to practice some C++, so I wrote it in that.

Currently a work in progress. Takes in images and can apply basic transform, rotate, scale, send an image to greyscale, remove colors, convert an image into a histogram displaying frequency of color Value, and sooner or later, stegonography.

A game made in Browser using JS and a canvas element. It's sort of a bullet hell, but not very extensive.

As part of my Theory of Computation class, I created an NFA (non-deterministic finite automata) to DFA (deterministic finite automata) converter. Since an NFA is basically just a vague DFA (some transitions to self are ignored) it can be converted to a DFA. In this project, I had just learned about Java's Collection's streams... so it's like 90% stream objects.

My friends often discussed DND5e stat generation methods. So I just did all of them and calculated some stats on each way of rolling stats. To be honest, this was a mistake. With multithreading (using my personal, and rather bad, thread management strategy), this took my poor laptop 18 straight hours to calculate. The output .csv file is 3 GB. I had to download a custom program to even read the file as excel just crashes. This project calculates all combinations of dice between d4, d6, d8, d10, d12, and d20 such that no dice type has more than 11 of itself in the set (ie, 2d4 + 10d6 + 3d8 would be tested, but 27d4 would not). That's about 12 million dice combinations (or at least that's how many rows were in the CSV). Shoulda checked how many combinations before running it, I think.

Here are some other projects based around generating stats for DND concepts:

DND5e Stats via Cards

DND5e Damage calculator

Advantage Vs +modified

Point Buy Vs Roll 4d6 drop lowest

Chance of rolling at least 1 16

Got the opportunity to take a chaos theory class and it's follow-up, a boolean networks class. I made some projects for the classes. For the chaos theory class, I made: A GPU-accelerated visualization of the Logistic Map And for the boolean networks class, I made: A modeling and evaluation program for boolean networks and cellular automata. Ended up being entirely too verbose, but the evaluation portion was useful.

I started reading about chaos in high school. Then I started writing small java programs to draw the graphs. Here's a bunch of them.

Made this in Highschool with a friend. It isn't very good and it's also very buggy, but you can walk around and collect coins and that's pretty cool. First game I ever made.