C# 2.0, DirectX 9 (Managed)

A 3D Rendering program, loads models, lights and renders them. Uses per pixel lighting w/ specular highlights and shaders. I have a ink n' paint (sort of) shader and a bloom shader. The bloom shader is non HDR, so is sort of a "fake bloom", I do not use a threshold, but an expenetional function.

If you want to put on antialising on put it on manually with your driver (usually CCC or NView). The shaders are completely customizible, and use a C like language to program, and are complied at runtime. The shaders I wrote are not very optimized (non hardcoded for the most part). To run this you need to have a video card with pixel shader 3.0 support. If you do not you can still edit the shaders to run with pixel shader 2.0, but you will have to edit them and put in your own.

You can put in your own models, you might have to change the name of the model to match one already in the program (easy hack), or edit the program (look in the Simulation class) to add or replace a name. All these models were made by me in 3Ds Max. Something weied is is if I put on anything but Point or None for filtering I get Horizontal Lines, might just be my card though.

Btw, the download is huge, because of all the textures the models use.

C# 2.0, DirectX 9 (Managed)

This is basically a shader that creates the mandelbrot set, it runs suprisingly fast, but I have a problem that yoou can't zoom in infinitely, kinda the point of fractals. So if anyone finds out how feel free to email me.

The rendering is done by drawing a quad to a screen and running a shader over it, that draws the set. The colors are controled by a texture, which is easily editible. The zooming may be limit to the accuracy of floating point numbers, but that is a bit unlikely.

As you zoom in further the computer (or rather the video card) has to run more iterations to keep the level of detail sufficient, there is also a 1024 loop limit, the entire screen is redrawn in realtime, but I think if it was designed to invalidate only parts of the screen it could be faster, Another thing that could be added is fractals in 3D, but that just makes my head hurt =) If you edit the shader you can make other stuff, like gradients, each pixel is passes x and y (in 0 to 1).

I also tried to add antialising and it worked, but was slow. You can change the way it renders the set too.

C# 2.0, DirectX 9 (Managed)

This is my first crack at shaders, it runs a shader on a texture, you can have multiple pass shaders (like a bloom shader). The test image is a bicycle I made in 3Ds Max.

The bloom shader runs by running a few passes, firstly it runs a threshold pass, which is if the RGB of a pixel is over a certain amount, it saves it. Ideally if you have HDR if the color is over 255 (or 1, however you want to think about it). It takes that color and desaturates it (or not totally doing so can have a cool effect).

Then a horizontal and vertical blur is applied (seperately, and in whatever order). It takes that and adds it to the image you had at the start, viola! you have bloom. The horizontal wave is just a sin wave running horizontally displacing the pixels.

The shader can sometimes screw up if you have filtering applied (other than Point or none), making horizontal lines, it may be alternate pixel centers (ATI only), but CCC is not working at the moment, installed a new driver but not the whole thing and it dosen't open.

C# 2.0, DirectX 9 (Managed)

This is alot like Spring Sim 4, but rewritten and uses textured quads to have a texture mapped to the springs. There is a distortion effect around the cursor, not using a shader, but just offsets the points around it, purely graphical. You can put in your own object and rip it apart! The top left pixel is the "blood" color, or for example, rock for a building (grey?).

The program can be tweaked mostly by changing values in the class "Simulation". To change the resolution of of the spring mesh, look in Base. The underlying mesh is visualized as a lattice, with motion blur applied.

Controls:

F5 - Reset

LMB (Hold) - Repulse (Small)

Space = Bomb (Repulse, Big)

The texture used is one I made, it's not very good thought... To turn up the stiffness of the springs increase the number of steps, The springs are simple Euler.

C# 2.0, DirectX 9 (Managed)

This is a mass spring simulation, it uses a bitmap to figure out what the objects will look like, the images which are used can be edited to look like anything. The images just check for the color, if the color is white on a particular pixel on a bitmap, the constraint will not be broken. So if you want to make your own bitmap make it like an alpha map, but the background dosen't have to be black.

After the stuff has been cut out (like a cookie cutter), there are alot of extra constraints and particles, so you have to remove the extra ones. I made it so you can have a mesh of triangles or squares, the squares were very easy to make (I auctually based it on some cod I used before), the triangles however were a bit tricky to make.

For rendering I used lines and polygons. I used the lines so if the object was not moving you can still see it. The polygons I used for motion blur, I used a quad (two triangles), I also have a texture drawing to the background darkening it, so you can have long trails on the objects.

Controls - For the controls press 1 to generate a square mesh, press 2 to generate a triangle mesh. LMB - Select Point RMB - Repulse from cursor

C# 2.0, DirectX 9 (Managed)

This is a program that is a huge particle simulation (hence the name). I used sprites to render the points, with streaching and rotation applied. It was a alot times faster when I rendered using only lines, but looked crappier.

The project is not published bacause I couldn't get the PNG of the line (particle), to embed properly. So I just included an executable with source code. The particles use structs, and are rendered with alpha blending. THe type of alpha blending is switched aroung during rendering so I can get the background to clear only partially eack tick. This is a easy way to make "fake" motion blur.

At the start I clear the screen to white, not black (the auctual color of the background), I do this because when I paint over the screen each tick, rounding errors cause the color to stay a bit above black, it's cheap and dirty, but it works.

I'm using a size of 64 x 64 for my textures, a bit big but you can create a fake bloom sort of effect if you put a glow on everything. The textures are square and divisible by 2, this causes less compatibility problems, and works well. This was not a hard program to make. The mouse has a spring to the particles, click to activate.

