amdreallyfast Goto Github PK

2d_gpu_pcollisionusingbvh

This demo shows how I use GPU compute shaders to make particles collide with 2D geometry.

2d_gpu_pcollisionwithgeometry

This project demonstrates particles colliding with each other and with Blender3D .obj-loaded geometry. This demo is only in 2D, so it is only parsing lines from the .obj file.

2d_gpu_pcollisionwithzordercurveradixsortbvh

Attempts to sort particles in 2D space using Morton Codes, then sorts the particles using the codes and a parallel Radix Sort, then uses the sorted particles to construct a BVH. THEN it does particle collisions.

2d_gpu_pcollisionwithzordercurveradixsorting

After ~4 months of learning about parallel sorting and what was wrong with the previous particle collision project (instruction divergeance and data divergence), I have now created a particle collision program that performs much better. It uses a parallel radix sort algorithm that sorts over Morton Codes. Collisions are detected by examining the neighboring particles.

directx_graphics_pad

followingvulkantutorial.com

As per the title, following along with www.vulkan-tutorial.com.

fork-dreambooth-sd-optimized

My fork of Dreambooth with Stable Diffusion so that I don't mess up the real thing by accident

freeglut_glload

A simple demonstration of how to start a window to render in and take basic keyboard inputs using Freeglut and glload.

freetype_atlas

Builds on freetype_basic project by encapsulating Freetype functionality into a class.

freetype_atlas_encapsulated_framerate

A demonstration of how to use a FreeType atlas to make a frame rate counter.

freetype_basic

A simple (as much as I could, at least) demonstrating how use Freetype to load characters one by one.

gpuradixsort

This demo sorts an SSBO composed of generic OriginalData structures according to a particular value in the OriginalData structure. This is a more practical application (for me) than a simple Radix sorting over integers because this demo lays the groundwork for me being able to sort many Particle structures along a Z-order curve by actually shuffling around the ParticleBuffer according to the particles' position-derived Morton codes. And that will be a setup for the parallel creation of a bounding volume hierarchy. A simple Radix sort over integers is nice and all, but it doesn't lay the groundwork for something practical like this demo does.

historyproject

This project will attempt to create a tool will allow historical events to be placed on a map at the time of occurrence, and to allow a user to see all other events occuring at that time. With only a few events, this is not impressive. With many events, new perspective is gained. Cultural, social, economic, and other contexts are vital to fully understanding history. Might also work for D&D and other fandoms (if we get the tool set up properly).

mplab_x_experiments

These are my experiments with Microchip's MPLAB X IDE and a Digilent rapid prototyping board powered by a Microchip PIC32 processor.

mx4ck_wireless_experiments

These are my experiments with wireless stuff in Windows and the Windows Phone.

mx4ck_wireless_scokets_opengl_rc_transceiver

This is a summary project that includes my MX4cK reading signals from an RC transceiver, sending that data to my PC using wireless socket communication, and having my PC render the RC transceiver's commands by rotating a cube.

my_dual_quaternion_paper

This is my paper that wrote as a guide to myself on complex numbers, quaternions, and particularly dual quaternions.

my_mx4ck_framework

This repo contains the source code to assist me in a number of (usually) pmod related projects.

opengl_graphics_pad

attempt 2 to create a github repo for my openGL experiments

opengl_simple_game_engine

This project follows the game engine tutorials of Jamie King's youtube channel.

render_multiple_2d_shapes

Expanding upon simple_render project, this project demonstrates how to render shapes in different buffers and at different window coordinates using glm. It is now big enough to justify expanding into multiple files.

render_multiple_2d_shapes_from_blender_obj

Loads a circle wireframe, a square plane, and a square grid with several deleted faces from a Blender-exported .obj file into my programs, then draws them. This is in 2D, and there is no camera, so the three objects had to be placed within [-1,+1] on X and Y. Depth testing is enabled with a maximum Z range of 0-1, and there are no transforms, so I used Blender to place the objects at Z=-0.5. It is a crude, proof-of-concept building block for later.

render_multiple_2d_textures

A demonstration of drawing multiple textures, one for each of my simple geometries. This program was getting big enough that, even though it is "bare bones", it required additional organization and more structured commenting and function headers.

render_particles_2d_cpu_multiple_emitters

Better organized than render_particles_2D_basic, introduces the concept of "particle regions", "particle emitters", and "particle updaters", plus drawing some vertices to match the particle regions so that it looks like the particles are hitting a visible wall instead of an invisible one. Also has a frame rate counter courtesy of FreeType.

render_particles_2d_cpu_p_on_p_collisions

This is my 2D attempt at 2D particle-particle collisions. Computations are on the CPU.

render_particles_2d_cpu_single_emitter

A simple, CPU-driven 2D particle renderer. Spits out up to 10,000 particles simultaneously in random directions and resets them when they go beyond a circular boundary.

render_particles_2d_gpu_cpu_hybrid_p_on_p_collisions

Attempting to combine the best aspects of the CPU "p on p collisions" project and the GPU "p on p collisions" project. It was found in the GPU version that it is not possible to subdivide within a compute shader. All attempts either crashed the program or crashed the computer. The CPU project really lagged when it came for collision resolution, but it shined in its ability to generate a quad tree of any size. This hybrid program upates particles on the GPU, downloads the particles' latest positions to system memory, generates a new quad tree with them using the CPU, and uploads that quad tree to the GPU for collision resolution.

render_particles_2d_gpu_multiple_emitters

Heavy lifting done in a compute shader. Demonstrates ~57,000 particles eminating from 8 different emitters inside an enclosed polygon region. When the particles hit the edges, they reset to one of the emitters. Technically handles up to 100,000 particles, but a restriction of emitting a max 200 particles per emitter per frame keeps the results around 57,000.

render_particles_2d_gpu_p_on_p_collisions

Like "render particles 2D CPU p on p collisions", this demo will collide many particles using a quad tree compute shaders. The particles and quad tree are initialized on startup on the CPU side, but everything else (quad tree reset and subdivision, particle updates, collision detection) is performed in compute shaders.

render_particles_2d_gpu_single_emitter

Like render_particles_2D_basic, this is a 2D particle renderer that spits out up to 10,000 particles simultaneously in random directions and resets them when they go beyond a circular boundary. Unlike that program, this one's particle processing runs on a compute shader instead of the CPU.