C# 2.0, DirectX 9 (Managed)

A program that simulates shadows from an omni light (not too hard to change light type), falling onto spheres. To find edge points of a shadow on a sphere was a bit hard, i did a magically divided by Pi and it worked, so i'm not complaining... =)

(Radius / ((Position - light.Position).Length() + Radius / SMath.PI2 )) * (SMath.PI / 2);

This calcuates the angle from the center the point is, anyways. The rendering using multiple samples to create soft shadows, putting them at an angle to make them disperse. This uses no pixel shaders, it does not even manipulate the frame buffer. The falloff of the light was modeled using a circle, surrounded by a ring (farther = darker).

The rendering uses a lot of alpha blending. The circles do not use multisampling, but instead are surronded by an antialised line (Edit: Only Nvidia?, does not work on my ATI card). Hardware supported, usually. If not turn on antialising manually (Catalyst Control, Nvidia Manager). To color the light the back color has to be changed, this is because you draw shadows, not light. This is a bit anti intuitive, but again, no shader used.

The spheres are not shadowed, but it is hard to notice because the falloff affects everything, including the spheres. I might try to implment some other shapes later... This all combined creates a fairly convincing effect, abiet, a bit cartoony though.

Source Code

C# 2.0, DirectX 9 (Managed)

This is actually two programs, but they are both similar. The first program has many different types of simulations in it. First of all it has a few types of springs, they ar Sqrt which is a basic spring qith good damping, but a bit slow to cacuate. There is Exp which gets larger Expentionaly, which is faster but dosent damp as well, but is better used in ropes where points need to be closer to gether and energy needs to be transmitted.

The springs here have a damping cap (both programs), so they do not explode. In #2, there is rope, deformable sphere, box, cloth, and fluid simulation. For ecporting the programs I published them so they could run on more computer, this however makes the filer slightly lerger for the needs to package the dlls with the file.

If you want the source code click on the link below. On with #3, the springs have a max diff, if the exceed a certain amount they get turned off, this is like the physics engine called Physical (very nice engine btw). It however does not have repulsion, but I would have to have linked lists to have the speed needed. A way to speed up your program is to use structs, just don't pass aroung too much (has to copy each time), the are hundreds of times faster than classes in some cases though. Try to keep the struct under 16 bytes if you can, a bit over dosen't do too much though (int = 4 bytes). Spring Sim #3 has motion blur implmented (multiple renderings, optimized). Added: Trail affect. Dosen't clear, just darkens.

Source Code

C# 2.0, DirectX 9 (Managed)

This is a huge cloth sort of simulation. I copied the one used in geometry wars (360), very cool geame by the way. The thing is auctually a giant grid, with springs connectiong everything together, press space to set off a bomb. The reason I could get such a huge grid is because I used structs, in one of my other programs (Physics Engine, directly under), I tried to recreate this effect, It however was too slow to get much of a grid, this though, has 13056 particles and 38938 springs.

It can run on a slow computer though, because the rendering is done using lines lists, a huge list is passed to the video card each update instead of in seperate chunks to speed up the process. For the springs (used to simulate), I used basic iuler intergration bacause with it it did not explode and it is the only on I currently know how to do (I'm trying to figure out RK4), on my other program (Physics Engine), I juust used multiple evaulations per timestep. This program looks really cool. Another thing is I used was antialised lines (just set in renderstate, during initilization of the device).

DOWNLOAD version WITHOUT DLL's, smaller, but may not work. SOURCE CODE

C#. This is a physics engine. When I started this, it was pure GDI. Now it is Managed DirectX. The particles are sprites (with rotation). The particles have collision detection against the lines.

I also implmented springs, with 4 timesteps per update. The springs can snap, which simulates breakage and deformation. They also simulate rigid body. The rendering also uses tringles and lines (for the lines). If you have a nice graphics card you have to manually turn up the graphics.

The collision detection is auctally line to line, but with a few tricks i turned it to circles, which were automatically swept cause I was using lines. I made the Renderer and Physics class detachable and easily used in another program, Mostly the renderer, it would be very easy to use. The way the springs and particles affect each other to simulate physics, is called a mass spring system. This uses C# 2.0, so you might have to download it.

C# 2.0 Download

A particle engine. It uses Managed DirectX sprites. It draws a whole bunch of the same image to the screen, using alphablending blends them into the final image. You can change the picture to make some cool affects. This took a bit more than an hour to make. The particles spawn at the mouse cursor, I have not put in a lost device method, but it is fullscreen so it should work. Press Esc to exit. You should use 32 bits of color for this, it dosen't look great at 16 bit, the blending screws up. It can simulate an HDR sort of affect, but it dosen't use any at all. You can tweak the program, change the colors, life, ect... The source code is included in the download. The falloff is constant, but it wouldn't be too hard to change.

This game is a top-down shooter. It took about 3 months to make. It the first type of this game we made, making it slightly messy. It has three maps included with it. If you want to download the game with the source code click here on zip,or rar. if you want to download the game without the source code click on the link below (or here for the rar). My brother Free helped me make this game. The collision detection not great, but playable. The physics are limited. It draws all of the game in GDI graphics on a Panel, in the center of the screen. The code eventually got messy because of lack of planning. The entire program is drawn through circles, lines, and rectangles. It has a few bugs, but for the most part it runs.