Flipcode: every IOTD in a single page! back
(L) [1999/08/12] [DanRoyer] [aggravated@bigfoot.com]
This is the latest screenshot of Network Client, the demo game that will
accompany my article on network programming. The white text is part of a
console that logs messages and gives a hint of what's going on in the
application. The blue and yellow lines are a lag-o-meter pladgiarized (sp)
from Quake III.
(It looks a lot cooler when all the missiles are moving at different speeds
and there are a few more enemies, I'll see about possibly taking another pic
when I smooth things over)
Believe it or not, those nasty yellow lines are actually an improvement over
some of my original code.
(L) [1999/08/13] [TimSmith] [tim.smith@omnidssi.com]
Image from the skydome/landscape stuff I am working on.
If you look close, you can see the stars as they fade into the day. Clouds
are rushing by overhead.
(L) [1999/08/14] [RichardTurnbull] [Blitz@3dfiles.com]
This is a scene from the Blitz Engine running on a Voodoo 2 accelerator with Multitexturing
enabled. It display some of the main features, these include the coloured spherical volume
fog. There are two fog objects visible which blend nicely in the middle as seen in real
life. There is also a curved pipe visible at the top of the picture demonstrating the bezier
curved surfaces. In the center of the scene is a rocket which is bellowing out particle smoke
from behind it and lighting up the surrounding surfaces, including the pipe.
[LINK http://acidreign.3dfiles.com/ Acid Reign - Home of the Blitz Engine]
(L) [1999/08/16] [MikeHommel] [jamul@hamumu.com]
Look at that, it's not 3D, but it's eye candy anyway! Is that still
legal!? It's my first foray into 16-bit color, and it's turning out better
than I imagined. This is SpaceBoy firing his Missile Barrage (which causes
some sort of freakish space warp that results in all those trails and crap).
The red blur in the middle is his ship, and the big exploding grey blur in
the upper left is a hapless enemy. Another smaller, more hapless enemy is
presently exploding right above SpaceBoy, and if you really look carefully,
you can just spot another equally hapless enemy who's not yet aware of the
fate that awaits, directly in front of SpaceBoy, kind of nestled in the arc
formed by his red trails - and there's two missiles about 3 pixels from
hitting him! There's actually a much cooler version of this picture, with
the missiles spread all over the screen, on my website, but I didn't put it
here because it's more compressed. Of course, you really HAVE to see it in
motion to have any kind of appreciation for it. Lucky for you, a little
(very early) demo of SpaceBoy is coming out this week. Check it out at
[LINK http://www.hamumu.com] , where things
may be dumb, but boy are they shiny!
(and there are more screenshots to enjoy!)
(L) [1999/08/17] [Yermack] [mi81@bay.da.ru]
These are the pics from my future 3D naval turn-based multiplayer
strategy game.
These shots contain the following techniques:
- Multitextured moving (not seen in the pic sorry :) sea
Moving sky
Projected shadow
Billboarded sun
Dynamic particle systems
Alpha blending
These are the most impressive capabilities of my 3D-Engine I use in
the game.
(L) [1999/08/18] [MikeHommel] [jamul@hamumu.com]
Not that I have ANY interest in self-promotion, but in an entirely
altruistic turn, I've decided I can't let Flipcode go a day without an image
of the day. So behold, SpaceBoy unleashes the Ultimate Cannon (so named
because the weaker version of it is already called the Hyper Cannon). And
let it be known that as of now, you can go grab the tiny little demo of this
game just by dropping by
[LINK http://www.hamumu.com]
(it's only 1.3 megs, how can
you resist?). It's pretty untested on 15-bit video cards, so if you have
one, tell me if it works or not.
(L) [1999/08/20] [ChrisEgerter] [powerrender@home.com]
Ever wondered what Quake2 would look like with bump
mapping? This is an image of a Quake2 level viewer that I ported to
Power Render 3 and added bump. It uses the base textures as bump which
isn't correct, but still gives a neat effect.
(L) [1999/08/23] [KurtMiller] [psykic@flipcode.com]
Well... since most of you are being wimps and not sending in any images of
the day, here's a shot that shows 4 stages of flipCode's history. In the top
left we have the pre-public planning version. The top right shows the very
first news post (January 01, 1999 - at 12 midnight). The bottom left shows a
slightly more mature version, and the bottom right shows the latest redesign
before the current redesign. Wow, huh? Yeah, that's what I thought too. Boring.
So send in your images!
(L) [1999/08/30] [ChrisEgerter] [powerrender@home.com]
This is an image taken from a new example program written in Power
Render 3.
The bumped mapped reflections are only available on a Matrox G400,
however you can
run the demo on any good 3D card. PR 3 is going through final testing
and should be
ready soon.
The demo can be downloaded from [LINK http://www.egerter.com/q2/prland.zip www.egerter.com/q2/prland.zip]
(L) [1999/09/02] [JaapSuter] [J.Suter@student.utwente.nl]
This is a screenshot of the very first Turbo Pascal flat shaded 3D engine LevelEditor I wrote together with a friend called Peter Sloetjes (He quit 3D programming and that is too bad, cause if he would still be in then we could have seen some very very cool engines.)
MMM, those were the days. Discovering new algos every day and thinking you thought them up yourself :) Then after three months reading a doc on the internet discovering some weird computer graphics professor already invented it.
Thank goodness we've got operator overloads and OOP these days.
(L) [1999/09/03] [AaronHilton] [Otri@home.com]
This is a picture of my (Aaron Hilton's) first OpenGL program called
Yoink.
First I built a tube generated around a spline path (defined in the
TunnelData.txt file). Then I took the geometry and scaled it with
Sin/Cos. Finally I rotated the entire scene around the X and Y axis. The
tube is drawn with random colours and transparency, which is simply left
in the buffer to show a trail. Then there's a very transparent black
plane (not back plane) that slips in and out of the near and far
clipping planes, which cleans up the buffer whenever it becomes visible.
There ya have it.. download off my web page, tweak the TunnelData.txt's
parameters and have fun! :)
[LINK http://otri.dhs.org/]
(L) [1999/09/08] [JamesBryant] [jaybebe@iastate.edu]
this is a screen shot of a software renderer i am making from scratch, it
is an example of the polygon rasterizer scan line interleaving (SLI)
capabilities. this is very cool, easy to do, and can yield 2x or 3x
performance with little visual quality loss. my current texture mapper is
all coded in C and i used no papers, docs, web sites or anything, just
started with algebraic equations and went from there, it actually isn't
that hard once you get into it, the hard part is going to be getting exact
accuracy, what i mean is now when you zoom into two polys that are
adjacently mapped, the texture is off and doesn't line up correctly all the
time at the crease, maybe due to round off errors, but i am almost sure it
is some design error by me, if any body has some general tips for this
problem please tell me about them.
i will be very interested in seeing how SLI will work in an actual game,
but that will be a couple more months before i have good content and engine
to test with. also, i might release the source code in the future, but not
until i get everything completed with the rasterizer.
some specifics about my t mapper so far:
- outer loop is all floating point
inner loop is all integer ops, currently 6 adds, 2 shifts, 2 ands, 2
assignments
currently affine mapped, but at huge angles there seems to be NO
distortion, don't know why? but i like it!
y clipping per polygon, and x clipping per scan line
hacked bilinear filtering (this is more ops then in above)
texture can be any size power of 2, width and height can be different
texture is tileable
arbitrary SLI
email me with any questions, comments, or advise!
james bryant
[LINK mailto:jaybebe@iastate.edu jaybebe@iastate.edu]
(L) [1999/09/10] [LukeHodorowicz] [hodorl@rpi.edu]
This is a shot of a skybox I've been working on. I call it the Mandel Nebula. I
generated an section of the mandelbrot fractal, messed with the colors, skewed it
to be a bit more spherical, mapped it to the box, added some stars, added the sun,
and then some blue tendrils into the areas of space where there were only stars.
Overall about 5 hours of work(which included some failed attempts). The software
I used to do this was fractint 19.6 for the fractal and Paint Shop Pro 5.0 and
SkyPaint for the image editing. The image is warped in this shot a little due to
a higher than normal FOV so you can see a bigger piece of the sky. Enjoy!
Guess coders can do art. =)
(L) [1999/09/13] [WarrenMarshall] [wmarshall@legendent.com]
I decided to try and get rid of the stair steps in my lighting the other
day. So I added a final step to my lightmap creation code to just run a
quick blur function over the lightmap before saving it.
Just taking the current pixel + the one above + the one below + the one to
the left + the one to the right, and divide by 5. It created a nice blur
and got rid of most of the stair step. Looks much nicer. :)
(L) [1999/09/18] [TobinSchwaiger] [tobins@mindspring.com]
This is a screen shot from Advanced-Productions ([LINK http://www.advanced-productions.com www.advanced-productions.com]) upcoming Real-Time
3D RPG/Action game titled The Discovery: Gene Wars. Here we can see the main character taking
a nap as the development team creates new worlds for him to explore! (:
(L) [1999/09/22] [JohnvanderBurg] [john@mysticgd.com]
This is an an image of the landscape system I just started working on for my 3D engine called Oxygen3D.
It can display really large highpolygon terrains at still high framerates.
You can see two numbers on the screenshot. TP and TC.
The TP stands for Terrain Polycount. In this frame there are 22098 being rendered and the total polycount is 131072 or so.
This runs at 60 fps on a P2-233 with Voodoo 2.
I'm using some sort of homegrown quad/octree method for as visibility system and a lot of precalc.
The landscape is one big generated mesh, and not just a grid where the vertex heights change.
I soon will put up some movie / demo of it on my page so you can see it moving.
Please note that I only coded 10 hours on it till now so the cool things still have to come :)
(L) [1999/09/24] [AlexChampandard] [ajc116@demeter.cs.york.ac.uk]
This screenshot was taken from the latest demo of my OpenVL engine. OpenVL
is a realtime 4 DOF voxel lanscape engine. As you may expect, the LOD
settings for this shot were quite high, and all the redering options were
turned on. The demo still ran at about 4.5 FPS on a PII, keeping in mind
that this is 32 bit software rendering. Notice the dithering in the
foreground to speed things up, since I only need to load 2 texels for
texture mixing, as opposed to 8 with bilinear filtering.
Find out more at the new
[LINK http://atlas.cs.york.ac.uk/~ajc116/OpenVL/Index.shtml OpenVL website].
(L) [1999/09/29] [TobiasJohansson] [tobias_johansson@mailcity.com]
These are screenshots from my very first radiosity processor that I've just
finished. It's very basic, using triangular patches and progressive refinement.
I doesn't use hemicubes, just plain mathematical form factor calculation.
Shadows are implemented using a simple Line-of-sight algorithm.
(L) [1999/10/11] [WillemH.deBoer] [whdeboer@iname.com]
This is a very early screenshot of the Landscape module of E-mersion
([LINK http://www.connectii.net/emersion www.connectii.net/emersion]). According to the latest measurements the landscape
system can process 32,000 triangles *per* frame at 55 fps on my PII434 with
a Riva TNT. I'm currently working on some optimizations to make it go
twice as fast as it is now. Stay tuned ;)
Willem H. de Boer
(L) [1999/10/15] [TimurDavidenko] [timur@compugraphic.com]
Thats the screen shoot from engine i work on.
(L) [1999/10/18] [DavidPaull] [david@tanzanite.to]
This is a screenshot from the TechNature Library for DirectX. This is a
shot of a spherical planetoid about 2 miles in diameter. The planetoid
terrain geometry, textures, trees, and grass are randomly "grown" using
fractal mathematics, and as a result, they are different every time. All
reflections are based on the spherical water surface using real time,
vertex based, ray tracing. This demo runs at 60fps on my PII-450 with a
VooDoo2. More information, and screenshots can be found at
[LINK http://www.tanzanite.to http://www.tanzanite.to/] Please send any questions, or comments to
[LINK mailto:david@tanzanite.to david@tanzanite.to]
Thank You, David Paull
(L) [1999/10/21] [PhillipSchuster] [Phillip.Schuster@munich.netsurf.de]
I am currently working on my own 3D Engine that runs under Direct3D. At the
moment I am working on my Lighting Engine. The screenshots shows one of my nice
effects I have built into it. If a face is set to no shadow casting and a ray runs
through during processing the lightmaps, my routine gets the pixel of the texture at
that intersection point and the light ray then get's the color of that texel. That
works very fine as you can see in the image above. I am just modeling a Scene with
a lot of these windows (a church or something like that). In order to get the
lightmaps impressive with these FX, they have to be quite big. The ground lightmap
is 128x128 pixels and the lightmap is blurred after it is created.
(L) [1999/10/25] [WillemH.deBoer] [whdeboer@iname.com]
Here is a screenshot of a couple of landscape system screenshots loaded in
Paint Shop Pro 5. The 3 top screenshots (and the the one at the bottom) are
all shots taken from the system with texture-generator. The terrain-texture
is pre-calculated using parameters which specify the type of terrain and then
mapped onto the heightmap. So textures are never repeated (tiled) in the
landscape but all parts of the terrain-texture are unique.
(L) [1999/10/28] [MattOlson] [mjolson@gpu.srv.ualberta.ca]
Here's a screenshot from Dogfight, an open-source arcade space shooter I'm
writing. The explosions are the most intensive (and impressive, to my
mind) graphics in the game, and were a hell of a lot of fun to code.
Gotta love particle systems. Dogfight's maddeningly addictive, too.
URL:
[LINK http://www.infernus.net/]
[LINK http://www.infernus.net/dogfight.html]
[LINK http://www.infernus.net/Images/scrshot0.png]
(L) [1999/11/02] [CedricCaillaud] [jeckl_@club-internet.fr]
(soory for my english, but i'm french)
This is a screenshot from the tool i'm coding for my game.
It's at an early stage of developpement. The features are :
- UV mapping with high control on UV vertex.
world editing (future)
Animation creation (for real time cinematics scenes)
High efficient interface
The interface is made for quick and efficient editing. This is (i think) a
very important point
for a good game developpement.
Note: the building shown in the window is a cathedral that i done in NENDO
(a very powerful modeling tool).
(L) [1999/11/12] [WillemH.deBoer] [whdeboer@iname.com]
This is an example of what the Blinn shading module of E-mersion is
capable of. For more information, visit the homepage.
-----
Willem H. de Boer
E-mersion Project
[LINK http://www.connectii.net/emersion www.connectii.net/emersion]
(L) [1999/11/18] [Kanda] [kanda@wanadoo.fr]
Hello... This screen is taken from my 3d engine i am working on since a few weeks. Its runs with
directx 6. Some minor things are implemented: multiple Rgb lighting, ambiant lighting, terrain generation, fog, translucy ect. ect. but more to come. some great thanks to Cédric Caillaud (Ssassh Engine) for his great help !)
Kanda / Universe
(L) [1999/11/19] [IanAshdown] [ian_ashdown@helios32.com]
This image of a Japanese tatami (dining) room was generated by the Helios32 Radiosity Renderer. It consists
of 3,448 polygons and took 46 seconds to perform the radiosity calculations on a 450 MHz Pentium II desktop
machine. The output is an OpenGL display list or VRML 97 file for realtime viewing.
Helios32 was designed for architectural visualizations, but it is equally adept at producing physically
realistic lightmaps for games development. There is no artistic license involved -- what you see is what
you would get in a real environment with physically correct light sources and diffuse surface reflectances.
Please visit [LINK http://www.helios32.com www.helios32.com] for more images and product specifcations.
Ian Ashdown, P. Eng., LC
Vice President
byHeart Consultants Limited
[LINK http://www.helios32.com]
(L) [1999/11/22] [AlexHerz] [SoftCore@t-online.de]
these are 3 shots of sovereign (editor's note: 1 of 3), a glide based fps..
it featues all the standart shit quake2 has and additionally
volume fog, translucent chrome, Lod Textures and some other shit
the indoor renderer is portal based and shows some quake level
(sound illogical as quake is bsp based...but it's that way..I needed
some level to test the shit)
the outdoor renderer is based on some voxel algo and renders
a greyscaled heightfield...
the gfx were not made by my...so (c) to the respective owners
the game won't be continued as glide is dead... :(
thx 3dfx!! :(
(L) [1999/11/29] [WillemH.deBoer] [whdeboer@iname.com]
Thought I'd post a screenshot of a demo I'm making for Davilex.
This demo shows the true power of E-mersion, which is the ability
to quickly and easily throw together some modules to make an
engine. Here you can see the Skybox system, landscape system
and lensflare system in action simultaneously.
-----
Willem H. de Boer
E-mersion Project
[LINK http://www.connectii.net/emersion www.connectii.net/emersion]
(L) [1999/12/09] [TobiasJohansson] [dtz222w@tninet.se]
this is some screenshots from my new engine, BeamEngine, well I couldn't think
of a better name. I've been coding on it for a couple of months now, and it's
really starting to look like something nice.
Right now it has the nice features:
- Hardware rendering through Direct3D
Octree subdividing
Mipmapping, created by engine to save diskspace
Lightmapping with raytraced lighting
Gouraud shaded/Environmentmapped objects
Collision detection (crappy)
Loading of ASC, BMM and MAP files.
Coronas
Particles
Simple scripting (maybe to simple to be called scripts)
The screenshots shows the different lightmaps can do to a scene, it gives
it a much better 3d feeling. Anyway, you can download an older version of
my engine at [LINK http://come.to/coding_zone], in the beta zone.
(L) [1999/12/14] [MarcSalmurri] [marc.salmurri@upcnet.upc.es]
Now Hurricane supports static lightmaps too. This simple scene was staticly rgb-lightmapped in about 4 seconds. No raytracing, no radiosity...guess what?
Marc Salmurri
(L) [1999/12/23] [VladimirKajalin] [Vladimir.Kajalin@mail.ee]
This is shots from my opengl game project.
The game type is a arcade fly simulator with multiplayer support.
You can download the game at this page:
[LINK http://www.freehomepages.com/vkajalin/]
I will glad to recive any comments
(L) [2000/01/05] [TomNuydens] [delphi3d@gamedeveloper.org]
The lightmaps in this screenshot were created using RPI (Radiosity
Preprocessor Interface). The RPI is basically an API that does nothing more
than create lightmaps. You can feed it some polygons, tell it where the
light sources are, and set some other parameters. Then you tell it to
calculate the lightmaps. When this is done, you receive a bunch of pointers
to raw image data, which you can then save in any format you want. Because
we're talking about an API, you can reuse the same lighting code for
multiple projects.
I wrote the whole thing using Delphi, but since it's a DLL, anyone should
be able to use it. Note that the project is still in its early stages - the
current version doesn't actually use radiosity yet, but you can use it for
simple point lights and spotlights. You can get RPI, with complete source
and documentation, from my site at [LINK http://www.gamedeveloper.org/delphi3d/projects.shtml].
Tom Nuydens
(L) [2000/01/09] [EsaSalminen] [python@dlc.fi]
Here is picture to our coming race game Toy Car. Graphically game not offer nothing new, but we are
satisfied to rigidbody physics that we use in game. Game is designed to one or two players, one
player can drive against to ghost driver and two players to each other, you can download demo to our
homepage [LINK http://www.saunalahti.fi/~python www.saunalahti.fi/~python], it shoud be available in any day now.
(L) [2000/01/14] [MarcosHernandez] [marcosh@jazzfree.com]
Free lightmap generator for PowerRender library, it can load exported files from 3dsmax and render all the omni,directional & spotlights of
the scene casting shadows & translucency effects.homepage: [LINK http://come.to/optimiza come.to/optimiza]
(L) [2000/01/18] [UthmanApatira] [almaroof@email.msn.com]
This is just a test of splines and curves in my 3d engine as well as colored
procedural lightmap generation
(L) [2000/01/21] [Dierk"Chaos"Ohlerich] [d_ohlerich@vcc.de]
Here you see 191 bugs crawling over a simple landscape, taken from the Kasparov demo. A swarm engine calculates the position vectors, then the walking engine moves the legs towards the target. The body position is calculated from the leg positions. The good thing about bugs is that they have 6 legs: they will never loose thier balance when lifting half thier legs...
Dierk "Chaos" Ohlerich
(L) [2000/01/23] [ChrisEgerter] [powerrender@home.com]
Here are a couple of new shots from Power Render's realtime landscape
engine. I've been adding dynamic shadows and huge terrain textures.
(L) [2000/01/26] [ClaudiuMarinescu] [cobra@odobleja.dj.edu.ro]
Here's a picture from one of my Christmas projects, QLeVe. It's just a
simple Quake 2 level viewer with support for BSP trees, PVS, lightmaps, and
the rest, written entirely in DELPHI. In the picture you can see the BIG
difference between a level with lightmaps and a level without lightmaps
(just textures), and the SMALL difference between lightmaps and Gouraud shading.
The difference in speed is big enough: the gouraud shading is two
times faster than the lightmaps. I think that lightmaps are soon to be
history, especially with the new GeForce cards coming up.
If you want to see the program, it will be available at:
[LINK http://cstudios.iwarp.com]
Right now, that url isn't accessible, so if you want to see it anyway (or if
you want the source code) mail me to: [LINK mailto:cobra@odobleja.dj.edu.ro cobra@odobleja.dj.edu.ro]
Anyway, I wrote this program only to show that Delphi is a pretty good
programming language, and it IS suitable for 3D Graphics.
Claudiu Marinescu a.k.a. "Cobra"
(L) [2000/01/31] [JohnvanderBurg] [john@mysticgd.com]
I've added curved surfaces support to Oxygen3D, and am working on Quake 3 level support.
The curves can be lightmapped, textured, multitextured and can have vertex colors for each
control point which will be interpolated along the curve, and contains dynamic level of detail including
a caching system.
John van der Burg
Mystic Game Development
(L) [2000/02/04] [TomNuydens] [delphi3d@gamedeveloper.org]
The attached screenshot is from a program I wrote for Borland's January
game programming contest, titled 'Set the World on Fire'. The goal of this
contest was to write a component that renders fire. I wrote mine in Delphi,
and I used a particle-based approach. No bitmaps were harmed, or even used,
in the making of this effect. The flame can be viewed from any angle, and
looks very volumetric.
The component, along with the sample program this shot came from, can be
downloaded from my site at [LINK http://www.gamedeveloper.org/delphi3d www.gamedeveloper.org/delphi3d].
(L) [2000/02/07] [Kanda] [kanda@wanadoo.fr]
After a lazyness period, real Skydome(with vertexlightning for amazing sunset) and a new terran system were added.
E-Motion modeler is now usable.
(L) [2000/02/11] [DarrinHurd] [darrin.hurd@trimble.co.nz]
These are screen shots from a flight sim I am working on.
We want really high detail low down flying, without sacrificing Visible distance, so came up with this technique, which draws a textured ground plane, and then alpha fogs the close in terrain into this.
This is created using the Power Render Landscape Engine (www.egerter.com), with a few extra goodies I have added.
The Ground plane does not have to be flat, and can actually be a simplified mesh of your entire terrain area. Flat is more suitable for my uses tho.
Cheers
Darrin Hurd
(L) [2000/02/14] [MarcMcCall] [eniac@ixpres.com]
here are a cupl pics showing planets rendered using a pseudo-procedural
texture mapping technique. I use OpenGL and my own 3dsmax file importer.
Marc
(L) [2000/02/16] [s.kallweit@gmx.net] [s.kallweit@gmx.net]
This are screenshots of my new Engine called freeD using OpenGL. We are a
small team of students, consisting of one programmer and some graphic artists
coming from switzerland. We want to build a real-time LAN (maybe Internet)
game. At the moment we are not sure weather we want to build an RTS or a
deathmatch racing game (with all the Unreal Tournament Modes like Domination
and all) playing on a huge landscape.
(L) [2000/02/19] [Dr.DieterJung] [KaneJung@topmail.de]
Here is one pic of my engine Damnation using OpenGL. It uses fog Lights and so on. Please
give me some feedback.([LINK mailto:KaneJung@topmail.de KaneJung@topmail.de])
(L) [2000/02/23] [CharlesNicholson] [chnicholson@vassar.edu]
This is a sample screenshot of a landscape demo I'm working on. The
heightmap is generated algorithmically using 2-dimensional Perlin Noise, and
rendering is done with OpenGL. No LOD is implemented yet, it's still under
construction =], but it's an independent study I'm doing for University (3rd
year student at Vassar). Anyone who wants to talk algorithmic landscape
generation/visibility, drop me an email at [LINK mailto:chnicholson@vassar.edu chnicholson@vassar.edu]. I'd love
to chat.
(L) [2000/02/24] [JohnMancine] [mancinej@river.it.gvsu.edu]
Here is a shot from my 3D landscape engine, Polemic. I am using binary triangle trees to get
realtime level of detail adapting meshes, and I recently added particle FX and some
other cool eye candy. For more info please check out [LINK http://www2.gvsu.edu/~mancinej/index.html]
-- John Mancine([LINK mailto:mancinej@river.it.gvsu.edu mancinej@river.it.gvsu.edu])
(L) [2000/02/28] [DraxsonTeam] [rjsantos@draxson.com]
Here are some screenshots for the game we are developing now.
Draxson Team
(L) [2000/02/29] [DanielWesslén] [wesslen@post.netlink.se]
Here are some screenshots from ODEN, a game engine I am working on.
ODEN currently features:
- OpenGL rendering.
Huge landscapes (about 16 square km), rendered with dynamic LOD (not
ROAM).
Static lightmapping of landscapes.
Supports .ASE models.
A simple window manager.
Extremely bad physics simulation.
ODEN currently runs in BeOS only. For the moment I intend to keep it
that way since programming for Windows is an pain in the - you know -
and programming for BeOS is pure bliss.
The game itself is in a very early development stage and is currently
unnamed. The plan is that it will evolve into an action-strategy game,
similar to Battlezone but with the emphasis on surveilance and
futuristic weapons rather than resource management and machine-guns.
All feedback is welcome.
/Daniel Wesslén ([LINK mailto:wesslen@post.netlink.se wesslen@post.netlink.se])
(L) [2000/03/01] [MarkAllen] [mark@tashco.com]
This is a terrain screen shot from of title in development called Storm. It
is a real time strategy game based in a 3D environment.
The terrain uses unique textuing and per texel shading. The terrain is
generated from a user modifiable script so different types of terrain can be
generated. This was done with the Highlands script. Our next development
will be the addition of vegetation.
We have more screen shots and information at our web site: [LINK http://www.tashco.com www.tashco.com]
Mark Allen
Lead Programmer/Owner
Tashco Studios
[LINK http://www.tashco.com]
(L) [2000/03/03] [ClaudiuMarinescu] [cobra@odobleja.dj.edu.ro]
This is a picture taken from QLeVe3, my Quake 3 level viewer.
For now, this is work in progress, and it has quite a few bugs, such as
"not too curvy beziers" or the "some.textures.are.missing.due.to.not.
reading.shader.scripts" syndrome. Sky isn't that great either...
When I'll finish it, QLeVe3 will be available at [LINK http://qlv.iwarp.com].
(L) [2000/03/06] [ChrisEgerter] [powerrender@home.com]
Here are some screenshots of my current landscape engine which is part
of Power Render 3.
The engine now features:
- Direct3D rendering (DX7)
per pixel rippling water reflections using hardware bump mapping
raytraced terrain shadows and fractal heightfield expansion
dynamic and static soft shadows
color keyed shadows for things like billboarded trees
single giant terrain texture which is procedurally generated
fully deformable terrain
You can download the running demo from [LINK http://www.egerter.com].
Please report any problems to [LINK mailto:powerrender@home.com powerrender@home.com].
(L) [2000/03/09] [ParasharKrishnamachari] [krshnmch@uiuc.edu]
These shots are from an engine I worked on with 7 other guys for
SigGraph. The goal was a 3d engine that could render any model as if it
were hand-painted. The algorithm is based on the papers by Barbara J.
Meyer(correct spelling?) of Disney. It tesselates the loose geometry
into a VERY tight set of points and the points are drawn as brushstrokes
of any angle and length.
Currently, we're using Glide to get the full speed out of the
demonstration hardware. With this engine and the visualization and
debugging tools we wrote (those 2 were OpenGL) and
file-format-conversion (we used our own format), we won 2nd place in the
category of Undergrad research. Other colleges' SigGraph groups tried
similar things -- they generally got better quality, but we were the
only ones to get it to work in REALTIME.
Each brushstroke you see there is a separate Alpha-blended polygon.
So the original model (which was based on a Van Gogh painting), had less
than 200 polygons, but in the final rendering stages, we usually draw
around 50,000 per frame.
I personally was a latecomer on the project (they were working on it
before I transferred into this school). So I managed little more than
lighting and a fair amount of debugging. We're going further, though...
Realtime Radiosity is around the corner... believe it.
More info at [LINK http://www.siggraph-uiuc.org/painterly/]
- Parashar K.
(L) [2000/03/12] [FrankLinder] [baron_3d@hotmail.com]
Hello, my name is Frank and this is some screenshots from my 3D-engine.
My landscape is 16x16 km, that is 100 sqare miles! of mountin, valleys,
seas, forrests and ravines. It is possible to walk or fly (or drive).
The main idea behind the landscape-engine is: It shold follow a rough
map and "in fly" create the details with different sorts of random
fuctions and place different sort of objects like trees and stones. It
is a special algo to create ravines.
More fuctions is planed. (ex algo to create caves, craters, roads,
ditches and so on)
It is possibe to do some 3D-editing, raise or lower land, adjust pitch,
change interpolation alorithm (4 algos), for each sector-midpoint.
More 3D-editing is planed. (ex place objects, change texture and so on)
I have not implemented an itelligent texture controller yet and
collision-detection and ... and.... .
There is also some ideas of an algo like older days simcity.
(with traffic and moving/travalling pepole)
Working currently with triangulation and the texture controller.
I´ve Also written a mapeditor (Delphi + delphix) (not ready yet).
And of course, I use Borand C++ Builder(4) and DirectX6 for the 3D-engine.
It givs 25 to 50 frames pes second. (AMD k6-2 333 and D3-Blaster Banshee)
It is inspiring to see all good 3D-engins here.
I must thank you on the flipcode for this great site.
[LINK mailto:baron_3d@hotmail.com Frank Linder]
Sweden
(L) [2000/03/13] [MarkAllen] [mallen@saitek.com]
At the beginning of March you saw an IOTD for our game Storm showing off its
landscape. Here is an updated image which contains vegetation as well. The
whole landscape (including vegetation) is randomly created at game start
time. This means that all games will play differently.
Obviously the game elements like military units and buildings are still
missing, as is the user interface, but they will all follow soon.
For more information go to the Tashco Studios web site ([LINK http://www.tashco.com])
(L) [2000/03/15] [OscarRydberg] [rydberg_l@hotmail.com]
It's a couple of screenshots taken from my new engine that supports planet
generation. Currently it has only one stonetexture for testing purposes...
The engine supports evolution, so the planet can evolve in realtime,
earthquakes are easily simulated, as well as floodings. Caves are also
supported.
Extreme LOD, which allows for flights from outer space down to a closeup
where trees&bushes will be visible.
As seen in the screenshot, cities are also supported, but in it's early
stages. The city seen here right now covers 1/6 of the entire planet! Since
the engine is evolutional, cities can grow with time.
Planned features:
Better cities & beaches, lightning (sun->day&night), atmosphere which will
give nice sunsets and clouds.
About me:
21 year old systems programmer and internet business consultant doing hobby
game programming! :) I've previously been involved in the amiga&pc demo as
well.
Feel free to send any feedback to: [LINK mailto:orydberg@ryctelecom.com orydberg@ryctelecom.com]
(L) [2000/03/18] [JeroenV] [ipwwviss@worldonline.nl]
Here is a screenshot of the terrain renderer I am currently working on. It uses voxeling technology.
This 3d engine is my first ever Win32 graphics engine, so it is also kind of an experimental thing.
Some of the features are:
- Lightmapping
MipMapping
Bilinear filtering
Trilinear filtering
MultiTexturing
Skytexture
Depth ceuing
It uses DirectX 7, at this time it only supports software rendering, but I'am working on a Direct 3d version.
I don't have a website at the moment, but you can mail me at [LINK mailto:jvisser@jvisser.tmfweb.nl jvisser@jvisser.tmfweb.nl]
(L) [2000/03/25] [MikaelThilander] [bete@hotmail.com]
Here's a few pictures from the game I'm currently working on.
It's just to show the world that there are still old-school shooters in the
making.
Vertical shooters are my favorite genre and has been since I first saw 1942.
I'm doing this game as a tribute to mr Yoshiki Okamoto of Capcom when he was
the one who opened up my eyes for the wonderful world of extreme button
bashing.
The Shooter Engine, as I like to call it, has the following features:
- Time of day system
Vertex lightning
Island LOD
In the doing:
- Motion blur
Realtime cloud generation/animation
volumeteric fog
Regards
Mikael Thilander, Sweden
[LINK mailto:bete@hotmail.com bete@hotmail.com]
(L) [2000/03/28] [MarkAllen] [mark@tashco.com]
This is our third submission to Flipcode's image of the day. I wanted to show
the current state of [LINK http://www.tashco.com/storm.html Storm] to those that are following its progress. The latest
feature is the addition of water and detail texturing.
Water has been added by defining a 'sea level'. By extending the terrain
texture generation algorithm that we use we have added an under water texture.
Then we render the water on top of that with a second pass. I intend to use the
water to also reflect the terrain.
The detail texturing added to the terrain is also done with another pass.
Essentially its a high resolution texture that modulates the base texture giving
the effect of having more detail.
I'd love to hear any comments that people have. As always, you can get the
latest information from our [LINK http://www.tashco.com Tashco Studios] web site.
(L) [2000/03/31] [Jawa] [jawa@paravolve.com]
GRYPS is currently a 3D engine written in Direct3D. It has plans to be a free 3D online RPG.
LOD is nearly completed, mouse support has been implemented, sound and music coding is nearly finished, arrow key movement, and sky BMP patterning are also done.
Collsion detection will be coming soon along with NPC pathfinding and behavior patterns, and mutliplayer features, plus a GUI for gameplay. Also, a particle system is being developed for casting spells. Some map editing features for the world builder are done already, too.
The engine has gone through many stages of coding since February 1999. Client/server integration is being worked on constantly, and is going smoothly.
Any comments, questions, or suggestions can be directed to the message board or, of course, the staff at:
[LINK http://gryps.paravolve.com/]
(L) [2000/04/05] [MartijnKeijzers] [m.keijzers@arcobel.nl]
These are four test images of a program I am developing for rendering quaternions.
When ready the program should be capable of rendering frames or movies of a 3d
space.
The upper left and the lower two images are basically a mandelbrot set in 3d space,
while the upper right is volume rendered with some random values.
The lower right is rendered at a higher precision using floating points.
Martijn Keijzers.
(L) [2000/04/12] [CharlesNicholson] [chnicholson@vassar.edu]
This is the second stage in the evolution of my terrain engine; an earlier picture can be found at
[LINK http://www.flipcode.com/cgi-bin/iotd.cgi?ShowImage=02-23-2000]. I'm playing around now with some DLOD
stuff, it runs at about 15fps but is still horribly unoptimized (no tri-strips, etc...). I think
something's horribly wrong with the quadtree clipping too, but I'm working on _that_... =]
Take it easy,
-Charles Nicholson
(L) [2000/04/16] [KurtMiller] [kurt@flipcode.com]
This is a screenshot of the new sky system that I added to my 3D engine project,
[LINK http://www.flipcode.com/kurt/grain/ the grain engine]. I posted a
little demo of the sky system on the engine's web site in case you're interested.
The mountain in the screenshot is part of a static backdrop (not an actual part of the
polygon world).
(L) [2000/04/20] [GazinMatthieu] [Matthieu.Gazin@wanadoo.fr]
This is an image from the curent engine I'm working on.
Basic3D is a free engine distribut under an S.D.K. for all.
Here some engine details :
- Lightmapped perspective texture mapping
MIP-mapping
Colored dynamic lights
BSP/ZBuffer rendering
Collision detection
Support for OpenGL
Polygonal objects
Particles and sprites
Movable BSP models
Suport for Quake 2 data
Suport model/animation of MD2 model
Visit my web page at : [LINK http://perso.wanadoo.fr/gazin/matthieu/Intro.htm]
(L) [2000/04/29] [DionPicco] [dpicco@cs.mun.ca]
Here is an image of a engine that a friend of mine and I are designing. This shot shows the landscape engine that I am currently working on. It is a fairly standard engine with features as:
- Polygon based, Quad-tree based visibility culling
All textures generated as needed on the fly with a cache to store textures that are re-used from frame to frame.
A 2 meg texture cache is all that is needed to have a full multi-textured landscape of nearly infinite size
Multi-Texture blending (done in software)
Vertex gouraud shading burnt into the textures at blend time as well to eliminate shade popping when changing LOD levels of quad-tree leafs
Textures generated at various LOD
Simple LOD (reduce quad-tree poly count by power of 2) with a post-pass to elimate edge cracks
I have also tested this with detail maps up close with breaks up the bi-linear filtering nicely (not enabled in these shots). I'm currently working on using Perlin Noise to generate my a more organically chaotic blending for my textures as they currently are only blended from vertex to vertex. I'm also gonna implement a ROAMing sort of CLOD instead of my DCLOD (discrete and crappy LOD). Runs at a very good frame rate as well.
(L) [2000/05/05] [CharlesNicholson] [chnicholson@vassar.edu]
Hello again! This is the third screenshot from my landscape engine, view the
previous one at [LINK http://www.flipcode.com/cgi-bin/iotd.cgi?ShowImage=04-12-2000].
Anyway, it's now textured and lit (better), coming along quite nicely. I'm
currently working on a few things at once, including adaptive quadtrees for DLOD
(The "Right Thing", IMO), compressed lightmaps (for animated shadows as the
earth orbits the sun), a heterogeneous terrain generator (Perlin Noise has been
one of the MOST important advancements in the history of fBm terrain generation-
not only will it do world geometry for you, but also natural placement of
rivers, flora, etc... It's good for water bumps too), and some terrain patch
blending. Once this thing becomes (in my eyes) presentable, I will put up a web
page, a complete "How I did this" (source, comments, whatever) section, pics,
executables, references. To those who asked before, I'm sorry I don't have
anything up just yet... I'm neck deep in finals and recovering from my 21st
birthday. Web page to come soon. =]
Take it easy,
Charles Nicholson
(L) [2000/05/12] [DanielPalomovanEs] [dpalomo@liacs.nl]
this is a screenshot of my speech driven CD-player. It is not a very beautiful CD-player,
but it is something else than a 3D-engine-shot ;-). It's implemented in OpenGL, and is
still in Beta testing phase. Future features will be mp3/wav/mod support, a speech driven
file-browser, and a nicer CD-Deck. If you like to see more about this app. or you like to
download it, see: [LINK http://www.liacs.nl/~dpalomo/voiced3d]
It's current version is beta 1.5, and it supports voicecommands to play/stop/eject/insert/next/previous/train/quit the player.
The speech recognition is made possible by MS Speech API, which has a voicecommands wrapper.
Regards,
Daniel Palomo van Es
(L) [2000/05/18] [VasileiouNikolaos] [nbasili@ceid.upatras.gr]
This a picture of my 3d visualization/game engine called utopia3d.
It is C++ API inspired by Iris Performer and VisKit.
It contains opengl support and runs on linux and windows (and BeOS sortly)
More info at [LINK http://utopia3d.sourceforge.net]
(L) [2000/05/23] [MaxMcGuire] [amcguire@andrew.cmu.edu]
This is a frame from a ray traced metaballs animation I made for the last
project in my computer
graphics [LINK http://www.cs.cmu.edu/afs/cs/academic/class/15462/web/462.html class].
The
ray-metaball intersection is computed using the "regula falsi" iterative
root finding method and
the whole thing is spherically texture mapped with colors blended between
the metaballs.
Unfortunately it doesn't run in real-time :(
The entire animation is online here: [LINK http://www.andrew.cmu.edu/~amcguire/asst4_640x480.AVI
www.andrew.cmu.edu/~amcguire/asst4_640x480.AVI]
(L) [2000/05/25] [VladAndreev] [goltrpoat@hotmail.com]
As the flipcode terrain engine parade continues, here are some shots of my
engine, OGRE.
They are about two months old, the newer versions use proprietary models and
I'm under an NDA so posting those is probably questionable. The things you
don't see in these shots that are functioning in the engine are:
- Dynamic and static object support, building and tree placement
Bezier roads
Voxel model support and triangle mesh to voxel model conversion
(incomplete)
Improved lighting model
and other miscellaneous goodies.
The things you do see are:
- Animated volumetric fog
Global unique texturing
Shadows
Motion blur
Day/night cycle support
Fully dynamic world (texture and geometry data can be altered on
per-polygon basis)
The indoors counterpart of OGRE, IGOR, is being worked on and I will post
shots of it as soon as there's anything worthy to post.
Vlad
[LINK mailto:goltrpoat@hotmail.com goltrpoat@hotmail.com]
(L) [2000/05/30] [DevonZachary] [dzachary@desconnect.com]
This is a screenshot of a little RTS game I'm doing called "Pytae".
Basically, it involves going from station to station and trading stuff,
like salt, fuel, water, medical supplies, etc. for cash (which is in turn
traded for salt fuel water or medical supplies...). The little "P" in a
square shows were the player is. The space stations (different icons are
different size) are all numbered so you can pick which one to space-hop to
in the "Course Selector" . The point of the game is to keep trading around
until you reach the goal amount of cash. As you can see from the lil'
version number in the corner this one's a pretty early build (only 3 days
after the first one). All the graphics were done with paintshop pro and
caligari truespace.
(L) [2000/06/05] [BenjaminSprague] [sprague@core.com]
This is NOT another terrain-engine demo! It's a screenshot from skiing a game that I am
making with a friend. All I have done is the 3D engine with terrain, and some collision detection/physics.
The things shown in this image are:
- Static lightmapping on the terrain
The really cool sky textures created with Terragen ([LINK http://www.planetside.co.uk www.planetside.co.uk])
Things that are there that you can't see are:
- There is only 4500 triangles in this image!
The terrain is a quadtree.
I'm using the Nebula engine. ([LINK http://www.radonlabs.de www.radonlabs.de])
I'm just doing this for fun mostly, I'm a 16 year old sophomore in high school, and this
is my hobby. I'm looking for some kind of 3D program, so I can add people and objects to
the game. (anybody have an old version of TrueSpace or something that they can legally give away? :)
I want something that can export Wavefront OBJ files.
Thanks all.
(L) [2000/06/09] [FabianRoeken] [fabian@vulpine.de]
Originally, we intended to post a nice outdoor terrain screenshot here...
but then, we decided to do something else with our Bezier Patch renderer.
The screenshot shows both Bezier Patches and CSG-generated geometry, with
the patches being dynamically tesselated in run-time. Some of the patches
are visually enhanced with real-time specularity; all the surfaces are
light-mapped using radiosity computations. The tentacles in the background
on the right side of the screen are sets of keyframe-animated Bezier
patches.
The nice thing about Bezier patches is that they can be adaptively
tesselated - thus, the scene shown in the screenshot runs smoothly even on a
Voodoo Banshee :).
Now, I wonder how long it will take until somebody comes up with a
Bezier-based Terrain renderer ;).
For more screenshots, visit the Vulpine home page: [LINK http://www.vulpine.de www.vulpine.de]
(L) [2000/06/12] [GabrielRABHI] [gabriel.rabhi@wanadoo.fr]
This is a screenshot of a small demo of my new GUI : you can download this demo
on my site [LINK http://www.z-oxyde.com/ez-world/ www.z-oxyde.com/ez-world/].
EZ GUI is a portable generic Graphical User Interface for game and software
tools development. EZ GUI can run over OpenGL, Direct 3D or every other
proprietary engine trough the rewriting of few low level functions.
The entire interface is displayed over the 3D views. This provide the best
integration with the 3D engine running back.
EZ GUI is a complete windowed user environment which include a integrated window
editor, a standard widget library, a full featured help system, a drag and drop
manager, and a basic data base manager.
EZ GUI is a component of the EZ World project. The EZ World project is a
composite creative software developed with EZ GUI. EZ GUI offer the high level
of integration trough his unified working environment and global mechanisms.
You can use EZ GUI for tool development, game development or to provide a
advanced GUI with your 3D Engine.
A real demonstration of the full EZ GUI environment will be available later.
Check it on the site [LINK http://www.z-oxyde.com/ez-world/ www.z-oxyde.com/ez-world/]
For more information, contact me : [LINK mailto:gabriel.rabhi@z-oxyde.com gabriel.rabhi@z-oxyde.com]
(L) [2000/06/17] [JensJung] [drdoomsday@gmx.net]
This Image collection is from 3d Studio Max. I export AsCI scene export
files and use ti for my Engine(Willpower3D). These scene will be the first
episode in my game. My engine uses also octree data structures. Lost of thanks
to Nate Miller, for his very good ase loading code, and to Tim Schroeder for
his goood Octree tutorial. If you have any comments send an e-mail to
[LINK mailto:drdoomsday@gmx.net drdoomsday@gmx.net]
(L) [2000/06/19] [ZedZeek] [sexybastard@clear.co.nz]
heres a shot of the game that ive been working on a while. it uses the bollux
(TM) engine. i would say the bollux engine (TM) is cutting edge but that would
be bollux so i won't. though what i can say is that it does/uses
- particle system
lightmapping
physics
dynamic lighting
LOD
bumpmapping (at least it did but its a bit slow on my card so ive disabled it)
opengl for rendering
bots though all they manage to do at the moment is run around bumping into
things
collision detection (been working on this since february ±20 hours a week and
still haven't got it sussed out 100%. i'ld appreciate some advice from someone
on a failsafe method of doing it)
zed zeek
BTW i don't have the landscape shadows turned on in the above picture + i know
theres a resemblence with a popular game (don't worry they'll be hearing from my
lawyers)
(L) [2000/06/21] [IlianStoianov] [ilian_s@yahoo.com]
- real-time
- light maps
- bump maps
- vertex lighting
- ray traced terrain
- an my old work dated 1998
- that's all
Ilian
(L) [2000/06/23] [DavidPaull] [david@tanzanite.to]
Here is a screenshot from the TechNature 2.0 engine. TechNature uses fractal
mathematics to grow random planets, trees, and grass. The planet is
different every time you run the program. It takes few minutes to calculate
the 4 billion multiplications required to generate all of the polygons, and
over 3mb of procedural textures. One of the new features is terrain shaping.
Despite a completly random surface, terrain shaping allows for a custom flat
playing surface. Perfect for vehicles that dont like mountains! Screenshots,
and the 1mb demo can be found at [LINK http://www.tanzanite.to/]
(L) [2000/06/26] [JohnvanderBurg] [john@mysticgd.com]
To join the terrain screenshot parade again, here are some screenshots from the current
Oxygen3D terrain system.
Lighting is disabled in this picture, because I'm working on that now. I have lighting in the terrain system
already, which it is vertex color based. Will upgrade that to lightmaps.
Another almost finished feature of the terrain system is the occlusion system, which performs very well
(when you are not viewing from top ofcourse). It automatically disables the occlusion system when you are
viewing at an angle where occlusion won't have any much influence anymore, and will only slow down because
of the unneeded checks.
It's nothing really special yet. Stay tuned for some real kickass shots :)
- John
(L) [2000/06/30] [LukeHodorowicz] [hodorl@rpi.edu]
This is an early shot of my cartoon rendering engine:
Features:
- Adjustable light sources
Adjustable shadow colors (i.e. the blue shadow on the white cloth)
Adjustable shadow location - starts the shadowing colors anywhere
between 0 and 180 degrees from the light source.
OpenGL rendering
Wavefront OBJ model loading
(L) [2000/07/05] [SebastianPosch] [sebastian_posch@c4.com]
this is a little pic of my current work on a racing game(hope one can see something :-) ).
currently, you can see more stuff like dots and lines (which are some vectors i need for calculating stuff, they make me crazy!! ) and less eye-candy :( .
but the better the engine is built, the more eye-candy i can expect from it :)
it's my first approach to make a game in openGL, but with the help of some of you guys out there it's not that hard !
(L) [2000/07/09] [LarsMiddendorf] [lmid@gmx.de]
This is an image of my 3d engine.
The source can be downloaded at
[LINK http://people.freenet.de/nolimits3d/]
(L) [2000/07/10] [FrankLinder] [baron_3d@hotmail.com]
I have done some improvements with my landscape.
(See my latest contribution to IOTD.)
Instead of divide n conquer I use a better height analyses, combined with
triangulation.
Instead of texturing in large blocks I use texturing in small blocks
combined
with alpha blending.
Programmed in Borand C++ Builder(4) and DirectX6
(L) [2000/07/11] [JoshuaShagam] [joshagam@cs.nmsu.edu]
Ah, the lowly torus... the bane of graphics programmers old and new, done
to death in testing every single possible permutation of simple graphics
algorithms... like in this case, where it's dynamically morphing with a
cube of a completely different number of vertices and polygons with
realtime reflectionmapping and shadows (shadows not turned on in this
screenshot). Oh, and it just happens to self-reflect too, complete with
interreflections...
[LINK http://www.cs.nmsu.edu/~joshagam/Solace]
(L) [2000/07/13] [LennoxAntoine] [lbantoin@ic.sunysb.edu]
These are screenshots from my xonnel engine. I brightened them a bit
because I think they are dark on some computers (this loses some of the
ambience in them). I have been working really hard at producing a demo
and so far this is all I could come up with. The screenshots do not do
it justice in my opinion. As for the engine, it is not biased towards
anything. I plan on using it for all kinds of games. Here is a little
description :
Features:
- Octree space partitioning
Quadtree continuous level of detail terrain
BSP rendering (not use for it right now, octrees are better with no
pvs)
Quake MD2 loader (temporary)
Advanced particle system
Collision detection (with sliding)
Simple Physics
Reading of map file levels (I use worldcraft right now) or any level I
can load
Automatic detail option for speed control based on framerate
Engine controlled through scripting for dynamic modification without
recompilation (not fully done yet, wait till you see this)
Scripting done with the Seer scripting library
Sound done with the fmod sound library
Fast terrain Shadows (only an approximation though)
Dynamic Terrain Lighting
Dynamic Layers (like cloud, and water planes)
I would really appreciate feedback on the engine (although you haven't
ran it). What do you think it needs?
Drop me a line at : [LINK mailto:lbantoin@ic.sunysb.edu lbantoin@ic.sunysb.edu]
(L) [2000/07/15] [KyleKestell] [kkestell@uswest.net]
hey, i've been a fan of flipcode for a long time now and I thought that
I would contribute my own IOTD for once :>
The following screenshot if of a Quake2 level (I dont remember who made
it, sorry) converted from the quake2 .bsp format into my own binary
format. It was rendered using a simple test program that I whipped up
in a few minutes to test the validity of the data. Currently, the
fileformat supports triangle strips, multiple textures and texture
coordinates. I plan on adding lightmap information soon, and then
probobly entity/actor/object information. This will soon be intigrated
with my octree based hidden surface removal. If anyone would like a
copy of the file format spec or the source code to either the converter
or the demo rendering program, just post a reply. Note: Although the
fileformat supports multiple textures, I havn't written a texture
manager yet so it is only rendered with one texture ("stolen" from Q3A)
Kyle Kestell
[LINK mailto:kkestell@uswest.net kkestell@uswest.net]
[LINK http://www.users.uswest.net/~mkestell/]
(L) [2000/07/16] [dreamexe] [dream@secsm.org]
first of all i am please at post my article flipcode's image of day.
here is some collection of Jindo3D's snapshot I'm working on.
Here some engine details :
- Data files packing
Billboard,Particle systems
Console system
BSP,Portal ,PVS rendering
Supports All types of texture wrapping ( Plane, Box, Cylinder and Sphere ),SphereMapping
Camera Nav System Based two-pivot crash detect like Drakan,MDK2 and Camera animation
Supports Vertex Lightning,Mesh Morphing
Bone and IK controller based animation
3DS Max Character Studio's Biped Animation,Physique( =skinning ) controller( Rigid only ).
Faster collision detection
Lens flares,Physics,Image loaders & savers for JPEG, PCX, TGA, BMP
Based 3DS MAX plugins
LOD Terran rednering(using Roam,Quadtree Tessellation,fast clipping)
Facial Animation(LipSynk,eyebrows defomation(Using Mp3 Callback Lipdata))
Motion Blending In Character Animation
Polygon Reduction (Multi resoluction)
Mp3 Player
ActiveX Component designed for Web Support
if you wanna more infomation of Jindo3D you just visit
my web page at : [LINK http://jindo3d.secsm.org].and special thanks to Thatcher Ulrich,Tobias Johansson.
Ps)Jindo is faithful korean dog's name like German shepherd :)
- han been
that's all~
see you later..
(L) [2000/07/17] [UthmanApatira] [wiz3d@home.com]
This is just some sample output from a procedural texture generator. It took
about twenty minutes to get it working... I plan to use it as a heightmap as
well as texturer in an upcomming 3D Landscape Heightmap project of mine. I
was going to use perline noise, but then I found some implementation ideas
on the net for a _MUCH_ easier approach, so I used it instead. I could send
a link for a demo of it if people want..
(L) [2000/07/19] [DouglasCox] [dcox@darwinmail.net]
This is a screenshot of the VSOC (Visual Security Operations Console) product
that I work on at Autometric, Inc. ([LINK http://www.autometric.com www.autometric.com]). A 3D and 2D window
allow for simple point-and-view navigation of a customer's site model.
We are able to write software plug-ins to interface with various types of
security hardware and map inputs to 3D/2D models. For instance, the red,
lobed-shaped sensors above are inputs from a microwave motion detection system.
When they are set off (as they have been before this shot was taken), a
configurable alert sound is played, the border color changes to red, the 3D
window 'flies' to a view of the sensor, and we issue a command to a video mux to
switch to a live video feed of the area in question on a separate monitor.
Actually, in this shot the user has selected the (highlighted) camera volume to
manually switch to another video feed.
The UI uses a skin technique so it is also completely customizable if the
customer has a different look in mind.
-doug ([LINK mailto:dcox@autometric.com dcox@autometric.com])
(L) [2000/07/21] [EsaSalminen] [python@dlc.fi]
This landscape picture shows outdoor engine features of our new
3D engine, this is done very short period, so all the optimizations
not ready yet. More screenshots and demo found to our homepage.
Esa Salminen
[LINK mailto:python@dlc.fi python@dlc.fi]
[LINK http://www.saunalahti.fi/~python www.saunalahti.fi/~python]
(L) [2000/07/23] [TAOSpain] [taodesign@airtel.net]
This is a brief capture of my NeO 3D Engine and a project that I use to
do "Dunes, a sand tale". The simulation was made on real time and
simulates a dunes field with dinamic dunes (dinamic base grid), wind
intensity and direction, dinamics clouds and other...
(L) [2000/07/24] [RuiFerreira] [t5rui@hotmail.com]
This is a screenshot showing my terrain rendering system's output.
Its core feature right now is level of detail. This makes the engine very
scalable. It also brings its own set of problems, but primarily I'm following
the LOD way because I wanted to have full dynamic terrain on the scene. I think
it real adds to the whole environment when you have something like this going
on. Its just not static boulders anymore, its level of detail from your
viewpoint all the way to the horizon. Yes, I hate clipping fog. :]
What looks less good is the lack of detail closer to the viewer, but I hope to
improve my dynamic texturing system, so it will look a lot better. If not, then
this is nothing a simple detail texture can't handle too.
One funny thing though, is that this wonderful screenshot was taken on a top of
the line Matrox G200 system. Of course that higher LOD levels are just too much
for this good old card, but the results sure look promising.
-Rui Ferreira
(L) [2000/07/25] [JorisTimmermans] [joris.timmermans@luc.ac.be]
This is a screenshot of my latest tinkerings with Image Based rendering.
It shows the warped image on the left, and the original on the right.
The gaps you see are introduced by lack of "visibility" from the original
image, I'm currently looking to implement ways of filling these gaps in
a satisfying way.
In my test-skeleton you can move around with the keyboard, to show the
warpings for different viewpoints.
(L) [2000/07/26] [WillMcGugan] [wmcgugan@netcomuk.co.uk]
This is a shot of a tech demo I recently produced. There are 15 of those
strange little creatures swimming over an undulating sea bed. Each one is
environment mapped, and contains a point light source. The screenshot
doesn't really do justice to the heightfield engine, because you cant see
the real-time caustic effect. The creatures are animated with a fairly
simple procedural system; the tails wriggles and the bodies expand and
contract to simulate breathing.
Im planning to release the tech demo soon. But in the meantime, I hope you
respond to my thinly veiled attempt to attract you to my website :)
Will McGugan
[LINK http://www.warren-software.com/]
(L) [2000/07/28] [DevonZee] [devonzee@hotmail.com]
It's a pretty simple particle engine, with a few different options.
Particles are static (well, they rotated and scale, but they don't have any
advanced movement) unless you move them yourself. It renders at 400x300
fairly quick, but once you get to 640x480 it slows to a crawl. It features:
6 different types of filters (4 shown here)
Most filters can be "Jittered" (see first shot) which makes them sparkle
quite a bit, for a firework effect.
"Alpha Mask" mode, which allows you to (although cumbersomely) export
AlphaMask animations, which could be used for animated blended textures.
Runs in OpenPTC so it should be portable if I ever want to make a mac
version :).
[LINK mailto:devonzee@hotmail.com devonzee@hotmail.com]
(L) [2000/07/30] [NathanielSaintMartin] [noote@bigfoot.com]
This is just a attempt for create solid texturing from famouse Perlin noise function.
The engine is a hierarchical OBB culling/sorting with (currently disable) vertex gouraud shading and shadowing.
Each face you can see have a texture (64x64) which is calculate once : the first time when face was visible.
Currently, I have few materials : 'blue-marble' (from Perlin), 'standard' wood implementation (from Perlin too),
a bugged checker and a 'sphere' material... so if you know some others procedural texture algorythms, don't
hesitate to send it ;)
You can get Dx7 binaries at [LINK http://www.bigfoot.com/~noote/3d/SolidTexturing]
A bientôt...
Nathaniel 'NooTe' Saint Martin
From Paris, France
[LINK http://www.bigfoot.com/~noote]
[LINK mailto:noote@bigfoot.com]
ICQ:39719035
(L) [2000/08/01] [LennoxAntoine] [lbantoin@ic.sunysb.edu]
I sent in a pic a while back of my engine in an earlier state. I changed up a
couple of things since then. To get more info and a downloadable demo, check out
my site :
[LINK http://www.sinc.sunysb.edu/Stu/lbantoin/]
Lennox Antoine
[LINK mailto:lbantoin@ic.sunysb.edu lbantoin@ic.sunysb.edu]
(L) [2000/08/04] [ShawnKirst] [skirst@fuse.net]
This is a little demo I threw together over a few days using spare time in
the morning before going to work. It's a terrain scene simulating an
errupting volcano. Features include: particle and smoke effects,
bump-mapping using a 2 texture passes (will work on TNT class cards) and an
animated skydome using a bezier patch. The terrain is generated using
height map images. I was thinking about trying an implicit surface mesh to
add realistic lava flow to the volcano. Shoot me an email at
[LINK mailto:skirst@fuse.net skirst@fuse.net] if you'd like to take a closer look. I'll release the
source code as soon as I 'clean' it up.
(L) [2000/08/06] [TobiasBarendt] [tobias.barendt@innovation.se]
A very early shoot of the outdoor part in my next engine.
features of the moment:
- ROAM
Lightmaps
Alphablended textures
a not to good looking water polygon =)
// Tobias Barendt
(L) [2000/08/08] [JaredGo] [j.go@rcn.com]
These pictures show the features of my new terrain rendering engine,
approximately one week into its creation (after many sleepless nights!). The
engine uses the ROAM algorithm, which makes for a huge difference in quality
over my earlier continuous-LOD quadtree engine.
Essentially, this game is intended to be a kind of "MMORPG" engine, as I
designed the architecture to be all patch based, with each 128m x 128m patch of
land about 5kb uncompressed at a 4m x 4m heightfield resolution. Essentially,
this height data is the basis for procedural generation of all other terrain
textures and details. For example, unique textures are synthesized during game
time for each patch. A normal map is also generated from the height data, and
thus this game makes heavy use of the D3DTOP_DOTPRODUCT3 operation for real time
lighting over the entire terrain. The skydome is essentially the classic
"interpolated colors" from horizon to zenith, with some additional tweakable
parameters.
The water is done through the use of a stencil buffer, and the edges are
smoothened through the use of another in-game generated texture - a simple alpha
map which determines opacity. I think I will be adding some ripples for added
realism too :). For some concrete numbers, the engine runs around 60-80 fps on a
P3-500, Geforce2 GTS, 128MB memory.
Other than that, the engine is still missing trees and decorative items, and I
am putting in detail textures just as I am writing this e-mail. For now, it is
kind of difficult to judge the scale, but the mountain in the distance is about
600m away or so..
That's all for now, any comments/questions welcome....
Jared Go
Lead Programmer (of a 1 man team :) )
(L) [2000/08/10] [EsaSalminen] [python@dlc.fi]
This time we demonstrates not only terrain engine, but also physics
engine part of our 3D engine. Car physics is implemented with rigid
body physics and this is our first physics implementation on it in real
3D enviroment. Engine does not care all physical laws at least not yet, but
it's quite fun driving around the world. Demo found to our homepage, hopefully
you enjoy too.
Esa Salminen
[LINK mailto:python@dlc.fi python@dlc.fi]
[LINK http://www.saunalahti.fi/~python www.saunalahti.fi/~python]
(L) [2000/08/12] [JaapSuter] [J.Suter@student.utwente.nl]
This is a picture taken from my last vacation in Les Deux Alpes, France. I
went snowboarding for three weeks there and as you can see I'm upside down, in
the middle of a frontloop, about 3 metres above the snow, jumping about 15
metres far. Anyway, I'm back in Holland again (sigh), and I'm currently
picking up my work (a new project, which I'm very enthousiastic about), I
started studying again, and drank lots of beer (and applejuice) with friends I
haven't seen for a while. I'm sorry to those I couldn't reply for three weeks,
but hopefully I replied everybodies mail by now.
See you later,
Jaap Suter
(L) [2000/08/13] [M.Knuth] [knuth@rbg.informatik.tu-darmstadt.de]
Some screenshots from two "experimental" Engines I programmed on a voodoo1 long time ago:
The upper two images are from an engine using "uniqe" texturing (this would be fast (if you have
64mb texture memory :) )), but it looks nice
The lower two show my way of using voxelspaces - it is a skybox - as a texture ,
recalculated every frame :)
I´ve got a lot of more pictures of these old projekts in my home :
[LINK http://www.student.informatik.tu-darmstadt.de/~knuth/ www.student.informatik.tu-darmstadt.de/~knuth]
(L) [2000/08/14] [AaronHilton] [videogamer@home.com]
Here is an early picture of a project I'm working on with my friend,
code named "Spolia-Island." The rest is a secret.
- Aaron.
--
Aaron Hilton
Software Designer / Programmer
and OpenGL Challenge Organizer
[LINK http://OGLChallenge.otri.net/]
(L) [2000/08/16] [MikeBoeh] [mike@retro64.com]
This is the retro game, Bugatron, that I am working on. It takes influences
from games like DX-Ball, Galaga, Bill's Tomato Game, Centipede, etc....I am
actually pretty far along with it. It uses renderit3d from indotek, which is
basically a d3d IM wrapper (although I have to go into dx/d3d a lot anyway) and
it's pretty good. The one feature it lacks that just KILLS me is that you can't
send it's loading functions file pointers- so I cant use my .wad file coding.
Anyway, my engine features: nothing! It is pretty vanilla d3d here. I am
envious and amazed by some of these fantastic IOTD's but I am focusing on true
retro playability and you wont be blown away by anything here. But I hope it is
a fun game that's a throwback and is really a 2d game in 3d space. One
interesting thing about it is that there is so little fill going on, that it
runs great on my machine even at 1600x1200. You have to be online to play it,
as the 6 xml levels are only on my www site (even the splash screen is an xml
level). The XML parser code is from my good friend, Mike Welch, of DX-Ball fame.
Also, I have not tested it on any cards except for my diamond viper2 under
win98, so I would GREATLY appreciate if you could mail me what your system specs
are, and if it ran, and what it's logic and render time was (hit f11 to get that
info). My email is [LINK mailto:mike@retro64.com mike@retro64.com]. The "test" can be downloaded from
[LINK http://www.retro64.com/bugtest.zip]
-mike!
(L) [2000/08/17] [MarkoDokic] [marko.d@gmx.net]
my little opengl metaballs demo. as i started this, it looked very much like
paul bourkes code. means, the values were computed for the whole grid
(example: 32x32x32 times getting distance to all the balls), and all
triangles used there own vertices. then i implemented a bounding box, so
only the values in the box around the ball were computed. this was a large
speedup, but it also brought problems, when the balls connected or there
were all near eachother, the surface could go out of the box, and gaps
appeared. the next thing i did was vertex sharing, because all the vertices
were computed twice!! yesterday i coded that it computes the values
recursively. that means that it startes with a cell, then looks what edges
of it are cut by the surface, and then goes to the cells that use this edge.
so only the needed values are computed. this meant over 100% speedup!
you can set the grid-resolution, the number of balls, the iso-value of the
surface, at runtime. i also did 6 presets of some cool settings. i realesed
the source for the old bound-box version.
get it at [LINK http://swiss.scene.org/quixoft/marko]
(L) [2000/08/19] [JoshuaShagam] [joshagam@cs.nmsu.edu]
Even with 9268 unique objects of which about 3500 are visible at this time,
only about 35 unique LOD mesh retesselations are being calculated. (Oh,
and even though they're all spheres, they're stored as a generic mesh, not
as a procedural generator.)
Obviously, this isn't a typical scenario. Good thing, too, since even on
my 525MHz Celeron with a 32MB G400 it's only getting 1.5fps. :) (I would
have sent an image using shadows to gloat about the fact that even the
shadow volumes would have only contributed a minimal increase to the number
of LOD retesselations, but stencils are currently broken on the Linux G400
driver and I gave up on waiting for this to render a single frame using
software Mesa after about 10 minutes...)
Oh, and one of the (many) things I'm working on right now is an actual mesh
editor for my funky mesh-representation scheme. Maybe I can eventually put
in screenshots where the models aren't all procedurally-generated. :)
This is all on Solace, my thesis project 3D engine. More screenshots are
available at [LINK http://www.cs.nmsu.edu/~joshagam/Solace/]
(L) [2000/08/21] [JariKomppa] [solar@icon.fi]
Here's a screenshot of my flipcode contest entry in hopes of getting other
people
to enter as well. The shadow algorithm is completely ad-hoc and almost works
=)
The 'mandatory' reflections were also added in in the form of small ponds.
When I read the competition description the first thing I could think of was
one army memory of mine, with flare flying in otherwise pitch dark forest,
and
the shadows dancing..
I had some misgivings about giving away the source but then again, I'm not
planning
on reusing the code myself anyways, so why not..
Jari Komppa
[LINK mailto:solar@icon.fi solar@icon.fi]
[LINK http://iki.fi/sol]
icq 44620217
(L) [2000/08/23] [Klaudius] [klaudius@free.fr]
This simple mesh was done by bozo (the klaudius brother) and we make this woman run with
only cycling sinus based function (No motion capture).
[LINK http://klaudius.free.fr]
(L) [2000/08/24] [ThomasMathys] [mathys_aka_scratchy@bluewin.ch]
this is some project for school.
we can code almost anything in any language,
so i decided to code a raytracer in c++.
it is the first version that is able to display
something nice, but there's still a lot to do
(more shapes, 3d textures, boolean objects,
maybe some speed omtimizations...)
thomas mathys
(L) [2000/08/26] [ParasharKrishnamachari] [krshnmch@uiuc.edu]
This is a screenshot of the latest version of UIUC-SIGGraph's 3d
Painterly Rendering Engine. I sent in an earlier one to [LINK http://www.flipcode.com/forums/iotd/03-09-2000.shtml IOTD - March 9],
2000. It simply takes a 3d scene and creates the effect of painting it
on the screen. The result is full mobility in a fully painted scenery.
This is the 2nd version and shows some significant new changes...
- Far faster
Better overall coverage of screen
More brush variety, including (sort of)curved brushstrokes
Direct3d (old one was Glide)
Lighting engine (old one was not using it)
Lesser interframe coherency (this is actually a bad thing)
Semi-quasi faked multi-layer painting
This version is also the one that was shown at SIGGraph 2000
conference. Although, we got the research award for version 1. There
is more info at [LINK http://www.siggraph-uiuc.org/painterly/]
and more Version 2 screenshots at
[LINK http://www.siggraph-uiuc.org/painterly/v2/]
As far as we've seen, this is still the only truly 3d Painterly
Rendering Engine in existence that runs in realtime. A PIII-600 w/ a
GeForce (not GeForce2) was running this particular scene at 30 fps.
- Parashar Krishnamachari
(L) [2000/08/28] [JohnSchreiner&GazIqbal] [jmschreiner@students.wisc.edu]
This is a screenshot from the recent test release of our 3d engine. It's
strong points are probably it's modular and clear coding style. For a full
feature list, and full source code and executables check out our webpage
here ([LINK http://www.thepeel.com/void]).
John Schreiner
Gaz Iqbal
(L) [2000/08/29] [AlexandreMaltais] [maltaisa@cogeni.com]
This is a preview of my flipcode contest entry (Shadow and Light).
I use a particle system for light and foutain effect (small picture).
Alexandre Maltais
(L) [2000/09/04] [Kain] [kain_3@yahoo.com]
Hey,
A few screenshots from my *engine* so far, just made a
few tests with per-pixel lighting with the NV register
combiners and thought it looked nice. Top left is with
a full white light in the middle of the room, Bottom
left is the same shot then Top Left without any lights
(fullbright), Top right is the library room with a
wierd orange-ish light, and Bottom right is a
wireframe view of my test level, each polygon has a
random color. The actual level is from Vampire the
Masquerade, compiled with my little level compiler.
Theres no visibily determination yet except for
backface removal and frustum culling. I'm working on
portal/octree hybrid thing right now.
Kain_3
(L) [2000/09/06] [RuiMartins] [Rui.Martins@link.pt]
This is the current state of the Art on image quality has all of you can
witness. ;-)
[Top Left] The MultiColor Car is cruising with the wheel trails ON.
[Top Right] A closer look of the cars.
[Bottom Left] The inside (pilot) view of a car, when making an Hard Left
Turn.
[Bottom Right] A view of the Colored Car with Graphical Debug Turned ON,
which enables us to see the actual diferent speeds each wheel has and
the Virtual curve Center.
What I have been really trying to make correct is the physical
behaviour/handling of the car.
Currently the entire world of Racer is plane FLAT, it's easyer to
implement for now. But you can Edit the track file (*.trk) !
The Suspension and Inercia are Implemented, and the timing should also
be ok.
But there are two inconsistencies, lets see if any of you can find them
out, besides the non implemented Features. ;-)
See ya
P.S.
Almost forgot, after all the trouble to make the page, for a runnable
demo just go [LINK HTTP://is-sv.link.pt/~rmsm/OpenGL/Racer here].
P.P.S
There is NO music, NO Sound, no Colision Detection, NO Sliding, NO
Speed Limit (air resistance should take care of this when implemented)
and NO joystick support (didn't have the time to include it, sorry)
which means no Force-FeedBack 8-).
Rui Martins
(L) [2000/09/08] [RobJames] [robjames@europe.com]
My name's Rob James and I'm working on a new demo which amongst other things
is attempting to do some Terrain rendering (oh not not another terrain!)
Hopefully this one's a bit different because it's ray-traced in realtime and
doesn't need a Hardware 3D card :)
The terrain is based on the HybridMultiTexture code described in the
excellent book, 'Textures and Modeling - a Procedural Approach' by perlin,
ebert and musgrave. The core of this terrain algorithm is a sequence of
weighted calls to the standard Perlin Noise function, which traditionally
can be too slow for real-time use. This tiny demo renders a practically
infinite terrain via a 128x256 texture which is rendered into a 640x380
window. Both the Perlin Noise function (Noise2) and the HybridMultiFractal
Terrain function have been implemented using Intel SIMD (for 4-at-a-time
power!) so it will ONLY RUN ON Pentium III class cpus (Celeron II is cool
too). Using Intel Compiler 4.5 and hefty use of VTune (both demo's from
Intel Site) I have managed to get the code upto 16fps on a PIII-650 and
19fps on a Celeron-750. If there are any SIMD gurus out there that can cast
an eye across my initial efforts I would be happy to post the code.
ta ta
[LINK mailto:RobJames@europe.com RobJames@europe.com]
(L) [2000/09/10] [JohnvanderBurg] [john@mysticgd.com]
Here is a collection small screenshots which I grabbed during the development of a new lighting system in Oxygen3D.
The new system supports hardware accelerated dynamic lighting using omni/spot/directional lights, and also static
raytraced lightmaps with also support for omni/spot/directional lights, and last but not least a very cool radiosity system
which can also be combined with the above mentioned light types.
Lights can be placed inside 3DSMax, and also you can setup the radiosity values per material.
The materials have an energy value, which tells how much energy it emits.
Also you can let the material be self-energizing or not. On this way you can create cool radioactive looking objects :)
Another nice thing is that you can fly around during the lightmap generation.
Inside the modelviewer you can start the generation (you can choose between raytraced lightmaps or radiosity), and then
the system starts generating the lightmaps.
You can see the lightmaps being updated while you fly around. And if things go too slow you can simply pause the generator, so
you can fly around very smooth and look for possible things you want to change.
This is very usefull while doing radiosity lightmaps, because it can take a very long time.
MysticGD hired Marco Kögler to code the lightmap system. So credits go to him mainly!
I'm currently working on a PVS system, which should speed up the radiosity calculations a lot.
Some much cooler screenshots coming very soon. We're currently building some nice test scenes.
Not just a few boxes/spheres/cylinders :)
p.s. we have some big news coming up... more info soon.
- John
(L) [2000/09/12] [JoeSilver] [joe@axesoftware.com]
Here's another taste of the next revision of my GUI system. Some of you may
remember my last IOTD of the GUI system You can check it out [LINK http://www.flipcode.com/cgi-bin/msg.cgi?showThread=07-12-2000&forum=iotd&id=-1 here].
I had made a huge mistake in my initial design, so unfortunately I had to
recode most of the underlying structure from scratch. There's a big
difference in appearance this time as well. YES it looks like windoze, but
it's a familiar interface, and it's easier to debug and get an idea of how
things should be work.
Anyway feel free to give me feedback.
Features finished
- Fully customizable menus (top level, and submenu levels) Right now the
menus can only go one level deep
Window and Control clipping.
Textbox
Progress bar
buttons (the buttons change appearance when clicked and only execute the
click code when the user releases the mouse button over the GUI button.. ala
win9x)
Status bar
fully functional console. (parameterized commands, cvars (via set command),
etc..)
commands in the console can be executed like "command(param1, param2)" or
"command param1 param2"
resizing and z ordering of windows
dynamic background in main window.. you can specify an image or a UDF
rendering function
proportional fonts, (even a tool to create the textures on the fly)
The text is a little fuzzy right now.. It's dude mostly to scaling the
texture. This is on my list of things to fix.
Each control/window has User Defined Function support for several events as
well.
I'm working on getting the rest of the controls done now.. Also I plan to
implement a very basic scripting system for the GUI as well. The scripting
system is low priority right now though.
I'm also working on getting it running under linux.. this could take a while
though.
The whole thing is done in C++, and uses classes extensively
Cheers,
Joe Silver
Axe Software
(L) [2000/09/14] [VladAndreev] [goltrpoat@hotmail.com]
This is something that was thrown together over the course of about ten hours
after having been awake for a good 30 hours prior to that. Nothing terribly amazing
from the technological standpoint, but it looks fairly nice so I thought I'd submit
it. Also, the landscape parade has been dying down, and I thought it'd be a good
idea to resurrect it :).
(L) [2000/09/15] [KimPallister] [kim.pallister@intel.com]
Attached is a screenshot of procedural terrain/world I and a co-worker have
been working on. There's no clever terrain LOD schemes, just a brute force
method of throwing loads of triangles at the HW (the terrain is ~100,000
triangles, of which 25% are rendered in any given frame).
The cool thing is that everything is procedural. The terrain,
terrain/detail/mask textures, clouds, trees, tree impostors, flocking birds,
etc, are all procedural. It's a <200k .exe file that doesn't load any
artwork.
We still have some work to do on it, but will be releasing the whole thing
with source as part of a webcast training on developing procedural content
for 3D applications. (Uh oh. Here comes the plug).
If anyone's interested in the webcast, here's the info:
Real-time Procedural 3D Graphics on the PC, or "How to Send the World
through a 56k Modem", with Kim Pallister & Dean Macri.
Learn how to use the horsepower of the processor to generate 3D content
algorithmicaly, saving valuable artist time & download bandwidth. Understand
procedural generation of terrain geometry, textures, trees, clouds and more.
We'll discuss and demonstrate performance implications and experiments we've
tried in DirectX*. This session should interest persons familiar with 3D
graphics programming and/or Microsoft DirectX.
When: September 21 9:30-11am Pacific Time
These webcasts will feature slides, live audio streaming, demos, and a chat
window where you can meet with peers and ask questions of the presenters.
To register, see [LINK http://developer.intel.com/software/idap/training/] under
"Spotlighted Courses".
A couple archived webcasts on scalable 3D apps & cloth animation are already
up there.
Kim Pallister
Staff Technical Marketing Engineer
Intel Corporation
(L) [2000/09/17] [PierreTerdiman] [p.terdiman@codercorner.com]
Here are some (mostly old) screenshots from my development framework called ICE.
It includes some rendering facilities as well as miscellaneous private libs (from
collision detection to rigid body and cloth simulation).
From left to right and top to bottom:
- Butterfly subdivision surfaces on a Lara-like model
cellular noise-based terrain interacting with water
spectral synthesis and texture generation
radiosity test scene #1
radiosity test scene #2 (Hi Klaus :)
the classic 2D water effect rendered as a 3D mesh
a complex scene made of more than one thousand objects (this is the french "Pyramide du Louvre")
cube-mapped reflections...
...on a Q2 character as a bonus
Of course, everything is exported from MAX by Flexporter :) ([LINK http://www.codercorner.com/Flexporter.htm www.codercorner.com/Flexporter.htm])
Cheers,
Pierre
[LINK mailto:p.terdiman@codercorner.com p.terdiman@codercorner.com]
(L) [2000/09/18] [TimLewis] [Tim@aicube.com]
Here's the latest shot of my 3d modelling software, Clayworks. It shows my
custom GUI which uses my own drawing routines under direct draw for
blitting. Although it looks quite different from a standard windows app, it
runs alongside other applications and makes use of the clipboard and drag n'
drop features, rather than running in full screen only.
The gui will soon handle transparency but as I'm clipping the correctly
windows rather than drawing them all from back to front, this is a more
complicated matter than in some other GUI's. I've come up with a neat
solution but it'll take a bit of hacking to get it working :)
The application itself has been in development for quite a while although
I haven't released this latest iteration yet. The older DOS version are
available from my site ([LINK http://www.clayworks3d.com www.clayworks3d.com]) but the new one is far in
advance of this. The modelling tools are quite extensive, including
polygonal mesh construction (with 'post-creation' parametric alterations
available ala 3dstudio max), splines and metaballs. The selection and
manipulation tools include the standard translation, scaling and rotation
functions but also include a wide range of more specialized tools for
scaling on an axis, rotating around and axis, twisting, shearing, tapering
and so on. All of these tools can be combined with copying and extrusion
functions which come in really handy for mesh modelling.
Clayworks supports quite a few popular file formats too with a wide range
of image and mesh import/export functions. Currently included are lightwave
lwo files, 3ds files, md3 quake models, clayworks internal file format and a
couple of other slightly more obscure formats. I'm planning on extending
this list to include POVray and softimage files amongst others.
Hopefully I'll have a release version available later this year. If you
want to encourage me to hurry up, drop me an email at either
[LINK mailto:tim@clayworks.com tim@clayworks.com] or [LINK mailto:tim@aicube.com tim@aicube.com]
Tim Lewis.
(L) [2000/09/19] [VilleMiettinen] [wili@hybrid.fi]
Here's a screenshot from one of the new SurRender Umbra demos. Umbra is a
commercial
visibility determination library that can be plugged into any 3D rendering
engine to handle
early culling of hidden objects (hierarchical VF culling, occlusion culling,
portal culling,
contribution culling). The library supports completely dynamic scenes and
requires
no visibility pre-processing.
This real-time demonstration shows how objects can be "on-demand loaded"
from massive world
databases. The demo loads objects from a database file when they become
"almost visible". The loading
never stalls the rendering - if an object hasn't been loaded in time, it is
not rendered until its data has been fully
streamed in. Objects that have not been visible for a while are removed from
the database and swapped
back to the disk.
The database in the picture contains two million objects. All models have
108 triangles and 258 vertices,
thus pumping the total triangle count to 216M. The database file requires
130Mb of disk space.
The memory used by the visible portion of the database (and other Umbra
allocations) is around 1.5Mb. The database
is not static: 120,000 of the objects are moving around every frame. The
startup time of the application is
a couple of seconds.
The image on the right side of the window shows a bird's eye view of the
situation. The
view frustum has been marked in transparent gray and the objects visible to
the camera on the left
are shown.
This and other Umbra demos can be downloaded from the SurRender Umbra
home page ([LINK http://surrender3d.com/umbra]). All of the demos run through Umbra
Visualizer, a fully portable (OpenGL+GLUT) rendering framework.
cheers,
-wili
(L) [2000/09/21] [NickAnderson] [andersnd@hotmail.com]
I like terrain engines alot and have been inspired by the numerous ways
people go about generating 3d worlds.
All the engines shown were written with OpenGL, however, the ICD
implementation on my ATI Rage Pro doesn't always give me the results I
expect. :)
You can find these screenshots at my web site
([LINK http://www.flyingislands.co.uk]), plus downloads including the source code
which is there for peoples use under the terms of the GNU public license.
There are alot of buzzwords going around in the 3D engine forums such ROAM
etc. though I found the ROAM algorithm to be a bit too complicated to
implement easily so in the end I settled for a quadtree algorithm. The
screenshot on the top left is from my LOD program which utilises a quadtree
style algorithm. There is also a link to a paper on the subject at the
relevant page on my site. The program could probably do with geomorphing and
some other additions.
Two of the other screenshots (top right and bottom left) are from an engine
called Caladan. A terrain engine with tiled textures, rolling oceans and
some imported ASC objects. :)
The one on the bottom right is another terrain program that I'm working on.
Nicholas Anderson
email: [LINK mailto:n.anderson@eidosnet.co.uk n.anderson@eidosnet.co.uk]
web: [LINK http://www.flyingislands.co.uk]
(L) [2000/09/22] [JonasCollberg] [jonas.collberg.8669@student.uu.se]
This picture was made using my ray tracer made as a school project
(A few years since I touched it now...). I guess it isn't anything special,
but I sort of like the colors...
Anyway, there's a lot of nice pictures floating about around this place.
Makes me wanna code... So I guess I'll have to start polishing up my rusted old
brain cells and try to do something about it.
--
Jonas Collberg
(L) [2000/09/23] [KasperFauerby] [telemachos@peroxide.dk]
I thought it was about time I contributed something to this section too.
This picture is an example of what my 3d engine can do at the moment. It's
being used for our remake of the classic RPG Ultima 1 and a tech-demo
has just been released on our project page along with some more screenshots.
[LINK http://www.peroxide.dk/ultima www.peroxide.dk/ultima]
About the image and 3d engine : The engine runs on vertex lighting but with
custom calculated vertex-normals and support for smoothing groups. The reason
why we are not using lightmaps are that the size of the gameworld will be HUGE
so even if we saved lightmaps in 16x16 the game would take up several CD's ;)
If someone knows a good and fast way to generate lightmaps on the fly for
about 25000 faces per level I'm interrested in hearing about it.
The visibility determination system in the engine is not really implemented yet, so
speed isn't too great. Basicly what it got is kind of a flat octree combined with
simple frustum culling. Eventually a portal engine will be used for indoors and
an octree/occlusion tree(??) combination will be used for outdoor areas like cities.
Maybe a dedicated terrain engine will be used for the big outdoor scenes between
dungeons and towns.
One word about the tech-release : It loads SLOW ;) One reason is explained in the
readme.now that comes with it - another is that I was taken by surprise about the
overhead of reading from my large datafile.. oh well, more coding to do I guess ;)
- Kasper Fauerby
(L) [2000/09/24] [Mike-T] [mike_t@slo.net]
This is just a screenshot of my simple particle system. It's nothing
special, but I had to test it before I put it into my 3D engine.
You can download it on [LINK http://www2.arnes.si/~mgrobo1/particles.zip].
Miha GrobovÂek
[LINK mailto:mike_t@slo.net mike_t@slo.net]
(L) [2000/09/25] [IngemarEriksson] [ingemar_e@telia.com]
Ray traced quaternion julia set (10 iterations). Original resolution
4096 x 3072 (4 samnples / pixel ) took 36 h on a pII-350. Made with
my own notyetfinished ray tracer.
//Ingemar Eriksson
(L) [2000/09/26] [AlanGordie] [alan_gordie@hotmail.com]
Here's a screenshot from my contest entry for the Lights & Shadows contest here on Flipcode. I'm uploading it
later tonight, so hopefully you can download it from [LINK http://www.flipcode.com/contest/ www.flipcode.com/contest] soon. I still have work to do,
but I wanted to get it out there and see what folks had to say about it.
The technique that I'm using is shadow-mapping and goes something like this.
--during load time (or whenever really)
for each spotlight
attach shadow casters
attach shadow receivers
next
for each frame
for each spotlight
calc view matrix from light
render shadow-casting meshes (white on black)
blit result into shadow-map texture
next
for each mesh-in-scene
render as usual
next
enable alpha blending and setup blend modes
for each spotlight
for each shadow receiver
render using shadow-map texture for this spotlight
next
next
next
Shadow-mapping isn't perfect, but it is well-suited for demo work...
Pro's:
- Very clean implementation
Will work on nearly all recent consumer hardware
Ideal application of multi-texturing
Con's:
- Shadow-casting meshes cannot self-shadow, so you have to be careful when picking which objects to use as casters. However, Mark Kilgard has extended the technique to use depth-mapping to achieve self-shadowing using Nvidia register combiners with OpenGL. I'm not doing that...yet. 8)
Shadows are blocky unless you use insanely large shadow maps. -- I use 128x128
If the hardware doesn't support render-to-texture, then it's much SLOWER!
Eats fill rate like it's going out of style
"D3D" and "rendering to textures" aren't friendly with one another
The technique is covered in Game Programming Gems by Mark Deloura, ISBN: 1584500492 --- I highly recommended this book.
Hope you like my demo.
Alan Gordie
[LINK mailto:alan.gordie@computer.org alan.gordie@computer.org]
[LINK http://gordie.editthispage.com/]
(L) [2000/09/28] [RicardoSantos] [dxantos@yahoo.com]
hi this is some screenshots of our engine
i want to know your what you think
this engine is for our game called
omega2040 soon will be relase the complete demo
in november 25 to 30 first to all our friend
in flipcode
please send ous a email to [LINK mailto:Dxantos@yahoo.com Dxantos@yahoo.com]
or [LINK mailto:johnmustance@hotmail.com johnmustance@hotmail.com]
synceraly richard D & Michael R
draxson team we have rain
bumpmapping snow storms particle system
X-lios mathemathics editor to edit terains
and inside etc etc etc
(L) [2000/09/30] [Jean-MichelHervé] [jean-michel.herve@lankhor.com]
Hi everybody,
Here's a small set of screenshots of the new shadow system I'm working on, for
the Lankhor's upcoming title called WARM UP ! edited by Microïds.
As you can see, the shadow is casted on a quite complex car mesh (note : the
rear wing is not included in the process, since it is still in early
development). The car itself has more than 8500 polygons. The whole thing is
rendered without T&L (but a T&L version is available too, that doesn't support
the shadow system yet).
Please note that this shadow system is fully compatible with ALL 3D cards
existing around, since it doesn't uses stencil buffer at all.
The screenshot in the lower right corner of the pic has been taken on a Radeon
card. The shot is not wide enough to show it clearly, but there's also a heat
effect, using the bump mapping functionnality of the Radeon (originally
developped on a G400 card).
The whole engine could be more optimized, but it currently uses an octree system
for the tracks, a fully physic-handled hierarchy for the car, and so on.
(L) [2000/10/02] [HanBeen] [jindo3d@dreamexe.co.kr]
Here is Screen Shot of Jindo3D's Current working Project.
It some based Motion trace system with four camera and DSP Board .
Character Animation data is extracted Motion Capture System
and four camera is detect 5 attached marker on human body.
Animation frame are about 3000-4000 Frame.and Single Character
is matched each hight(using basic motion retargeting)
if u more infomation, check out movie clip
Cheers,
Han Been
[LINK mailto:jindo3d@dreamexe.co.kr jindo3d@dreamexe.co.kr]
(L) [2000/10/04] [MaxMcGuire] [amcguire@andrew.cmu.edu]
This is a photo of me juggling torches with the Campus Fools Juggling club.
(Photo courtesy of Howard Georgi)
(L) [2000/10/06] [NathandObrenan] [nathand@firetoads.com]
Here is a shot of Ectosaver distorting your flipcode webpage. The
tech in Ectosaver will be
the same kind of water effect you'll see in our up and coming game,
Everglade Rush. The base technique
Ectosaver uses is a spring system to calculate the vertices, and a
refration technique for the actual texture
coordinates.
We also put in DOT-3 bumpmapping for nVidia's geForce cards... in this
case were bumpmapping the
flipcode webpage. If you notice, theres a small amount of dithering
going on with the bumpmap, but thats
due to the fact that the light is so close to the mesh.
Check out the demo @ [LINK http://www.firetoads.com/ectosaver.htm]
(L) [2000/10/08] [JoergBrauer] [jb@games-net.de]
Hey,
these are 4 screenshots from the skp3D-engine I've been working on over the last
year. It's the engine we use in our project NTT 2103, a 3d-rts-game. For some
further information you could have a look at [LINK http://www.skullpture.de] . Some
features at the moment are :
- Support for Q3A .bsp levels
ROAM for landscape-rendering
Skeletal animations
Advanced Particle system
Editors for outdoor-areas and buildings in form of self-made Q3-levels, the
skysystem, particle-systems, object-physics, etc.
.md2, .3ds, .mdl, .obj, .lwo, .ase, .asc, ... files can be loaded
...
I still need to put some work into the physics and some sweet things such as
occlusion culling and better physics, but it's hopefully going to be finished
until december. As to the screenshots, the one in the top left corner shows the
first unit in the game. The second one shows the landscape-engine again, but
this time without a precalculated color-map. The screenshot in the bottom left
corner shows - who might have known it ? - a level from Q3A. At this point, I
want to thank the others of the Titan-engine, their source-code helped me pretty
much fixing some problems I had. The last screenshot doesn't really have
anything to do with the engine, since it was an entry for an
1-week-game-coding-compo where no big engines where allowed to be used, so I had
to rewrite all the necessary functions, I just needed another screenshot and
didn't want to show something twice. It's an Asteroids clone in 3d, using an
octree for visibility determination and collisions, nothing really special.
CU, Joerg Brauer aka nufan^skp^pb
(L) [2000/10/10] [TimSoliday] [TimS@CSSLTD.com]
Here is something a little different from what you are use to seeing on
IOTD. I decided to take a break from 3D programming and make some everyday
utilities/applications in DirectX to refresh my brain, and for a little jump
start. This is my media player paused on one of the scenes in Halo.
80% of the functionality is in place and working perfect. The only thing
missing here is a remote control that will have open/save as file, volume
settings, resizing, and the existing buttons that you see. The final version
will be in window's mode and skinned. The movie will fit the playing screen
in the final version.
I am putting up a site pretty soon that will have the exe and the source
code.
Thanks to Flipcode for the tutorials on Directshow, I was running into a
memory issue in my code and looked at the tutorials to fix it.
For the graphics I used Adobe Photoshope 5.5.
Tim Soliday aka vhalik
(L) [2000/10/11] [JeffVoigt] [jvelite@earthlink.net]
Here are a few screen shots from my skydome I have been working on lately.
So far so good :) What do you all think???
TopLeft: Sunrise
TopRight: Day
BottomLeft: Sunset
BottomRight: Night
Jeff Voigt
[LINK mailto:jvelite@earthlink.net jvelite@earthlink.net]
(L) [2000/10/12] [DavidKarlsson] [98davka@ostrabo.uddevalla.se]
this is a screenshot from my contribution to the lights & shadows contest. The scene
might not be the most interesting - only an enviroment maped statue and some pillars, but
it took many night to get everything working so I'm very satisfied with the result.
It's coded in C++ using OpenGL and I'm using shadow volumes to render the shadows so it
requires a stencil buffer to run.
Well, please download the demo and see for yourself... ([LINK http://www.flipcode.com/contest/ Contest Page])
// Spark
(L) [2000/10/13] [KurtMiller] [kurt@flipcode.com]
Here's a screenshot of a simple utility that I wrote about a week or two ago
for my game engine. Its a material editor (as you've probably guessed)
with various settings for each layer, including blending options, UV manipulators,
and a few other things. Scrolling and rotating UVs are pretty fun for special
effects as well as common game features including scrolling cloud layers, simple water pools, and so on.
I realize this image isn't exactly amazing compared to some of the
cool stuff that people post here, but I posted it simply because the IOTD queue is currently
empty! If you'd like to post your own Image Of The Day, send along a screenshot of something
development-related that you're working on, and it just might make it up here. The IOTD queue is
FIFO, so send those images to [LINK mailto:iotd@flipcode.com iotd@flipcode.com] asap! ;]
(L) [2000/10/14] [OhadEderPressman] [eder@bigfoot.com]
I decided to get going with OpenGL, it's about time. I started playing with height
maps and this is what came out after a few hours. Apart from taking documents like
"Continuous LOD Terrain Meshing Using Adaptive Quadtrees", "siggraph96 - Real-Time,
Continuous Level of Detail Rendering of Height Fields" and printing them at work so
that I can learn something new., I'm thinking of the whole Texturing mechanism.
Should my terrain contain more than 1 texture, how do I blend the textures ? I'm
investigating into this at the moment.
regards
---
Ohad Eder Pressman
IMR
(L) [2000/10/16] [Serge] [langkous@fly-freestyle.demon.nl]
Hi all,
this is a screenshot of my entry for the shadows & lights contest. It uses
shadow volumes & the stencil buffer for shadow rendering. There's also a
simple particle thingy flying around. I don't have the demo somewhere on
the web, but it will probably show up on the contest page in a couple of
days (just in time for the deadline... hehehe!)
--Serge
(L) [2000/10/18] [JaccoBikker] [Jacco.Bikker@davilex.nl]
Here we have a couple of screenshots from the visibility algorithm that I
am developing here at Davilex. The algorithm is a combination of an adaptive
octree for spatial subdivision and a c-buffer for occlusion testing. About
the shots: The first one (top left) shows the scene, rendered normally. The
one in the top-right corner shows the c-buffer: 'Red' means occluded. Note
that I don't just draw every single polygon in this buffer, but just the
large occluders. Also note that I normally use a lower resolution c-buffer,
but that doesn't look as good for an IOTD. :) The green lines are the
boundaries of the adaptive octree nodes, the blue lines (hard to see) are
the bounding boxes of the detail meshes.
The two images on the bottom side of the image show the scene rendered in
wireframe mode, with and without culling.
This is a conservative culling algorithm; as soon as a part of a mesh is
visible, it's drawn completely. This ensures minimal culling costs,
resulting in optimal performance on today's hardware. For software
rendering, you might want to try a slightly less conservative algorithm.
Jacco Bikker, a.k.a. 'The Phantom',
Davilex Software ([LINK http://www.davilex.nl www.davilex.nl])
(L) [2000/10/20] [VanderNunes] [vander.nunes@ig.com.br]
A mix of screenshots from my upcoming game system, the TINY engine. Actually the
work is on the early stages, but I felt somewhat anxious to hear from this
refined community what do you think about it as it is just now (very simple, I
know). I will be glad to see some comments.
Maybe it sounds a little biased, but I must say that this sample doesn't show
it's real capabilities. The real demo will be ready within 30-45 days from now.
The system will feature seamless indoor/outdoor scenery and advanced game
entities, particle systems, etc.
Features already implemented:
- Direct 3DSMAX scene/model exporting including correct multi/sub materials,
lights, cameras, textures (with auto-conversion) and geometry -- with
immediate preview;
Tunable raytraced lightmaps with phong shading and shininess;
Saving/loading of preprocessed scene to/from compressed cabinet file
(using Microsoft's free cab library - works but is provisory);
Adjustable octree subdivision with fast frustrum culling;
Adjustable ellipsoidal collision detection (octree aware);
Multiple origin/target cameras;
Support for keyboard, mouse and VFX-3D helmets through DirectInput and
retouched code fragments from IISVR;
Vertex buffered Direct3D rendering;
Quake2 animated models (works well but is provisory);
Small executable, small scene file, no external dependencies (being
designed with web in mind);
Average good oop with separated Core/Windows modules.
The first preliminar preview is available at [[LINK http://planeta.terra.com.br/informatica/tiny]]
(L) [2000/10/21] [MatthewRiek] [mriek@hotmail.com]
Here is few screenshots from our first attempt at a 3d engine. We coded the
engine as a uni project and hope to do alot more with it after graduation.
The engine is a portal/bsp hybrid with obb frustum culling for intricate
world objects. Screenshots, bottom left shows a static model with a
transparent convex hull and obb, bottom centre is another model
demonstrating lightmapping, bottom right shows a mirror and up the top is
the courtyard in our current test level. We are currently getting ~100fps
on a TNT2 with celeron 400. Still to go, lots :). We are working on curved
surfaces (Q3 insired of course), finishing animation, dynamic lighting and
shadows. When exams are over, we will set up a site from which a walk
around can be downloaded.
(L) [2000/10/23] [FrancisShanahan] [openglmodeller@yahoo.com]
This is a small program I wrote which implements a
nice effect reminiscent of the art of Vasarely. This
picture shows four shots from the program. It's a
square grid which twists and bulges with time. The top
left shows a bulge with a texture mapped grid. The top
right shows the same but with just the grid and it's
inverted in the bulge. The bottom left shows the grid
twisting, I like the lines view because you can see
what's going on, the bottom right is this same effect
with a texture added. Lots of screensavers are built
on this code and it's a nice effect to add to your
demos. I'm will have a small tutorial soon. Source
code is available at [LINK http://www.cornflakezone.com]
Francis Shanahan
(L) [2000/10/24] [BrianGantt] [bgantt@onegames.com]
Here's some screen shots from the latest beta/demo of my game Remote
Assault. The top left shows the full interface with 5 tanks moving in wedge
formation. The top right shows some tanks and APVs escorting a supply truck
through a mountain pass. The bottom two shots are battle scenes between
several tanks, APVs and Walker units.
Some game features:
- Real time play
Chain of command AI(Groups, squads, units)
True line of sight for all units
Detailed damage modeling
Single play vs the computer, or multiplayer vs. humans over a LAN or the
Internet
Note that while its real-time, the game has been designed to play more like
a wargame than a RTS.
If you would like to check it out further go to [LINK http://www.onegames.com www.onegames.com]
Brian Gantt
[LINK mailto:bgantt@onegames.com bgantt@onegames.com]
(L) [2000/10/25] [PhilCarlisle] [pc@team17.com]
This is for use by my little home/test project (freedom -
[LINK http://www.nukeplanet.com/freedom www.nukeplanet.com/freedom] (note: nutscrape doesnt like the site, and ie is
a bit unhappy too :))
The toolbar at the top holds the editing tools for the particualar view.
The view is the set of tab pages on the right, there is a greyscale
heightmap editor, and landscape preview (using opengl, this is a semi
wysiwyg view), when the user selects an object in the objects panel on the
left (the set of tab pages containing "objects" which are placable on the
landscape) the Object properties page contains details and/or editable
attributes.
Finally the Instance properties panel edits properties for a specific
instance of a placed object (so for instance, i place a panda on the
landscape, I can switch to the instance pane and change its name, scripts,
etc etc..).
All in all, not bad for a few hours work (less than an hour creating the
app as it is.. ).
I'll send an update when the preview is more spetacular :))
Phil.
(L) [2000/10/26] [MorganMcGuire] [morgan3d@yahoo.com]
This is a screen shot of our 10/20/00 release, [LINK http://morgansystems.net/radon Radon 2000]. The astute flipCode
crowd will probably wonder, "why is he showing us a Tetris clone?". It is
actually a re-release of a 1994 windows game that Laura Wollstadt & I wrote for
Windows 3.11. At the time, it was hot stuff, and has been a consistent seller
for Morgan Systems. The reason we're re-releasing is that it is a demo of our
all new on-line credit card processing system and distribution method. And
it's a pretty fun Tetris variant. You can choose different block shapes
(including ones that change their shape).
You won't believe how much work it is to create a distribution method. It
turns out that the difference between writing a really hot piece of software
and having a product (i.e. something professional that makes money) is pretty
big. You need to have a distribution channel, quality assurance (make sure it
runs on all kinds of machines), legal protection, credit card processing, fraud
protection, instructions, promotion, customer support, and a web site. Most of
this is tricky... and boring. The difference between having a "completed" game
and a product is kind of like the difference between a game engine and a game--
you're running at 100fps, it looks beautiful, but you still haven't got
something anyone will actually enjoy playing. Except here, you've got
something great to play, but can't actually finish/sell it.
I tried to use 3rd party credit card processing, sign with a big time
distributor, and distribute shareware/freeware. Finally I gave up and made my
own distribution company. I saw some posts on a previous IOTD that others were
similarly frustrated. If anyone wants to use our existing distribution
infrastructure to handle the legal, credit card, testing, etc. send me an
e-mail. I figure that others might have good games (you'd better be making
more interesting things than Tetris!), but don't want to deal with all of the
business side of things, so I'd be happy to distribute for some fellow
flipCoders if there is interest.
Credit for Radon to: Laura Wollstadt, Alison Veneto & Justin Miller.
-[LINK http://graphics3d.com/matrix Morgan]
[LINK mailto:matrix@alum.mit.edu matrix@alum.mit.edu]
[LINK http://morgansystems.net Morgan Systems]/[LINK http://origent.com Origent]
(L) [2000/10/28] [SimonJacoby] [templar@spray.se]
Some screens from my engine, Foo3D. It's just something i've been playing with
to learn direct3d. It's grown a bit, and now i'm thinking of doing som sort of a
adventure game.
So far:
- loads 3ds files + generates mipmaps from .bmp-files
skybox (i've borrowed the skybox textures from a skybox tutorial *sorry, i
can't remember the name of the guy who made them!*)
uses a layers to draw materials, for instance i can have a base texture, and
then an environment map, and then some other texture etc. Blending modes are
included in the layers. (So it's some sort of very crappy shader thingy)
direct3d lighting (real impressive feature, isn't it ;))
uses vertex buffers, to speed up multipass rendering, and when you have
hardware TnL
Next step is visibility culling and lightmaps (and cleaning up my shitty code
;))
I get around 150-200 fps on my Geforce2 MX and Celeron 400. (~4000 faces in
total)
/Simon Jacoby
[LINK mailto:templar@spray.se templar@spray.se]
(L) [2000/10/29] [TimothyBarnes] [God@gdnmail.net]
This is a recent screenshot of the Captured Reality Engine. The pink thing is a
test of my particle engine. There are 1000 particles in that scene. The map is a
deathmatch map that I'm still working on.
Anyway, the framerate is still somewhat low since I haven't added a BSP engine
and special collision optimizations. The particles aren't much of a slow down
though. It dropped about 5 frames using 1000 particles.
(L) [2000/10/30] [AndyLuedke] [aluedke@digipen.edu]
I'm a Senior at DigiPen Institute of Technology, and in my raytracing class I
made this raytracer. This scene file was created by my teacher, and I must say
I was a little surprised at first that my tracer could actually make it look so
wicked. I believe there are 15 lights in the scene, with the three spheres, 5
columns (made as quadrics), and the polygons. I went ahead and busted out an
image with the phong illumination and soft shadows, and here's the result. I've
been working on transmission for a day or two, but it's not really in a state to
demo yet.
BTW, with soft shadows calculated for each pixel (up to 19 shadow feelers per
reflection), max depth of 30 for reflection, and phong illumination, this took
about 8 minutes to render at 1000x1000 resolution on my P-III 650, and no, I
don't do any of the sneaky tricks for optimizing raytracing at the cost of
precision.
-Andy Luedke
[LINK mailto:aluedke@digipen.edu aluedke@digipen.edu]
(L) [2000/11/01] [AndrewWelch] [awelch123@home.com]
Not too long ago Macromedia Flash 5 came out with a new object oriented,
Java-like scripting language. A friend of mine had been doing Flash movies and
3d rendered movies and wanted to add a few games to his site for demo purposes.
These are some screenshots from his site. I coded the Pacman game for him over
about a week and a half in the evenings. Learning Flash was pretty easy because
it is so C/Java like. While "Flashman" is not meant to be an identical copy of
one of the most (if not the most) popular games on the planet... it is a pretty
good representation... and it's pretty cool to be able to play it online, right
in your browser. I modeled the AI after what information I could find on the
web about the original, and I think it generally turned out pretty good. The
other screenshots are from a version of the pacman game doctored up with new
art, and a Donkey Kong-like platform game my friend created (which is pretty
hard ;).
If you want to try these games online, you'll need the Flash 5 plugin installed.
You can get it here :
[LINK http://www.macromedia.com/shockwave/download/index.cgi?P1_Prod_Version=Flash4]
(don't ask me why the link says "Flash4" ;)
..and to play the games : [LINK http://www.misfitbeach.com]
If you have a slower computer, you might want to shrink down the size of your
browser window. The games scale automatically.. Sometimes full screen Flash
(vector) graphics can slow down.
Andrew Welch
[LINK mailto:awelch123@home.com awelch123@home.com]
(L) [2000/11/02] [JamesMatthews] [jmatthews@generation5.org]
This is a screenshot of my edge detection/prototyping program. Basically, on
the left is the originally image and on the right is an image built from
prototypes.
Prototypes are generated by the program looking at the general "features" of
the image - for example the program saw the a solid black was one of the
prominent features and assigned the colour red to those pixel groups. Look
at the black group (second from right), now notice how the left-hand wing
has a band of black down the side?
I just thought you guys might be interested in this. It is a little
different to the normal IOTDs. It "may" relate to some graphics programming
in that you can actually recreate the image (given the right number of
prototypes and prototype resolution) quite impressively by using the
prototypes. This technique can be utilized with sounds too.
I'm thinking more along the lines of making a program that looks at a lot of
pictures of terrain and the builds prototypes from that data - then you
classify some real-world data (let's say a terrain map of England) using the
prototypes and get relatively realistic results but only using perhaps 20-30
prototypes. For more details see [LINK http://www.generation5.org/vision.shtml].
- James Matthews
Generation5: [LINK http://www.generation5.org]/
"...At the forefront of Artificial Intelligence..."
(L) [2000/11/03] [TobiasJohansson] [dtz222w@tninet.se]
These are screenshots of a Quake2 level viewer I've written the past weekends.
It uses Quake2 PVS to render worlds, and it is almost identical to quake2 renderer
except for entities, warping water and dynamic lighting, which I plan to implement
sometime. I think I get pretty decent framerates out of it, 25-30 fps on a
PII-300 with ATI Rage Pro using multitexturing. There are still optimizations to be
done, like texture-sorting. It uses Direct3D for rendering.
Tobias Johansson
[LINK http://come.to/polygone]
(L) [2000/11/05] [DanRoyer] [aggravated@bigfoot.com]
This is my first attempt at Metaballs. The polygon generation code
is _evil_. Fast, but evil. The rendering logic in this version was supposed
to be faster, but isn't. That's the last time I take advice instead of just
winging it (:
This demo ran at ~30 FPS on an P500 / 256MB RAM / GeForce SDR / Win2K (sp1).
I've seen it go as high as 200 FPS.
Features:
- OGL rendering.
Keyboard/mouse controls.
User controlled camera movement.
Dynamic LOD
Wireframe, textured rendering.
Special "data visualization" rendering.
Surface polygon generation using a version of Marching Cubes.
(I implemented this + some hashing and it still ran slower than the
naive brute force, no culling, switch-with-256-cases method.)
Future plans:
- Multitexturing w/ alpha channeling for a completely unique surface texture.
"SurfCam" which moves as if walking on the surface of the metaball.
VSD and collision detection using octtrees.
Many-threaded version for multiprocessor machines?
Incorporation with my cloth, sky box/sky sphere and particle system demos to make
something _really_ nice.
(L) [2000/11/06] [Chronos] [chronos@mediaone.net]
This screenshot is of an engine I have been working on for the past 3 months.
The basis for the engine is SDL, for those looking for a fast(Unreal Tournament
for Linux uses it) way to create multi-platform applications take a look at
SDL([LINK http://www.libsdl.org www.libsdl.org]). The graphical part of the engine is written is
OpenGL(hence the same ChronosGL :))
No, the background isn't some super cool terrain engine it's just a skybox.
However, you are actually looking at a corner of the skybox. By displacing the
texture coords by very very little I managed to create a seamless 360 degree
wrap around world.
The console shown alpha blends in and has different text colors and a syntax
similar to quake3. The font was created using that handy font builder which was
mentioned on flipcode's main page.
The pink lines around the actual map represent the edges of an Octree. The
map itself is for now just textured with a simple grass texture I got from a
friend.
The 'Rain' you see is just that, rain. The lines are generated using a very
simple algo which can easily be applied to many other atmospheric/particle
effects. The rain for now is just lines but plan to expand it to a triangle
strip so it can be textured with a more realistic effect.
It's pullin 48 - 64fps On my P3 450 w/ a Viper 770(not ultra 16mb) while
running in screen res of 640x480. This is without any visibility detection.
I've also started collision detection and it seems to be going pretty well.
I am planning to make a fighting game once the engine is completed...nope not
full 3d...more like a Smash Brothers/Marvel Vs Capcom sorta game(no sprites
though :P). If you'd like more info just email me.
-Amitt 'Chronos' Mahajan
([LINK mailto:chronos@mediaone.net chronos@mediaone.net])
(L) [2000/11/08] [LukeHodorowicz] [hodorl@rpi.edu]
Here's a shot of the volumetric fog that I recently implemented in my 3D
engine. It's based on arbitrary fog volumes which are set up as a BSP model.
Fogmaps are then generated by casting rays from the viewpoint through the
BSP tree. The parts of the ray that fall into the solid parts of the BSP
tree are found, and their total distance is used with a density scalar to
compute how much fog hits a point.
More screenshots and info at [LINK http://gollum.flipcode.com]
(L) [2000/11/10] [BastianClarenbach] [b.clarenbach@ascaron.com]
These are shots from an older version of our engine, we call her Walhalla. The
shots are taken from a tech demo we made to test and demo the capabilities of
the engine. The whole scene that was created has over 150k polys and full
dynamic lighting and positioning.
- The upper left shot features a scene where a keyframed robot with about 5k polys
picks up a glowing object from a spawner and puts it into the blue ball thing
you see at the left side of the picture. The ball is transfered over objects.
The upper right shot shows a head floating over some socket thing. Our artist
created the head from a NURBS surface in MAX. The surface was then exported with
our own inhouse exporter plugin and is tesselated by the engine at load time
(including texture coordinates and correct normals). The new version will
feature Bezier surfaces.
The lower right shot is taken from the end of the demo. Our camera flies through
a scene with objects along a TCB spline path. The scene was assembled in MAX and
the splinepath was exported from MAX, too. The rune itself is created with
NURBS, like the head.
The lower left shot is another shot from the demo scene. The white square in the
corner is a false color image of the occlusion buffer we use for our culling
algo. You can clearly see the bridge and parts of the wall from the background.
You also notice that parts of the scene are not shown in the buffer, this is
because we flag objects that shall function as occluders.
Currently, we are working on a full redesign of the engine for DX8 and adding a
few features like skins and the like.
Hendrik Grüne & Bastian Clarenbach
Code & Engine Design
Ascaron GmbH
GERMANY ;)
(L) [2000/11/12] [TobiasJohansson] [dtz222w@tninet.se]
This is a picture rendered by a raytracer I wrote a few months ago.
It renders spheres, planes & cones/cylinders. Features a nice illumination model,
soft shadow and adaptive supersampling. It has pretty good material handling, you
can have a ambient, diffuse, specular and bump texture on each object.
I've written a very basic tutorial on raytracer and put it on my homepage, [LINK http://come.to/polygone]
Now I'm off to read Realistic RayTracing by Shirley, a fine book on raytracing.
Tobias Johansson
(L) [2000/11/14] [ChongJiayi] [chongjy@pacific.net.sg]
ODDSaur stands for the Opensource Digital Dinosaur Project. The aim is to
create a digital living creature that runs, breathes and exhibits all sorts
of behaviour on a personal computer. ODDSaur also demonstrates real-time
perpixel bump-mapping and software vertex blending using OpenGL. Release
1.01 of ODDSaur shows the creature striking a running pose in either
windowed or full-screen mode. Source code and the executable for 1.01 are
free for download now. Compiled in C++ for win32.
The Opensource Digital Dinosaur Project:
[LINK http://creature.sourceforge.net/default.htm]
cheers,
Chong Jiayi
(L) [2000/11/16] [DrewHester] [hestercd@alltel.net]
Drew Hester here of Max Gaming. This is a shot from a game that is
currently in the works. Critical Subterfuge is planned to be a MMPOG. We are
developing it with the LithTech engine. This is a basic shot with no real
special effects. I wanted to submit something like this to show that lighting
can make a huge difference. Although the lighting is not perfect and is still
being worked on, I can say that it is in it's final pass. The room is part of
an underground tunnel. You can see the air duct that provides air throughout
the tunnel system to players. To check out some models and other shots, go to
[LINK http://www.maxgaming.net/~critical www.maxgaming.net/~critical]
From there you can learn a little more about the
story and what not. Thanks for your time guys, check you later....
-Drew Hester
(L) [2000/11/18] [Peadar_Coyle] [Peadar_Coyle@ic24.net]
Here is a pic of a new game in early development for the PC using Open GL
so tell me what you think collision detection has been added and a few new
textures this is an Apocalypse Now! Production
not much features yet haven't decided what to use
Yours Sincerely Peadar Coyle
[LINK http://www.gameprogramming.co.uk]
[LINK http://www.peadar.ic24.net/newgames.html]
(L) [2000/11/19] [MoJo] [xycsoscyx@hotmail.com]
These are some screenshots of a QuakeII Level Viewer. It used BSP/PVS for
rendering, and included loading of textures and lightmaps. The Textures are
hashed out when rendered, and the lightmaps are scaled to 16x16 and banked onto
a 256x256 texture, and the lightmap banks are hashed when rendered, to reduce
state changes like with the textures.
Also, I have animated textures and the warp effect implemented and functional.
At the moment I am working on optimizing the code and cleaning up what I have.
I have decided to use a class structure for the entire engine, which has it's
pros and cons I have noticed.
I am also working on a game logic module, including entity parsing and spawning.
I only have a few entities implemented, BSP models, rotating functions, and
player starting locations and MD2 loading/placement. Unfortunately, I do not
have MD2 rendering implemented because I use OpenGL and Direct3D for rendering,
which means I am using a vertex array rather than per vertex rendering, and I am
trying to still take advantage of Quakes OpenGL optimizations, but still make it
ompatible with my engine. I am getting decent FPS at the moment, but I only
have a P333 and Diamond Monster Fustion (uses the Voodoo Banshee chipset). I am
also working on implementing MultiTexture support, I have it (but can't test it
because my computer doesn't support it) so I don't have it implemented into the
released engine.
Last but not least, the basic features of the engine are: Q2 BSP/PVS Rendering
with Textures/LightMap, Animated Textures, Rear View Mirror, Direct3D/OpenGL
Support, DirectInput, and a few others. At the moment I am working on, but have
not implemented collision detection, and like I mentioned, optimizations. Also,
one problem I am having is that first, Quake uses the Z Axis as the horizontal
axis, (which isn't difficult to deal with) but mostly that it also seems to
have everthing 100 times larger, and I have to scale everthing by 1/100 to make
it look right, and i hate doing this because I am losing a lot of precision and
it just takes that much extrawork to load and display, if anyone can help me,
pleaz do! :-)
You can download the source code at [LINK http://www.geocities.com/~xycsoscyx/]
(L) [2000/11/20] [JanDohl] [jdohl@hotmail.com]
here's my entry for the Screenshot of the day. It shows the showing-part of
my experimental particle system at work. The showed effect is a fire effect
with distraction to the lower right corner and some flight-range overgrowth
so that it looks little more chaotic ;).
Some words about the program itself: It currently consists of 2 parts. The
creator and the shower. I divided this cause the creator uses MFC and I
guess performance would be much lower if I had implemented the shower also
into that. The particle system has following features:
- unlimited amount of particles (ok, limited by performance ;)
100 color-steps per particle (you won't need more, believe me)
Horizontal and vertical distraction
Flight-range overgrowth
Up to 10 gravity points with pos/neg gravity (easily extendable, but it's
unlikely that you'll need all 10 and more)
The rendering is an additive effect that makes everything a little more
interesting because some cool effects were caused that weren't originally
planned (But it's cool to have them ;). Well, in the shower module you can
move the particle spawning point around and so cause fire-trails a.s.o. The
only serious use I can now think of is testing particle effects before
implementing them. Apart from that it's a nice toy and fine to look at
*hopefully*.
And that's it. If you know an effect that I could implement, don't hesitate
to post it here or to drop me a mail. BTW: All other mails like questions,
suggestions, flames a.s.o. are also welcome. Send 'em to: jdohl@hotmail.com
Ok, hopefully my English wasn't too bad at all ;).
--- Polygon ---
(L) [2000/11/22] [chohanbeen] [jindo3d@dreamexe.co.kr]
concept of complex character animation spec is designed in earily days in this year,
I have just finished modeling and programming it. 3D model has 1505 vertex 2581 face,
and use motion capure data via 3DS MAX.
refer to left,leftup,leftdown image in 3D MAX ,and right dowm image in jindo3D.
eyelid eyeball,eyebrows moving and lipsynk,finger,Linked item is enable.
Compiled in C++ for win32.
more scren shot of this or jindo3d just refer to [LINK http://jindo3d.dreamexe.co.kr]
(L) [2000/11/25] [JeffGutierrez] [bytor@cfl.rr.com]
This is a screenshot of a 3D object editor I'm writing, no official name
yet, so far I've just decided to call it "thingy". I took a shot in
wireframe mode because the current default textures are kind of crappy, but
that will hopefully improve soon. You can also see one of my translucent
dialog windows( ooohh eye candy...) open in the foreground.
Jeff Gutierrez
[LINK mailto:bytor@cfl.rr.com bytor@cfl.rr.com]
(L) [2000/11/27] [MartinStich] [mstich@primusnetz.de]
These are a few shots of the game we are currently developing, called tank2.
It's (self-written) engine features outdoor terrain rendering, Quake2 models,
x-models, decals, smooth day/night cycling, 3d and 2d particles, dynamic
lighting, a console, multiplayer support, and a few more things. Collision
detection, multiplayer, weapons and all that is already implemented. What's
missing is the implementation of the game rules, death and respawn code etc.
We are currently thinking about porting it to DX8 (right now it's DX7), but that
would take great effort, so I was wondering what you guys
think - is it worth the pain ? ;)
More screenshots can be found on [LINK http://tank2.primusnetz.de]. Please tell us what
you think!
Sincerely,
Martin, Michael
(L) [2000/11/29] [AndreasGustafsson] [sdw@lysator.liu.se]
This is my first IOTD, it's nothing special, just a couple of
screenshots from some of my small OpenGL programs.
The reason I submitted this is that I have just put together a little
webpage where all the OpenGL effects that I have entered into
competitions like the Flipcode Coding Contest and the OpenGL challenge
can be downloaded.
Most of the programs include sourecode, but I wouldn't recommend that
anyone actually try to learn something from it, since my code isn't
all that well-written or commented :)
Anyway, you can check it out at :
[LINK http://www.lysator.liu.se/~sdw/opengl/]
(L) [2000/11/30] [AndrewHarvey] [a_j_harvey@hotmail.com]
This is my entry for the OpenGL Challenge, Gears Challenge.
I tried to come up with something original and eye catching, with
TnL friendly ("clean") OpenGL.
The oglchallenge website seems to be down (?), so "oh well maybe next time".
Some of the code is messy, with plenty of magic numbers.
Some of the code is (IMO) nice & clean.
Comments are for quiche-eaters (Mmmm... quiche).
Download:
[LINK http://www.users.bigpond.com/a_j_harvey/gears/gears.zip] (193Kb)
[LINK http://www.users.bigpond.com/a_j_harvey/gears/gears_src.zip] (75Kb)
Features:
- Display lists (see Note).
Fast, fake env-mapping using texture matrix.
Fast, fake Phong shading with env-mapping.
Interesting blend mode glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA).
It doesn't saturate as quickly as GL_ONE/GL_ONE.
To be honest, its not much different to GL_ONE/GL_ONE at all :)
Skydome stars.
Billboard particles.
They really chew fillrate.
100% procedurally generated meshes & textures.
Exe is only 61Kb without C Runtime.
* Note:
I'm using glGetFloatv(GL_MODELVIEW_MATRIX) several times per frame.
This won't be TnL friendly unless the driver keeps a matrix stack in
software. If the driver didn't maintain a software stack, it would
be very easy for the app to do this.
Andrew Harvey
[LINK http://www.users.bigpond.com/a_j_harvey]
[LINK mailto:a_j_harvey@hotmail.com a_j_harvey@hotmail.com]
(L) [2000/12/02] [UthmanApatira] [wiz3d@home.com]
Hello! This screen shoot is the output from my software encoded TDK
(texture dither kernel) which I am implementing into my 3D OpenGL Engine for use
with an upcoming fighting game- ApatiraFo. You might wonder why I donÂt just use
OpenGLÂs blending capabilities. Well, I have been looking into the speedups of
many popular console games and have decided that if I used 256 colored bitmaps,
my game/engine runs a hellofalot faster. If I just used OpenGL, I ended up getting
crude blocky images, soÂ
.. I used a _quick_ TDK software filter pass right when I
loaded up my textures to convert my nice 32bpp art to the 256bpp substitute my engine
uses and I must say, the results were quite impressive. ;). After I post an image of
another cool speedup that I have been working on, IÂll post an image of the results
of this TDK running in place with a sample ApatiraFo session in Acton.
(L) [2000/12/03] [JonCreighton] [jon@creighton.com]
Here is a image from the game I am currently developing, 'Wolf'. It shows
off a few of the features of the rendering engine.
The landscape uses an adaptive quadtree both for storage and progressive
mesh rendering, with multitexturing to add detail and shadow maps. This
allows a massive area to be stored and effectively rendered. It also
supports wrapping to extend the terrain indefinately.
The sky is a series of domes, with the texture coordinates of cloud layers
distorted to appear flat. The cloud layers move across each other at
different speeds to give variety to the formations.
The geese, trees and footprints (that are just visible in the foreground)
are rendered using an adaptive quadtree which manages all the visibility,
level-of-detail and culling.
The geese themselves fly around using flocking rules to maintain their
formations. It's very cool just to follow them around, and they're easier
to take care of than real animals.
The image was captured on a Celeron 366 machine with a GeForce2 MX card
running under DirectX 8.
For more information about the project, have a look at my web site at:
[LINK http://jon.creighton.com]
(L) [2000/12/05] [JonOlavBjorndal] [jon.olav.bjorndal@susoft.no]
This is an image from my OpenGL demo called "LadyDeath and the Light
Sources of Doom", or just "LightDemo" for short.
It is a windowed standard OpenGL application. No DirectX or extensions
involved.
Main feature is shadow volumes for global shadows using stencil buffer.
Other than that
relatively straight forward OpenGL lighting. Draws whole scene several
times for each
light source and uses blending to combine the results of each pass.
No rough culling is involved. Only Z buffer. If used in a larger scene an
additional
rough culling algo would be needed.
Editor's Note: Download the demo + source code here: [LINK ftp://ftp.flipcode.com/code/effects/LightDemo.zip LightDemo.zip] (428k)
(L) [2000/12/06] [JohanGlysing] [mace2@home.se]
This is a screenshot collection from Dizzlogic´s (our)
fresh demo called Imagine. We coded it for a demo contest
at Dreamhack which is Swedens biggest demoparty where all
the cool coders come once a year to compete in the contests
and drink Jolt (n' vodka) until they throw up :)
The top left image is the "jiggly tunnel" and the one next
to it is a antimagneticdistortionsomething effect on a
cube, works like a more dynamic "spherify" tool in 3d
studio. ;)
There are some other cool stuff in it as well such as
particle systems, undescribeable mesh-triangle thingee++
and of course my old submission to the flipcode contest
called "fog".
A demo will be downloadable at [LINK http://www.dreamhack.org www.dreamhack.org] very soon
so try it out. This demo was done faster than lightspeed
and quick n dirty code in the final version. :)
Demo by Dizzlogic
Code: Mace & Volantiz
Gfx: Jewelaye, miffo & Volantiz
Music: Volantiz
Hope you like it
/Mace, Volantiz
(L) [2000/12/07] [PierreRenaux] [prenaux@yucom.be]
This geiss effect is just a variant of the classical fire effect. It's very easy to create,
you can check out the source code on my web site [LINK http://www.Alias25.com www.Alias25.com].
If you want more details about it, just ask me =)
(L) [2000/12/08] [DominicMorris] [dominic.morris@ideashed.com]
Here's some screenshots of my submission for Milia. You can download the EXE
from
[LINK http://freespace.virgin.net/richard.morris5/Download.htm]
Following up on some criticisms from my last IOTD, this EXE is hopefully a
lot more robust! ;-) I've also added computer-controlled players, a 2-player
LAN option and 3 soundtracks. The race track is procedurally-generated and
can take some time on slower CPUs. Also, collision-detection runs pretty
slowly on anything less than a P3-class CPU. The game will default to FSAA
if available... oh, and it'll also keep track of your best lap-time in the
registry!
Next up is gonna be some nice eye-candy mountains, so I'm on the hunt for
the DX terrain-algo. code, if anyone can help..., more tracks, and a
'mouse-look' type thing for more accurate shooting.
I hope you enjoy it!
d
(L) [2000/12/09] [JesseLaeuchli] [jesse@laeuchli.com]
Just a small screen shot for my terrian renderer ([LINK http://www.laeuchli.com/jesse www.laeuchli.com/jesse]).
(L) [2000/12/10] [JoakimHårsman] [harsman@hem.passagen.se]
This is a shot from the latest version of my cloth simulation, based on
spring dynamics. There's air resistance and wind (that's why it's
billowing so beatifully :-) ) and decent friction. Oh and ignore the 9.6
fps in the titlebar that's just my timer that's confused since I paused
the sim for the shot. The sim can be downloaded from:
[LINK http://hem.passagen.se/harsman/index.html]
Joakim hårsman
(L) [2000/12/12] [RobertClemens] [Moonbytestudios@aol.com]
Those 5 screenshots show our action racing game 'Crashday'. We're developing
on the DirectX version for about half a year and now the first graphics can
be shown to you :). Crashday will be a crash'n'stunt game like Carmageddon,
however a main part of our game is the powerful track editor (like once in
"4D Stunts")
The screenshots show some of the cars (only one is already textured) and in
the background you can see the first track objects (set randomly :))
On the centered picture the "evening" ambience is activated, the upper left
and lower right ones use the standard "day" ambience. In the upper right
corner you can see a loop in our texturizing tool. (All of our textures are
hi-res and photographed by ourself.)
Finally the lower left shot shows our rendered title picture.
More infos or screenshots you can get on our website [LINK http://www.moonbyte.de]
(L) [2000/12/14] [JakeWolf] [cleverdesign@home.com]
Here's a shot of a space simulator I am working on. It started out as a project
to help me learn OpenGL (already knew DirectX) and it's slowly evolving to a
space simulator.
Here are some of the features already available:
- Starfield and sun that can be randomly generated or loaded from a file.
Lighting and blending effects that simulate lighting.
Lens flare (still working on "pretty-ing" this one up).
Level of detail. Planets use less polygons when far.
Fog, to simulate the darkness of space. So that planets gradually come into
view when approaching them.
Features to come:
- Dynamic parametric clouds (to simulate gaseous planets like Saturn)
A heightmap for solid planets. this way, you'll be able to land or hover on a
planets surface. Possibly mix that with a parametric approach to get a better
LOD without immense heightmaps. (Anyone has tips or leads on this one? send me
an email).
thought about bumpmaps but my card does not support them, they kill my FPS.
3ds or mesh file loader so I can add some spaceships to this mess.
Right now though, I am busy cleaning my code and making it modular. The demo
runs on a P2 333 with a Riva TNT2 16MB at a speed of 30 to 60 FPS (depending of
the features switched on). Also, I would like to take this opportunity to thank
the folks at opengl.org Discussion forum for helping me out and answering my
questions, especially "Punchey" and "dmy". And of course, flipcode.com for a
kick @ss site.
Thanks,
Jake Wolf
CleverEntertainment
(L) [2000/12/15] [stil] [stil@ilovewarp.org]
I did some metaballs with cartoon rendering the other day and just wanted to
show it.
One screenshot is with "normal" metas, the other with cartoon rendering.
It does a "motion blur" onto the grid and err... just download the exe and
the source code at [LINK http://www.neuromatrice.net/kindness/meta-stil.zip] (60kb,
opengl).
I used dake's great tutorial (in french).
see you
(L) [2000/12/16] [HenryLudemann] [henryludemann@hotmail.com]
These are a few shots from a landscape game I am putting together.
It has a quadtree type map, multiple cloud levels, basic collision detection
(very), and some simple game aspects (shoot the landscape). I am starting a map
renderer rewrite which could take a while, so I am submitting an image first...
The skybox has been done a bit differently to what I have seen before. It
doesn't draw fixed world point triangles, but rather draws a fixed grid on the
screen, and from each point casts out a ray to see where it hits the cloud
layer. From this point is derived a texture coordinate. This has the advantage
that the cloud doesn't finish at the horizon, but has a few disadvantages as
well (slow routine to find intersection of sphere).
You can download it at [LINK http://web.one.net.au/~ludemann8 web.one.net.au/~ludemann8]. (If you do, have a look at the
sun shining though the clouds). Running on my k6-2 500 with a banshee, it goes
at around 30fps, but will eventually be made to go much faster.
Henry Ludemann
[LINK mailto:henryludemann@hotmail.com henryludemann@hotmail.com]
(L) [2000/12/17] [LauriKoponen] [ld0d@kolumbus.fi]
Most of the images here seem to be from 3D-engines or 3D-games, so here's a
shot from a game I created with a friend of mine about two years ago,
Ufogame. Yes, it's quite old but it hasn't lost any of it's glitter!
Basically, it's a paratroopers-clone, and.. well, not much else :) But try
it for yourself, [LINK http://www.kolumbus.fi/ld0d/stuff/ufogame1.zip]. The reason
why I wanted to show this is because we're working on a new (Windows-,
perhaps even Linux-) version of ufogame and it's going to rock ;)
You'll have to find DOS4GW.EXE somewhere if you want to try the game. It
runs fine under Windows95/98 but I couldn't get it to run under Win2k.
Perhaps it's because I'm using MIDAS, who knows. And don't run it under pure
DOS without a mouse driver loaded, it won't work too well :) It's a beta
anyway... and it'll probably crash after a few games.
There is no documentation in that zip, use arrow keys to turn the cannon and
space to shoot.. Simple.
I have some other screenshots from my misc. demoeffects at
[LINK http://www.kolumbus.fi/ld0d/stuff/] and even my Assembly'2k 64k intro (I
placed 3rd! whee!) is there.
- ld0d
(L) [2000/12/19] [SebastianSylvan] [sebastian.sylvan@spray.se]
Here's a pic of Concept Art modelled into existance.
You might recall the concept art of Alan 'Riot' Shafer from our game Reason Run
Riot (here's a [LINK http://www.flipcode.com/cgi-bin/msg.cgi?showThread=10-17-2000&forum=iotd&id=-1 link])
that we posted here a couple of weeks ago, well this is what our excellent
modeller Joey Davis created with them.
Check out the site too, there's some more stuff there, like a downloadable mp3
sample of the soundtrack.
[LINK http://www.reasonrunriot.cjb.net]
Sebastian Sylvan
(L) [2000/12/20] [RobinHåkanson] [skede@algonet.se]
Here are som screenshots from my TI-82 demo IMATION released during
Dreamhack00. It has som nice parts, faked grayscale (LCD screen's has
low refresh rate ;) ), tunnels and other stuff that you normaly find in
standard PC demos. For all you pepople out there that have you own TI-82
calculator you can download the demo from [LINK http://www.algonet.se/~skede/flum.82p www.algonet.se/~skede/flum.82p]. You will need
CRash to run it (if you don't already have it you can find it somewhere
on [LINK http://www.ticalc.org www.ticalc.org]). There is also an MPG version of the demo for all you
poor fellows that don't have an as kicking TI-82 calculator, it's
lokated on [LINK ftp://ftp.dreamhack.org/pub/dh00/compos/Oldskool/Imation.mpg]. If anyone is intrested in coding TI-82 and Z80 processors i
have wrote some artikels about it on [LINK http://www.planetzeus.net www.planetzeus.net] (it's pretty
good if you know swedish because the artikels seamse to be written in
that wierd language ;) ).
/Robin Håkanson
(L) [2000/12/21] [OhadEderPressman] [eder@bigfoot.com]
I saw the WinCE Lemmings shot, its cool, but we mustn't leave Palm behind :)
Attached is a screen made of 6 shots from different apps we've written for the
palm platform
- 2D Sierpinski
3D Sierpinski
CFXWeb Palm-Intro
Color Mandelbrot generator
Life
Checkers (the only commercial one)
Palm uses a fixed 160x160 resolution with LCDs' varying from 1bpp b/w, 4bpp
greyscale, 8bpp paletted mode and recently 16bpp hi-color (Visor-Prism). It uses
a Motorola 68k processor at speed ranging from 16mhz to 33mhz which is nice
except for the byte-ordering.
---
Ohad Eder Pressman
IMR
(L) [2000/12/23] [NeilMarshall] [neil.marshall@sympatico.ca]
I thought I'd tease people with my first shot at a 3dsmax plugin. It
exports from 3dsmax directly to the Crystal Space world format. Sorry
no code is available for download :(
Currently there are quite a few bugs/limitations which I'll hopefully
add in the coming days. Right now, none of the textures are exported.
I export omni lights, sectors, and things (For people who know how
crystal space works). So far I've run into a couple problems. Naimly,
Y and Z are different from Y and Z in Crystal Space, so everything came
in sideways. Also, I have 3ds max setup to work in mm and crystal space
works in m by default, so everything gets exploded to monsterous
proportions :)
-Neil Marshall a.k.a WillyWonka
(L) [2000/12/24] [TimC.Schröder] [tcs_web@gmx.de]
Here you see a few screenhots of my new terrain engine. The upper left picture
shows the detail texturing and the sun. You can see the glitch where the sun's
flare shines trough the mountain. Thanks to the Octree and my triangle class,
this problem is gone now. On the right side you can see the Octree, red nodes
contain more triangles. The pics in the middle show various heightmaps. I think
you can see how nicely the procdedural generated texture looks. In the
lower-left corner are some screenhots of early version of the engine. The last
pic is a water-only view. The cubic environment mapped water looks so cool that
I think it deserves its own picture ;-) I hope you enjoyed the view. If you want
further informations and want to download source & exe (when it's released ;-(
), visit my homepage [LINK http://glvelocity.gamedev.net] . Some of the source that was
used to create the engine is already in my code archive. I also would like to
hear a few ideas on what to include into the engine. I'm currently thinking of
some kind of algorithm that removes occluded montains. I also want to do
lensflares and a moving cloud layer. Bird, butterflies, fishes and trees would
also be cool. Oh, and underwater fog and rain and... Way to much...
Tim C. Schröder
(L) [2000/12/29] [SaadFaisal] [saad_faisal@c4.com]
Here is my contribution to Image of the Day. This is the game that i developed
in 1997 as my Final year project for my BCS. The lower right screen shot is of
editor that i developed for the game. You can download it from
"[LINK http://www.download.com www.download.com]" and search for "Mahafiz". It's a preety small file 394K self
extracting zipped. The editor is a seperate program and is there in the archive.
The artwork is from the famous Sprite Library from Ari Feldman and the level
design was done by my batch mate Akhlaq Ahmed.
(L) [2000/12/30] [MarcoKögler] [koegler@uni-koblenz.de]
Here's my little contribution to the IOTD gallery. I just saw another teapot
IOTD and thought I would add mine to the list. The screenshot is from a program
I wrote for a university project. The project was about interactively rendering
bezier surfaces with OpenGL. You can load up models, select patches, play with
the control points of the patch (the blue boxes) and see how the objects shape
changes. The goal of the program was to visualize some basic properties of
(cubic) Bezier surfaces. This was my very first attempt at using the MFC and I
was quite pleased with the results, although using MFC is a pain in the ass.
Anyways, from a technical side the program still has a bunch of shortfalls. For
example, it doesn't care about preserving continuity at the seams of patches and
it only uses a recursive subdivision algorithm for rendering (far from optimal
regarding speed). One of the better ideas I implemented was scaling the level of
subdivision down when the user wants to interact with the selected surface. The
proggy tries to maintain at least 15 FPS. In essence, a very crude form of LOD.
Oh maybe a short description of what you see ... the red patch of the teapot is
the selected patch, the yellow transparent thing is its control point net. The
rest should be pretty self-explanatory.
- Marco Kögler (MK42)
(L) [2001/01/01] [M.Knuth] [knuth@rbg.informatik.tu-darmstadt.de]
I'm working on my engine again. I've updated my sky-rendering-engine, so I can
render different times on a day continuosly (I set the position of the sun and
ist does the rest). The new thing is the cloud renderer. It renders Clouds in
dependency of time (The Clouds change over the time)
The next think will be an CSG-performer,(I hope I can create buildungs again ,
soon)
wbr.
M.Knuth
(L) [2001/01/02] [NateMiller] [nkmiller@calpoly.edu]
This is a screenshot of the bezier patch editor that I have been working on
in my spare time. It isn't anything great, but it has been fun to work on
so far. The screenshot shows the layout of the editor as well as a teacup
made up of 26 patches. I didn't create the teacup, I found it on the net
and use it for testing.
Right now the editor can create / delete patches (quadratic or cubic),
translate / rotate control points, load / save the models you make and other
miscellaneous editing features. Once the base features of the editor are
done I plan on adding more to it. I am using FLTK (http://www.fltk.org) for
the GUI elements and OpenGL to render the edit and 3D views. Source code
for the editor will be available once I get more done since one of my main
goals is to get the editor running on as many platforms as possible.
If you are interested in more images of the editor they can be found here :
[LINK http://nate.scuzzy.net/pedit/]
Nate Miller
[LINK mailto:nkmiller@calpoly.edu nkmiller@calpoly.edu]
[LINK http://nate.scuzzy.net]
(L) [2001/01/04] [GiulianoCornacchiola] [Giuliano.Cornacchiola@mbi.mercedes-benz.com]
HI!
This image is been made by Now3D...a 3DEngine written in VisualBasic6 (no DirectX or OpenGL).
Bye! Bye!
Now3D : [LINK http://www.now3d.net]
(L) [2001/01/06] [Jean-FrancoisDube] [jfdube@ubisoft.qc.ca]
Hi, this is a little software engine I did in my vacation week (entirly from
scratch). Here are the software rasterizer features:
- subpixel and subtexel accuracy
perspective correct texture mapping (every 16 pixels)
linear rgba vertex color interpolation
environment bump mapping à la G400 & use the same bumpmap format (DUDV88).
You can download the demos at [LINK http://pages.infinit.net/deks2000]. To run
bumptest your desktop must be in 16 bits, and to run bumptest2 your desktop
must be in 32 bits.
Enjoy.
(L) [2001/01/09] [HelgeFoerster] [helge.foerster@activezone.org]
this is a screenshot taken from my current project JPCT, a 3d engine for
Java.
It requires Java 1.1 or higher and makes no use of the Java3D Api.
Everything
is done using software rendering. An online (applet) version of the engine
(limited features
because of loading time) can be found at [LINK http://fr.activezone.org]. The more
advanced
application/offline version can be downloaded from there. The image was
taken from
the application version.
JPCT features:
- perspective correct texture-mapping with 16 pixel scanline-subdivision
environment-mapping
environmental mapped bump mapping
sub-pixel and sub-texel accuracy
24 bit RGB perspective correct Gouraud-shading
24 bit textures and framebuffer
32 bit W-Buffer
texel-filtering (faked bilinear filtering)
any texture-size supported (256*256 used in the demo)
FSAA using 2x2 oversampling
portal rendering
collision detection
Best regards,
Helge Foerster
(L) [2001/01/10] [Mox] [mox@mercurial-studios.com]
This is a pair of images taken from our latest game demo. You can see the
multi-textured landscape, the special effect materials and some particle
effects in these screen shots; the demo itself shows off the unit AI and, of
course, the physical simulation routines. You can get the demo from our web
site, [LINK http://www.mercurial-studios.com www.mercurial-studios.com]
yours,
Mox.
(L) [2001/01/15] [MarcSchneider] [m.schneider@bally-wulff.de]
The image shows the 3D-Portal-Engine for OpenGL.
You see a 3DS mesh which is animated through a VUE
animation file ( 3D Studio MAX format ! ). You can walk through
the level and see how the portals are working.
[LINK http://www.crazypixels.com]
(L) [2001/01/17] [KarpatiIstvan] [karpati@pannonline.hu]
This is a Jelly Cube.
I used some code from [LINK http://freespace.virgin.net/hugo.elias].
It's using OpenGL for rendering.
It's a screensaver.
You can download it from [LINK http://www.ifdef.hu/files/JellyCube-v1.0.zip].
Hardware accelerated OpenGL rendering is hardly recommended.
(L) [2001/01/19] [Klaudius] [klaudius@free.fr]
Aquasub an old playable demo in found recently in my 'dusty archive'.
All is 'soft rendered' and was programmed when no 3D hardware was really available.
In this demo you can control a fururistic submarine engine or a dolphin.
This demo was programmed with Watcom C and an old version of DirectDraw.
All 3D is computed with 'old style' fixed point integer method. This was a first test for 3D sinus animation and motion blending (see the dolphin).
Triangles display is programmed with assembly and 'quickly' optimized for pentiun UV pipe (please don't write me to
explain me how to win 1 more cycle...). It was a really laborious way of displaying...
Demo and source code are provided 'as is' and can be used for non commercial usage (who could win money with that ?).
(Editor's Note - The demo is available here: [LINK http://klaudius.free.fr])
If you see some cube on the ground, you can try to push them...
some problems can occurs on Win2000
KEYS :
- F1 : test of display box
F2 : statistics on/off
F3 : change display type (solid, wire, flat...)
F5 : "Half line" render
F6 : control AQUASUB ENGINE / DOLPHIN
CONTROLS OF DOLPHIN :
- LEFT RIGHT
UP DOWN
SPACE : ACCELERATE
CONTROLS OF AQUASUB ENGINE :
- LEFT and RIGHT :
UP and DOWN + and - for increase and decrease speed.
SPACE : fire !
Have fun with coding.
(L) [2001/01/21] [ThomasMathys] [mathys_aka_scratchy@bluewin.ch]
this is a little screenshot of the texture generator i coded recently.
it's mainly intended to generate textures for intros. at the moment
the code is 4900 and some bytes big (unpacked). not bad, i think :)
well, i guess i should now either write an editor or at least some
kind of program that translates human readable descriptions of the
textures into the byte code for the generator...
thomas mathys
(L) [2001/01/23] [MichaelBlack] [mblack@tornspace.com]
Today's "Blob Map" made me search through my Way Back files for this little
guy. It's a program that I onced used to genereate political boundaries for
a map after the terrain was generated.
The black area in this shot is a bay or an ocean and the colors are
countries or territories.
The source code is in MFC and is very simple (probably 100 lines). If
anyone would like to see it, I can put up a link.
-Michael Black
(L) [2001/01/25] [LukeHodorowicz] [gollum@flipcode.com]
Recently I completed my 3D game engine, and I'm now working on making a racing
game with it. It's going to feature racing, arena matches, powerups, weapons,
and all the fun stuff thats in futuristic racing games.
More shots of the game and engine at [LINK http://gollum.flipcode.com gollum.flipcode.com]
(L) [2001/01/28] [ChadSterling] [chads@firetoads.com]
This screenshot was take from a demo program I whipped up. It's just a rotating solar system, the geo-sphere's
geomorph from detail level to detail level.(best seen on slower computer) It uses a recursive structure to pregenerate
the level's of subdivision for the geo-sphere's. Subdivision is done in the way discussed in the OpenGL programmers
guide. I'm not exactly sure if there's a real practical use for this demo but if you like this screenshot or have gotten
an idea from it please make a post to Flipcode and we can all figure out where the geomorphing geo-sphere's are going.
the demo and source can be downloaded at [LINK http://www.firetoads.com www.firetoads.com] under the coding section.
(L) [2001/01/29] [LeeMazurek] [lee@mazurek.net]
Here is a picture of an old project I was working on. Its nothing
spectacular today, but it was pretty good at the time. I decided that I
should show it to the outside world even though it was obsolete before
completion (finished about 97).
I was developing a technique to display heightmapped quads without a
z-buffer. If optimized correctly, I could have made it just as fast as my
ordinary textured polygon renderer.
The procedure goes something like this -
I divide the cube along its quadrants (sections sliced perpendicular to x
and y axis). There are four different quadrants that parts of the cube
could be in. This is important for the drawing order. The top left is
draw from left to right top to down, etc.
I computed how often to sample the texture and heightmap based on the
number of pixels for each side. It is sampled in a regular rectangular
array( not scanlines, I tried those and it causes visual anomalies) This is
a step that can save time. The polygon can be sampled every five
pixels, and each of the resulting points can be connected. These can be
filled with a single color. In this way, heightmap complexity can be
traded for texture complexity using a consistent amount of time.
(L) [2001/01/31] [YannickSuter] [ys@visualight.com]
Recently I found these pictures of my raytracer I've programmed with Watcom
C++ for DOS three years ago. As I moved to win32/MFC programming I forgot
the sourcecodes somewhere on a backup cdrom. Actually the code was quite
well structured and the engine could handle some nice features:
- 3DS loader with multiple Objects and Lights handling
optimized ray-castings with dynamic boundary-spheres
all these material properties like specular/diffuse etc levels
supersampling
reflections/refractions
texture- and bump-mapping
keyframing for objects/lights/camera -> I saved every single frame and
compiled them into a *.FLI file
notes to the pictures
big one:
one of my favourite pictures showing some colourful/antialiased mushrooms.
It took quite a lot of time to raytrace this scene. =)
little pictures from left to right:
1. This picture shows the boundary-spheres used to optimize the trace-time
and you see quite well, that the mushrooms are splitted into subobjects.
2. Just another mushroom-pic - in a way I like the cold and clean feel of
this one.
3. Here you see a selfmade 3D character originally made for a demo, which
unfortunatly never has been finished. It had quite a lot of subobjects and
was fully texture-mapped. Again with some psychic omni-lights.
4. Another test-scene featuring some antic stones. I remember testing here
some material properties..
In the Image Of The Day Gallery I saw some other raytraced pictures. Hey,
great work and keep on programming!
Yannick Suter
(L) [2001/02/01] [[MoW]-=Comanche=-] [comanche@mow-clan.de]
This screenshot was taken from my new Voxel based 2.5D Voxel Engine (I call
it 2.5D because it's not truly 3D). The Rendering Algorithm is coded in
Assembler, so I get a very good scrolling speed on my Athlon 500. The
Landscape is Gourand shaded and 32-bit.
I'm only 16 years old so this is my first try in programming such a huge
thing. I hope you'll like it.
Do somebody have a idea how to render transparent liquids in that trench?
All my Alpha-Blending stuff is very slow.
If you like it please give me feedback to: [LINK mailto:comanche@mow-clan.de comanche@mow-clan.de]
(L) [2001/02/02] [MorganMcGuire] [morgan3d@yahoo.com]
Here are four images created by Evolver, an image/animation generating program
I recently finished. Evolver uses genetic algorithms evolve combinations
programs in an image processing language. Images, Java source code, and
documentation at [LINK http://www.cs.brown.edu/people/morgan/evolver/index.html].
The source contains nice implementations of common effects like Gaussian blur,
particle system, zoom, rotation, distortion, environment mapping, and edge
filter, as well as an entire interpretted programming language framework and
genetic algorithm implementation. The paper explains how it works in detail.
[LINK http://graphics3d.com/matrix Morgan] [LINK mailto:matrix@graphics3d.com matrix@graphics3d.com]
(L) [2001/02/04] [MicahCox] [micah_cox@softhome.net]
This shot shows my Dynamic Level Of Detail demo. The image marked number 1
is the model at it's full detail level, and as you can see the polycount
decreases as you progress to the higher numbers. The method I used to
implement it was in the November '98 issue of Game Developer Magazine but
the author of the article has posted it on his website
<[LINK http://www.cs.ualberta.ca/~melax/polychop/]> as well as some demos. The
article describes a very simple method of calculating the edge collapses and
then reordering the vertex list based on which costs the least amount to
collapse. It only took me about three days to write the demo.
Micah Cox
(L) [2001/02/06] [PierreTerdiman] [p.terdiman@wanadoo.fr]
Hi there Flipcoders,
My IOTD from September, 17, 2000 featured old ICE snapshots. Here are brand new
ones.
- The first row shows 3 pics from a Quake-like world. No special features there,
just the engine warming up.
- The two first pics from the second row show the rigid body simulator in
action. That one is currently simple, using convex polytopes only and shameful
penalty methods. Anisotropic lighting and shadow volumes make the first snapshot
more attractive. On the second one nonetheless, you can notice the nice trails
showing the path of one of the cube's vertex. The first version (not the best, I
must update that zip) is still available here:
[LINK http://www.codercorner.com/Rigid.htm]
- The third row begins with a purely eye-candy effect: realtime glow. On the
left you can see a dynamic procedural texture (Perlin turbulence), used on the
right to make the glow nicer. To do this I just compute the silhouette of the
cylinder (using the same code as for shadow volumes) then extrude it in a radial
way. Dumb, looks nice, what the hell ?
- The bumpy sphere is a test of displaced subdivision surfaces, as presented by
Hugues Hoppe (SIGGRAPH2000) and Tom Forsyth (WGDC2000). I use the Butterfly
scheme, even if this is useless here. The displacement map is a simple noise
map. Don't miss Tom's presentation, here:
[LINK http://www.muckyfoot.com/downloads/tom.html]
- Last but not least, the lady is an attempt to mix several techniques together:
skinning, progressive meshes, subdivision surfaces, IK, cloth and hair
simulation and cool shaders. Coding those techniques separately is not "too
difficult", but actually making them work together can be *very* painful... Work
in progress. There's about 200.000 faces in the model, which explains the
somewhat low framerate (on a Celeron 500Mhz + GeForce) .... You can also have a
closer look there: [LINK http://www.codercorner.com/NextGen.jpg]
As always, everything was exported from MAX with Flexporter
([LINK http://www.codercorner.com/Flexporter.htm])
Pierre
(L) [2001/02/07] [JordanMaynard] [maynard@rohan.sdsu.edu]
Here is a screen shot of a program I wrote for an OpenGL class at San Diego
State University. The terrain shown is actually a representation of the
real terrain near the university. The elevation data was taken from USGS
.DEM files and then textured with actual aerial photographs (not satellite)
of the same region. The hardest part of the whole thing was getting the
textures to line up with the elevation data - some of them had to be
tweaked/skewed/stretched in an image manipulation program to more
accurately line up with the elevations. In the top left picture you see
Cowles Mt as seen from the north (in Santee), with Mission Gorge Rd. The
bottom left picture is Highway 8 as seen from above, with San Diego State
off to the right (you can just make out the track and field) The overpass
in the center is College Ave. The bottom right picture shows the entire
region (elevation exaggerated, no fog) and in it you can see Cowles Mt.,
Highway 8, and Lake Murray. I sent this screenshot to a few local pilots
and gotten good reactions from them. Hope you all like it. : )
Any questions about it can be directed to [LINK mailto:maynard@rohan.sdsu.edu maynard@rohan.sdsu.edu] (though
I'm not sure how long the account will remain active now that I've
graduated...)
(L) [2001/02/08] [JoachimHofer] [Joachim.Hofer@t-online.de]
Not long ago I thought it would be cool to have materials that partially look
metal and partially not.
I thought that the best way to do this is to use inhomogenous specular
highlighting. This can simply be done by using two textures, one with the metal
parts white and one with dark metal parts. And then I use the specular light to
blend between the two textures. This is really fast on a board that supports
multitexturing, and for the little effort it requires, I think it looks quite
good. I haven´t seen this anywhere so far, so I just thought about posting it
here. Maybe you can even use this technique for any game. A car with such a
texture might look good, I think...
You may download this program at [LINK http://www.crowsoft.de] in the download section
(Be sure to get DirectX 8 first...) It´s rather slow as it draws the stones
two-pass as my graphics card doesn´t support multi-texturing, and so I can´t
test one-pass. It also doesn´t support T&L and for sure contains many bugs.
Enjoy it ;-)
(L) [2001/02/09] [PhilCarlisle] [pc@team17.com]
Myself and Alex C. have this little thing going about landscapes and ROAM
and what have you. So I thought I'd submit an early test shot of a
landscape system I am playing with as part of my landscape adventures :)
My contention was, that texture and lighting are ALL thats important to a
nice landscape. Not fancy shmancy level of detail ROAM implementations or
other insanity.
So. Here is a test image I took.
A brief description of whats going on:
1) The texture is generated from a base set of textures (hand drawn by me
:)), it uses a simple alpha blend with noise added, and is about right
apart from its pretty uncontrollable and needs some changes based on slope
angle.
2) There is a seperate "light" map, which is basically a colour per vertex
byte image produced from the heightmap.
3) The heightmap is either taken from an image or is generated with a FBM
or other fractal algorithm (its pretty unimportant).
4) I added a detail texture, which is applied using multitexturing via the
second tmu.
The heightmap is broken into "patches", and each patch is placed into a
quadtree, the quadtree nodes (and contained patches) are coarsly (sp?)
culled against the view frustrum (nothing complex there).
Without the incredibly shoddy LOD system I am putting in place, I can get
between 30 and 70+ fps at full detail (dependant on how your view frustum
falls against the quadtree). WITH the isLs I should be able to double that
(at least). Patches are rendered as quad strips, using nothing fancy at all.
I am still unsure wether to call this landscape system "BRUTAL" (because
its as brute force as you can get) or YALE (yet another landscape engine).
:)) Suggestions on a postcard please!
Phil.
(L) [2001/02/12] [TimLewis] [Tim@aicube.com]
Whilst there isn't much here that's particularly spectacular code
wise, I just thought this looked rather nice. This shot shows off the
new shader code in my 3d modelling program, Clayworks
([LINK http://www.clayworks3d.com www.clayworks3d.com]). It's a bit tricky to see in this shot but the sea
and rivers of the earth exhibit specular reflection whilst the ground
does not; it looks rather neat from glancing angles. The cloud layer is
just another sphere sitting around the earth (I know it's a bit too high
up). The diffuse lighting model is slightly modified from the standard
function to give a sharper difference between the light and shadow of
the earth. I used an exponential function to give the impression of a
long camera exposure to achieve this effect. The standard diffuse model
just doesn't look right for planets hanging in space.
Later, I hope to be able to generate the terrain data procedurally
(and hopefully add greater detail levels when zooming down on the planet
using a pseudo random number generator) and blending the ground terrain
from a set of textures tuned for terrain type, altitude, weather and
latitude so that equatorial regions have nice turquoise water and more
temperate climes have the familiar grey-blue stuff that I'm used to.
Tim
(L) [2001/02/13] [FredericMy] [mythos@fairyengine.com]
Here is a screenshot of the engine (called Fairy) I'm working on during my spare
time; or I'd rather say the game I'm working on, because I'm more interested in
finishing something simpler one day than trying to create the most perfect
engine on the web and never use it [this is my contribution to the 'game or
engine ?' discussion ;)]. So, there's nothing really awesome at present, but a
lot of things put together : some rendering using hardware TnL through DirectX
or OpenGL, MP3 and soundtrack (mainly S3M - I'm an old retired demomaker)
replay, a database manager, 3DS import and animation replay with quaternions, a
portal based scene graph (hence the mirror in the screenshot), particle systems,
collision detection.
You can download a demo here : [LINK http://www.fairyengine.com www.fairyengine.com]
This is a website I have recently opened, where you can also find my old DOS
demos, and soon (I hope) some source code and articles explaining most of the
algorithms of Fairy.
Concerning the demo, it is very easy to manipulate, especially if you're used to
the Tomb Raider games (these are the same keys, almost the same camera
behaviour, and...)
Mythos
(L) [2001/02/14] [Eric] [ehremo@hotmail.com]
This is a screenshot of my landscape engine. I decided to post this in
response to a previous [LINK http://www.flipcode.com/cgi-bin/msg.cgi?showThread=02-09-2001&forum=iotd&id=-1 IOTD posting],
where the submitter commented on the fact that it's the quality of the
texture mapping which makes or breaks a landscape engine.
My landscape engine only has a simple static binary triangle tree LOD
system, much like ROAM but without the dynamic LOD depending on how far away
the particular part of the landscape is. It may seem pointless to have LOD
which doesn't depend on distance, but I wasn't happy with the idea of the
landscape morphing around before your eyes as you move across it. Also the
WHOLE landscape is drawn every frame, so I needed some way of reducing the
detail in large flat areas of land (this is shown in the corner). One final
advantage is that you can specify how many triangles you want the landscape
to consist of and the LOD system does that, within about 10 triangles.
Eric
(L) [2001/02/15] [DanielHein] [danhein@hotmail.com]
These Pics are just some shots from my Portal Engine-in-progress. All these
shots show some Lighting + Volumetric Fog tests. The upperleft shot shows a
Red, Green, and Blue light, as well as a Blue fog volume in the background.
The Cube is a Rigid Body spinning back and forth across the room. I do have
Volumetric shadows, but at the moment they slow it down quite alot, so they
are disabled for these pictures.
The lower left shot is a closer look at the Blue fog volume, being lit by
the pinky/red light above it.
The 2 shots on the right are of a red Fog volume being lit by a green light.
The upper one is from above the volume, and the lower one is from inside the
volume. I'm trying to improve on the realsim though.
What these still shots cannot show you is that the world geometry is
deformable, and the fog volumes are as well. i.e., walking through the fog
will leave a disturbed trail behind you...Doesn't work 100% yet, but it's
getting there :)
(L) [2001/02/16] [StevenHugg] [hugg@fasterlight.com]
I have been working on a spherical ROAM renderer to render planet-sized
objects. When the NEAR spacecraft made its brave plummet today, I began
wondering if my renderer could handle a very *non*spherical object --
namely, the dog biscuit-shaped asteroid Eros.
I found an elevation map of the asteroid on [LINK http://www-geodyn.mit.edu/near/nlr.30day.html this site].
Eros is a very irregularly-shaped object -- its most distant point is 14
km from the center and its closest point is only 2 km! Quite an
interesting thing to see if a renderer built for spherical objects could
handle it.
After a few tweaks, the thing actually worked! What you are looking at
is a real-time flyby of the asteroid, about 6000-7000 triangles per
frame. I mapped the rock with a generic asteroid texture, and although
you can't see it well in these shots the engine generates unique detail
textures as you approach the surface. The thing runs about 9-25 FPS on
my TNT2 (best when far away, in the first frame) but keep in mind it's
written entirely in Java and I haven't finished optimizing :)
This probably isn't the best way to do LOD on an irregular object like
this. But it shows that an algorithm designed for a specific purpose
(ROAM and flatland) can be perverted into something completely different
yet useful!
(L) [2001/02/19] [AndrewCox] [acox@globalnet.co.uk]
This is a picture of my volumetric sculpting tool
[LINK http://www.users.globalnet.co.uk/~acox/Cavernosa/index.html Cavernosa]
in action.
My work on it was sparked off by the voxel demo and paper released by Stan
Melax of Bioware. His stuff is
[LINK http://www.cs.ualberta.ca/~melax/vox/vox.html here].
Since my goal in creating Cavernosa was to allow the modeling of expansive
natural environments containing features such as caves that can't be
represented by a heightmap, I've built it around a hierarchical voxel grid.
This compressed representation allows grids of up to 2'097'152 x 2'097'152 x
2'097'152 voxels to be worked on.
Andrew
(L) [2001/02/21] [MaximeBizon] [bizon_m@epita.fr]
This is a screenshot of my school project, an opengl 3D game that looks like
Super Mario 64 from Nintendo.
Technically, I use a BSP only for collision detection with the world and a
sphere/sphere collision between the moving object. As
there are not many faces (around 1500 by scene) I don't use any clipping
algorithm, I just send all the faces and that's pretty
fast even on my tnt. The object are simple mesh (3ds) or animated mesh (own
format) using interpolation (like MD2). I use directx
for sounds, musics, and input.
As you can see I've managed to rip the original textures and even the meshes
from the Rom :) so the first level is exactly the
same as in the original game, and the mario mesh also (excepted the face which
is my teacher's one jsut for fun :)
Only one bad thing, the physics sucks and the collision detection are still not
working quite well but I'll try to improve that.
You can download the game at [LINK http://www.sk64.fr.st/final.zip] and if you can read
french I also explain everything about the
developpement.on the website.
Maxime
(L) [2001/02/22] [RobertHutton] [Rob@RCMD.CO.UK]
After the recent spate of IDE screen shots on IOTD, I thought I'd contribute
mine. It's a general purpose IDE that can build projects containing a mixture of
Java, C++, C, asm etc via multiple build steps a'la Make.
It features an addin system to allow easy addition of tools, dynamic compiler
invocation, pluggable look and feel, themes etc. It also includes an interface
to my source code control system
It's 100% Java and will be open source soon (When it's finished, I still have to
add a visual interface to the Java debugger and a drag-n-drop style dialog
editor/code generator)
It is currently being tested by being used to develop a 100% Java game engine
named Luxor. I am currently working on a 3D audio engine as part of the game
engine.
(L) [2001/02/24] [JoeriCapens] [psion@capens.com]
Here are some screenshots from my Psion game called ZherØes. It's a
tactical action game where you must move your soldiers to strategical places
and kill your opponent's soldiers with a bazooka, grenades, a shotgun or
TNT. Bazooka missiles are influenced by the wind, grenades bounce against
the walls and TNT is extremely deadly. All bombs make holes in the landscape
so if you play for a while the landscape is really destroyed. You can play
with up to four players and you can control eight soldiers per team.
My beta version includes one character, the snail, but I'm also going to
make a turtle, a snake and a frog. I also have to add some more landscapes
and sound effects. The game can be controlled with the keys or with the
touch screen. If you would like to see more screenshots or try the game
please visit [LINK http://psion.capens.com my homepage].
It's possible to try the game on your PC. There's a EPOC emulator on the [LINK http://www.symbian.com Symbian site] but it's difficult to install
it and the download size is very big. You can always [LINK mailto:psion@capens.com mail me] and I'll tell you what to do.
It's also interesting if you're thinking about buying a [LINK http://www.psion.com Psion].
(L) [2001/02/25] [NathandObrenan] [nathand@firetoads.com]
Were going to be releasing a "screenshot a day" from our game
Everglade Rush, until a 'certain' video card
company launches their
next gen video card (*ahem* MacWorld *cough cough*), on the PC
platform. At that time we WILL be releasing a demo of Everglade Rush
for everyone to
download and play! The attached screenshot is running in real-time on
this "next gen" video card, however the demo we release is fully
playable on practically
every video card.
This pic demonstrates perpixel lighting (all the hovers down in the
valley), perpixel cubemapping (realistic, accurate refracted
reflections, using programmable
vertex and pixel programs all in realtime), and the sick poly counts you
can expect from our game. There's lots of other great graphical
features in our engine
that aren't displayed in this pic, but we'll leave that for tomorrow :)
Were under NDA to not mention the video card's name, but hopefully you
can figure out which card I'm referring to :p
-Nathan d'Obrenan
[LINK http://www.firetoads.com www.firetoads.com]
(L) [2001/02/27] [BenjohnBarnes] [benjohn@fysh.org]
Hi there. This image comes from a test renderer I've put together to
experiment with shadowing in volumetric environments.
The model (I think it's 128^3 voxels) is a Pink noise function with some
scaling and bracketing to create the desired cloud cover.
The rendering is achieved by simply drawing the volume as 128 overlaid,
textured polygons. Each polygon is rendered twice, once textured with an RGB
transparency map, and once textured with an RGB emission map.
The transparency map is essentially just the initial volume of cloud data.
The emission volume data however, is generated by "illuminating" the cloud
data set. Illumination is achieved by sweeping a light map through the
volume data. The light levels of the map's pixels are used to illuminate the
voxels of a slice of the volume, and then the voxels are used to attenuate
the pixels of the light map, casting shadows on subsequent layers of the
volume. As well as generating shadows, the volume is "normal shaded" without
ever explicitly defining a normal data set - which is nice. The technique
works particularly well for clouds because you get glow filtering through
some of the thinner bits of fluff.
Each image takes a few seconds to draw at the moment. This is rather slow!
Most of this time is due to texture transfer, and my iBook having a sedate
3d card. In a multi-resolution setting (it's the future, boys and girls),
impostors could be used to "flatten" blocks of the volume into a single
polygon. It's a bit tricky to do shadowing "on the card" with openGL, but
it's not impossible by any means. I believe it may be a better trade off to
do the shadowing and impostor generation in software (with Shear Warp), and
final texture composting in hardware.
Cheers,
Benjohn
(L) [2001/02/28] [zed] [sexybastard@clear.net.nz]
a bit of background. ive been wanting to write this game for ages ( as well as 2
others one set in space + the other a rpg ).
currently this is my fourth attempt. the first attempt was with the zxspectrum
in the early 80's in z80 asm, then came amiga in c,
then directdraw (in icsometric style) and now in 3d with opengl, i keep telling
myself this time ill finally finish it but history
aint on my side meeewwwhaha
on the code front lately ive been simpliying the code of my bollux engine(TM),
cleaning up the hacks etc which has resulted not only
in the code being more readible but also the engine is now running at greater
speed.
- ive also ditched the heightmap/landscape restriction so now it can display
indoor/outdoor maps, well basically it draws any crap
that u throw at it.
im using static LOD with my meshes, i have experimented with various LOD
systems but have yet to find a acceptable one though if
anyone knows of a good demo with source i might switch back
dumped doing my own lighting and have decided to let opengl do it all for me
(part of the simplification process) and r pitty
happy with the results.
a personal gripe 'where can i find DECENT texture mapped low polygon models on
the web', ive wasted so much time in making/mapping
models myself with little success. i wouldnt mind starting up some sort of model
group like where ppl would have access to its the
models u have to supply one decent model ie u pay for one u get a hundred. not
money wise u know just effort what are other ppl's
thoughts
a final note prolly the greatest achievement about my game sofar is its been
written on win2000 with 64mb 'so many magical 5 minute
moments ive enjoyed sitting twiddling my thumbs, listening to the sweet sound of
my harddisk have a heartattack whilst vc churns
over my code' tommorrow im getting an extra 128mb. damn my thumb twiddling days
are over!!
(L) [2001/03/01] [Emil] [emil@linteractive.com]
Here are a few screenshots from my latest project, an underwater screensaver,
rendered in realtime using OpenGL.
This is one of my first attempts with 3D graphics, so I have kind of added more
features while learning.
I think the result is pretty cool, though it requires a Geforce or something
similar by now (About 25 FPS on a Geforce256).
The lightmaps are procedurally generated and animated. (I'm really running out
of texture units)
(The light is refracted by a simple wave simulation to generate the typical
light-patterns on the bottom.)
In the shot with the can you can see a soft shadow at the bottom, which gets
sharper as the can moves closer to the bottom.
(It looks better when animated. Also, notice the darkened shadow volume)
The rocks seen in one of the pics have some precalculated bump-maps.
The schools of smaller fish uses a simple flocking simulation. They also avoid
the rocks, and tries to escape the hunting dolphin.
The dolphin, which is programmed to hunt the smaller fishes, is animated by
deforming it's object space with a suitable continious function.
The seaweed is animated to give the illusion of streaming water.
Most of the geometry is procedurally generated.
That's all.
I'll try to make it available for download soon.
Look for it at: [LINK http://www.liscreensavers.com www.liscreensavers.com]
/Emil
(L) [2001/03/02] [Cuban] [amperez@andrew.cmu.edu]
This is the result of my first foray into D3D Vertex Shaders. It's the
regular D3DXTeapot, rendered with three projective textures. One is a
rotating fan-like texture, one a static vent-like texture, the other is a
moving texture (the DirectX 'X'). The inspiration for making this was the
Doom3 video shown at MacWorld the other day. Code-side I spend some time
setting up projection matrices for each of the spot lights, set a few
vertex shader constants, and then just render the mesh 3 times with alpha
blending. Texture coordinates are generated given the object-space
coordinates, they're clamped to the texture boundaries, and the texture
is also multiplied by N*L (N=Vertex Normal, L=Light Vector) to get a
nice falloff on the edges.
The DX8 binary is here:
[LINK http://www.contrib.andrew.cmu.edu/~amperez/projtex.zip http://www.contrib.andrew.cmu.edu/~amperez/projtex.zip]
The code for the
vertex shader is included. Pretty standard, and probably grossly
inefficient in register usage (hey, it's the first assembly code I've
written in years). Makes for a purty app tho.
-Cuban
(L) [2001/03/03] [BenoitAutheman] [authem_b@epita.fr]
Theses screenshots shown my two 3d engine in action.
The two car race scenes were extracted of my last year shool game project.
It's programmed using Delphi and Opengl. It's a very basic engine, even if the
game looks pretty cool visually.
The two other shown my new c++ opengl based 3d engine. It a bit more evolued,
since the project include a 3ds Max 4 exporter and some cool specials effects.
The scene in lower left corner show a 5000 poly animated water effect, plus a
700 poly smoke effect and a 400 poly snow particle system. It run at 15-16 fps
on my celeron+tnt2, but it is really unoptimized for now.
More infos, a demo of theses effects, screenshots and delphi engine source
code can be found on my web page : [LINK http://falsem.citeweb.net]
Since this web page just came online, any feedback would be greatly
appreciated !
thanks,
benoit.
(L) [2001/03/04] [Brebionflavien] [brebionf@club-internet.fr]
In previous IOTDs, many people asked what algorithm Terragen is
using to calculate its textures. Since i didn't dare to post YALS
(Yet Another Landscape Screenshot), i prefered to send this one (which
is a top view of my terrain) with a short description of how i'm texturing
it (i don't know if Terragen does the same thing, but the results look quite
similar).
First, before you ask:
1. It is realtime rendered, and actually quite fast (there is
around 8000 triangles in this frame). I expect 150 fps on a P2-400+GeForce.
Brute-force method: no LOD (yet).
2. It is not using a Terragen's texture. Terrain textures are completely
procedurally generated.
3. No demo yet, but i'm working on one. Still needs a few weeks of
work.
Now, some words about the technic:
I'm using a set of 3 parameters: elevation, slope and exposition/
orientation for each texel. Designers can use a script language to describe
how to texture-map the terrain. It is done, as Terragen, with materials
layers. To each layer is associated a texture map (grass, rock, mud),
some conditions about the elevation, slope and exposition, and for each
parameter, a min/max blending coefficient too.
The influence (ranging from 0.0 to 1.0) of a given layer is calculated,
for a texel, by interpolating the 3 blending coefficients. Then, we get
the final color of the texel with a standard n-blending function.
It is also possible to specify specific texture maps for some texels,
as shown with the muddy road in the shot.
A simple script example would be:
Grass {
Slope {
angle_min:0 # min angle condition (degrees)
angle_max:31 # max angle condition (degrees)
blend_min:0.9 # blending for min angle
blend_max:1.0 # blending for max angle
}
}
Sand {
Slope {
angle_min:31 # min angle condition (degrees)
angle_max:90 # max angle condition (degrees)
blend_min:0.8 # blending for min angle
blend_max:1.0 # blending for max angle
}
Elevation {
height_min:0.0 # min height (in meters)
height_max:10.0 # max height (in meters)
blend_min:1.0 # elevation blending is identiy
blend_max:1.0
}
}
Rock {
Slope {
angle_min:31 # note that these are the same
angle_max:90 # parameters than for sand. Only
blend_min:0.8 # the elevation condition
blend_max:1.0 # changes.
}
Elevation {
height_min:10.0 # min height (in meters)
height_max:10.0+ # max height: above 10 meters
blend_min:1.0 # elevation blending is identiy
blend_max:1.0 # too
}
}
I let you, as an exercise, imagine what sort of terrain this would result
in :)
(L) [2001/03/05] [ChrisEgerter] [powerrender@home.com]
Here are a few screenshots of my new terrain engine, running on a ATI
Radeon with DX8. The entire scene is rendered with hardware T&L and
it's running at full frame rate with around 140,000 tris total per
frame.
Features are: fully deformable terrain, quadtree visilibity, dynamic
soft shadows, rippling reflections using EMBM, skycube and moving cloud
planes, can draw directly on the terrain texture so scorch or tread
marks last forever, wrapping world so you never reach a world boundary,
automatic terrain texture generation, WYSIWYG editor in development,
drag and drop objects in the world.
Bigger screenshots and more information is at [LINK http://www.powerrender.com www.powerrender.com].
Sorry no public demos yet.
Chris Egerter
(L) [2001/03/07] [RobPasquini] [trunks336@yahoo.com]
This is a screenshot from a game that I helped develop
at my school. It may not be a beautiful terrian
engine, but it is a pretty fun game. :] It's a
top-down shooter where players battle in enclosed
arenas. Gathering weapons and shooting your enemies up
what it's all about. Good clean fun.
The game itself took about four months to develop. We
had a solid process of game design documentation to
technical documentation before we started coding. The
game features a rhobust 2D engine, and some
challenging computer controlled opponents to battle
against. The game is also multiplayer over a LAN, but
does not perform well over the internet unfortunately.
If you'd like to check out the game it's about 22MB,
but well worth it.
[LINK http://www.digipen.edu/Original/downloads/GenJox/]
There is currently no instruction manual to download
but hopefully soon there will be.
On a side note; we had no real artists working with us
to develop the game, so it is not as graphically
impressive as we'd like it to be. It's all about
gameplay. ;] Have fun!
(L) [2001/03/09] [DennisMeffert] [dennismeffert@hotmail.com]
Some screenshots of my almost completed 3D Engine. This is NOT a Quake 3
level viewer. I wrote the BSP/PVS compiler myself.
There are some few problems regarding "illegal geometry" but I think I will
have them fixed very soon.
Main features:
- BSP/PVS compiler/rendering
Curved Surfaces
Static Lightmaps
Entities
Collision detection and response
Scripted shaders
Dennis Meffert
(The Netherlands)
(L) [2001/03/12] [Dan] [dan@propellerheads.se]
I've been an regular reader of flipcode for about a year or more and been
just lurking around picking up cool tips and looking at awsome pictures.
The image submitted is a screenshot of the application I've been working on
at Propellerhead Software ([LINK http://www.propellerheads.se www.propellerheads.se]), it was finally released
last autumn.
So what is it?
It's a music-making software. It features a number of "devices" that
generates sound and has a build in sequencer. There is also free routing of
the audio chain by flipping to the back side of the rack. The top left area
is the front and the lower right is the back. At the very end is the
sequencer.
So why post it at Flipcode?
It looks pretty good (imho).
It uses a number of techniques more normal to games than music, the graphics
uses alpha channels and are custom compressed, it creates sound using both
algorithms and samples in real-time. Realtime physics for the cables - yes
they do move pretty convincingly. We use offscreens to avoid flicker.
I'd just wanted to share this with you guys since I like the site a lot. And
I think it would make a really good tool for people making games who wants
music but can't afford an entire studio. :]
Thanks for your time guys/girls.
PS. The absolute hardest part of any project is to finish it...
(L) [2001/03/15] [ChanKaMing] [ming4883@hotmail.com]
It is a screenshot from the map editor of my 3D Engine, ming3D. The engine use Direct3D7 and is still under development. I have just finished the static light and shadow calculating part. The white cross is the light source and you can see the shadows on the floor and the wall.
Here are the features I would like to add to my engine:
- Octree or Leafy BSP and PVS rendering
Dynamic lighting
Midmapping
3D Object picking
Finally, thank you very much to Tobias Johansson for his excellent lightmap tutorial on [LINK http://come.to/polygone].
Chan Ka Ming
(L) [2001/03/17] [JackStrohm] [jstrohm@jam.rr.com]
These are some screenshots from an engine I've been working on for over
a year called Geek. This engine dynamically generates a mesh from a
3D voxel data structure. The voxel structure used to create these
images was 128x128x128. I plan on supporting a voxel structure of
65536x65536x65536. I have a long way to go before I can call it
complete. I plan on adding a portal basted indoor engine also. A
friend of mine is writing a scripting language for it. Check out the
website for more details.
Going clockwise, the top right picture shows some terrain that fades
into fog. The next image is a wireframe showing LOD in action. Note
the more distant terrain has fewer triangles. My cost function for
generating the LOD sucks but will be improved soon The next image is
what I like to call "green swiss cheese". This model is created using a
perlin noise function. The final image shows real-time editing. (Still
not as real-time as I would like). When you modify the voxel structure
all affected meshes and textures are recalculated allowing you to see
your changes immediately.
The engine and the editor are the same. My goal is to have an engine
that allows for real-time map deformation. Imagine throwing a bomb and
find a hole in the ground where it landed, along with being able to see
the grass on the edge and the dirt under the grass from where the bomb
exploded. Well that's my goal anyway, hope I can get that far.
Current features include:
- Underlying data structure are voxels contained in an octree.
Dynamically Generated Mesh, Textures, and Texture coordinates.
Terrain doesn't have to be flat. It can have holes and caves in
it easily.
Allows modifying of the voxels which in turn causes all affected
meshes to be recalculated.
Real time editing (this is still slow, but hasn't been optimized
yet)
Early LOD, as you move farther away I use lower resolution meshes.
Saving and Loading of all data structures.
Preliminary console implemented.
Implemented in C++ and OpenGL under Linux
Currently only tested on TNT2 and Geforce2MX
Multithreaded (Except can't run in MT mode on SMP machines running
NVidia drivers, bug in drivers).
Sky sphere has been implented.
I'm sure there is more, but I don't remember.
You can download the linux executable (Mandrake 7.2) and see more
screenshots at [LINK http://home.jam.rr.com/jstrohm/projects.html].
I'm most proud of the dynamic texturing. I can take a OpenGL texture
and generate texture coordinates to wrap it around an arbitrary
surface. I'm not talking about projection mapping, but I am able to
give every triangle it's own area of the texture image and still
generate triangle strips that can quickly be fed thru OpenGL. On my
TNT2 I can get between 1 and 1.5 million triangles a second. Once some
of the driver features that are available under windows for the Geforce2
are implemented under Linux I should be able to get 5-8 million
triangles a second on a Geforce2MX.
Thanks for any comments and constructive criticism,
Jack Strohm
(L) [2001/03/20] [NikolayStefanov] [oligopod@yahoo.com]
These are a couple of pictures from a CSG demo I've
been working on for the past few days. Features
include :
- BSP-style CSG (Naylor's algo)
thick BSP planes
DirectX 8 rendering
loading of X files for primitives
command line interface
horrible asserts from time to time :-)
I plan to release the demo and the source in the next
few days, as soon as I optimize the code a bit. Btw,
the 1011 FPS are real :) This is what you get from
TBird 800 / GeForce2 with a few vertices in a buffer.
Nikolay Stefanov aka Oligopod
(L) [2001/03/23] [JonHasselgren] [jon.hasselgren@telia.com]
Some sceenshots of a dynamic light and shadows system I've been working
on for some days now. The shadows are dynamic stencil buffered shadows and
the system trys as much as possible to cut down the amount of shadow volume
polygons generated in order to minimize fillrate dependency.
The pictures are:
Upper left - One dynamic lightsource with shadows.
Upper right - Its the same shot, but shadowing edges are outlined.
Lower left - 3 lightsources scene (R,G,B). It might be hard to see but there are really alot of faint shadows in the picture.
Lower right - The scene with lightmapping only.
It's still quite fillrate intense since the shadowing force me to do a
n+2 pass rendering where n is the amount of lights. First I need to render
lightmaps (This also initializes the depth buffer so you can do blending),
then for every light I must render shadow volumes to the stencil buffer
and then render lighting with additive blending and stencil testing.
When done with all lights I render the textures with modulative blending.
There are still some problems/bugs to overcome, for instance the entrance/exit
of shadow volumes are bugging me. Since I actually render the shadow volumes they
are also clipped to the near plane, but as you can imagine this creates
somewhat weird results. It can be solved by setting the near plane to 0.01,
but that breaks the Z-Buffer.
The performance is pretty ok (I think). Since my hardware sucks i sent a copy to a friend
with a better computer and the one light scene run at 50-70 FPS on his machine in 800x600
resolution. The 3 lightsource scene runs at ~25 FPS on my computer in 320x240 (but my
Viper550's fillrate is ~28 MPixels/s).
Well,I guess I could keep talking forever, so I better stop.
(L) [2001/03/27] [DavidMassey] [dave@alphasquadron.com]
This is a small project I've been working on for about 3 months now.
Right now it's a single player 3d shoot'em space game /w a limited chat
ability.
I plan on adding a multiplayer component that will allow people to play
against eachother.
One player will essentially make the fleets, the other people will then
have to defend against whatever formations the opposing player decides to
launch at him.
I use OpenGL for the graphics, a custom 3dsmax importer for my ships, FMOD
for the sound, and standard Win32 for all of my *necessary* stuff.
The particles are still a bit slow (sub tnt2), but they are so flexible
that it makes adding any kind of particle effects a breeze. I hope to use
them in a future graphics demo that I can not wait to get around to..
You can download the demo at [LINK http://www.cs.unm.edu/~genesis/alphasquadron.exe]
I'd really like to hear from anyone with a voodoo3 or a radeon and see if
they are having any problems with it.
Thanks,
David Massey
(L) [2001/03/28] [MustataBogdan(LoneRunner)] [lonerunner@planetquake.com]
QLand is simple program which shows quad tree cooling for a land. The land
is random generated and has futures like: water, easy mouse control and
possibility to change size and texture for the land.
The program use a new Skeleton for Win32 and IJL - Intel(R) JPEG Library.
Source code is included in the ZIP.
[LINK http://lonerunner.cfxweb.net/]
(L) [2001/03/29] [MikeHommel] [jamul@hamumu.com]
Here's a shot from my latest game, Loonyland: Halloween Hill, just came
out yesterday in fact, so hurry to my website and order up a copy! How can
you resist!? I could talk about some of the fancy features, but however
fancy they are, they aren't trilinear or mip-bizzled or flange-flipped or
anything, so I'll just say it's fun, it's 2D, it's an
action-adventure game (Zelda type of thing... get quests, do them, kill lots
of monsters), and it includes the Pants Of Power, not to mention a whoopee
cushion and potted cactus as special weapons. Demo, shots, info, and
ordering are available on my website at [LINK http://www.hamumu.com]. Check out
the demo and I'd love to hear what you think.
Mike Hommel
Hamumu Software
[LINK http://www.hamumu.com]
(L) [2001/03/30] [Hikey] [humi@hikey.org]
Hi, these screenshots are from my final year project (B.Sc Comp Science).
Features include animated user interface, 3ds model loading, model hierarchical
structure, flat/smooth shading model display, model skeleton editor, object
picking, model position editor, forward kinematics, ...
The project is organised in a library and a demo program. the library handles
the model loading, data structures (objects, vertices, normals, camera, etc...),
animation functions, ...
The demo program simply displays the model with a fairly nice interface for file
browsing, object picking, and so on.
It includes a skeleton editor which is not part of the 3ds file but in an own
format.
Full source code, binaries and project report available at [LINK http://humi.hikey.org]
Lionel LEMARIE aka Hikey
(L) [2001/04/02] [JaccoBikker] [Jacco.Bikker@davilex.nl]
Here we have a shot of a wacky bunch of Flipcoders posing in the [LINK http://www2.davilex.nl/devweb Davilex] building after the second
IGDA meeting in Holland. The meeting was a great success; we had around 60
Dutch game coders attending two highly interesting presentations. Anyway,
about the picture, from left to right we have: XjaapX, Phantom, Willem and
Bram. All in the right outfit for the occasion, of course.
I'm sorry about the model and the texture for Jaap; somebody did a lousy job
there. I masked the worst part a bit.
Anyway, greets to all game coders around the globe, especially the
Flipcoders and of course the Dutch game scene.
(L) [2001/04/04] [DeanHarding] [deanie@bigpond.net.au]
War Worlds is a game I've been working on in my spare time, it's very akin
to WarZone 2100, (I came up with idea before I learned about WarZone,
though! Honest! I've just re-written it about 4 times since I first
started)
It's still at an early stage, but basically what you get when you run it is
a rolling demo, the camera moves over the terrain, and there's a whole bunch
of units fighting each other.
The terrain is rendered using a technique I read about on [LINK http://www.cbloom.com/3d/index.html Charles Bloom]'s page, which
he calls "splatting". Basically, you take a chunk of terrain, and render it
several times, each time you add a different layer of texture to it. My
version is slightly different to his, but you can see it gives quite good
results, though it's probably a little slow on anything but a GeForce. It
just uses vertex lighting, which you can only see in the loading screen on
the top-right (a cool effect I made up for the fun of it, it takes a
screenshot and blurs it and subtracts a random amount from each pixel).
Also of note, perhaps, is the bottom-left shot. This shows the cliffs that
I support in the terrain, you won't see any of these in the demo, because
the units just ignore cliffs, and roll right off the edge, but you can have
a cliff, which is compiled to just one triangle strip. They're not very
good yet, basically all you can do with them is what you see in the screen
shot. Later, I'd like to be able to have cliffs that run diagonally through
a tile, which is possible, it just needs a bit of coding effort...
The units themselves are just meshes I export from 3DStudio in ASE format
(I'm not a very good modeller, as you can see, but they work...). They're
not lit, or anything, but that'll be something to add in the future. You
might be able to see that there's three different types of turrets that each
unit has. The missile launcher (foreground of the top-left picture), the
machine gun (background of the top-left picture) and mortars (which you
might not be able to see, since it's covered in smoke in the top-left
picture).
There is a demo available for download on my website, [LINK http://www.cse.unsw.edu.au/~deanh/war-worlds/ www.cse.unsw.edu.au/~de
anh/war-worlds/] I'd encourage you all to download it and tell me how it
goes!
Dean Harding.
(L) [2001/04/06] [JoeBanach] [j.banach@inetmail.att.net]
This is a little polygon pusher IÂve been playing
around with written in Visual Basic 6 and DirectX
8. Much of the code I have ported from
mrgamemaker.comÂs BSP Tutorial II. I got tired
of manually typing coordinates to make my own map
file, so I used the .mwm file from the above
tutorial. I know that mrgamemaker.com took the
BSP tutorials down but I hope they donÂt mind I
used their map file. DX8Maze does not use binary
space partitioning (BSP) or potentially visible
sets (PVS). It is just a polygon pusher I wrote
to learn DirectX 8. It uses discreet lighting
with mostly ambient light. I threw one point
light in there and sucked the green and red
components out to leave a blue color. I think it
looks pretty cool. I had lightmaps at one point,
but editing the .mwm file with a hex editor I
found to be just as tedious as writing my own
map. So I left the .mwm file in its original
form.
Special thanks to mrgamemaker.com for the two
excellent BSP tutorials, Romka Graphics for some
textures, flipcode.com and gamedev.net for the
awesome web sites, the DirectX newsgroups for
answers to some questions and Microsoft for
DirectX 8, Visual Basic and the DirectX 8 SDK.
This code may be used freely by anyone for any
purpose. I hold no responsibility for anyoneÂs
use of this code. I have successfully run this
on a Matrox G400 and an nVidia TNT2.
The code can be found at [LINK http://www.gdcopen.com/DX8Maze www.gdcopen.com/DX8Maze]
Thanks,
Joe Banach
(L) [2001/04/07] [RobJames] [robjames@europe.com]
Hi IOTD Watchers,
Some of you 'may' remember my IOTD from a few months ago - it was a
Multi-Fractal Terrain demo rendered in sort-of-realtime using ray-casting
onto an infinite, implicit surface with SIMD optimised multi-fractals :)
(demo at [LINK http://www.pocketmoon.com])
Well now I'm aiming at the whole planet rather than just a flat terrain.
It's vanilla C & OpenGl.
With traditional terrain rendering, there is a (potentially huge) data set
defining the terrain. Even with wavelet compression I doubt you'd get a
small planet into a reasonable amount of memory - but it may be worth
invetigating!
Another approach, taken here, is to have no stored or precalced heightfield.
The surface of the planet is instead represented by an 'implicit surface',
i.e a function, f, that returns the surface height given a position P. So
h = f(p) :)
'f' is a multifractal function based on the work of Ken Musgrave, who's
currently working on a 'commercial' fractal world called Mojo
([LINK http://www.pandromeda.com]). I build up many layers of random noise at
increasing frequencies and magnitudes. For the flat terrain I used Perlin's
Noise2 function within 'f' ([LINK http://www.noisemachine.com]). For this Fractal
Planet i've moved to the Noise3 function which obviates the need to map a 2D
function around a sphere. The Noise3 function is inherently slow (lots of
lerping) so at some stage I'll implement a SIMD version (as I did for Noise2
previously) which should easily double its speed for PIII users.
The height function is also used to generate the surface texture (based on
an index into a 1D surface type (colour) array - re Musgrave) This makes the
texture match the terrain (varied by latitude).
The surface mesh is a simple bintree with level zero being a 8-sided diamond
(Octahedron). The first screenshot (top left) shows the mesh split down to
level 6 with the whole sphere tesselated down to 17000+ triangle. Each
subsequent image (TL->TR->BL->BR) is a further level (or two) down. NB the
terrain height has been GREATLY exaggerated to aid visualisation!
The intention is to be able to get down to ground level and still see
detail. To get a 10 meter resolution mesh would require around 40 splits
(based on a 6000KM radius planet) which would result in a sphere of >4
trillion triangles! I doubt a even a GeForce3 could handle this ;) So lets
CULL and LOD! Currently I have two pre-Opengl culling routines: Horizon
Culling and View Cone Culling. Horizon culling is done at the level 6 mesh.
At altitude 'a' above the surface, the horizon is sqrt(2*a*Radius+a*a) away
so I do a quick distance check for each tri and stick them in my horizon
culled pot. I then split these tris down to level 12 and carry out the
view-cone cull. This set is where I plan to carry out the final LOD
splitting stage. It will be some sort of ROAM-esque LOD - probably with
splitting based on distance and 'wedgies', with a merge queue to free up
memory.
Usually, LOD systems are based on a predefined heightfield so they work
bottom up - simplifying the smallest triangles upwards to larger ones based
on some visual error metric. In this case I have no predefined data so I
work downwards from the large tri's. A key point is that this can be tied in
with the multi-fractal function - each frequency of noise contributes less
and less to the overall height but represents features of smaller and
smaller scale. For a point far away we may need only 2 or 3 octaves of
noise. As we get closer we add more and more additional octaves to get the
fine detail. We only need to split if the split pair is noticably different
when rendered, so for flatish pairs we can defer a given split till we are
much closer. Initially though I'll just try pure distance based splitting on
the final culled triangle set. Once this is in and I've added some flight
controls I'll post a demo.
Hope to release the demo soon at [LINK http://www.pocketmoon.com]!
ttfn
Rob James
(L) [2001/04/09] [HelgeFoerster] [helge.foerster@activezone.org]
This is the second shot of my 3d engine for Java that i submitted as an
IOTD.
(The first one was the shortest shown IOTD i ever saw on flipcode...around
9h
before it has been replaced...i don't think that it was that ugly :-))
It shows the improved environment bumpmapping and it's effect on image
quality
by comparing the same scene with and without bumpmapping. Below the two
engine shots the used texture, bumpmap and envmap are shown.
The engine can be found at [LINK http://jpct.de]
Greetings,
Helge
(L) [2001/04/11] [3TETeam] [turing@anet.net.tr]
This is from our in development, realistic 3D adventure/shooter game. The
key to finish the game is not killing everybody you see. You must talk to
other NPC's, find&use items, plan your strategy and combat when neccessary.
We started developing 3TE Gaming Engine for our first 3D/Shooter game during
past 3 months.We are trying to incorporate the latest technologies into 3TE.
We are planning to use 3TE in our future projects.
We are a small team consisting of two people. One of us is currently working
on game design and level design so we have only one person dedicated to
programming the engine and the game. Because of this, we are temporarily
using Q3Radiant for our world modelling tool. So we also made Q3 BSP file
loaders for testing engine features.
We also support Lightwave models for game objects. If needed, we will also
make importers for other modelling packages like 3D Max, Maya, SoftImage
etc.
The final engine will support all the features that are listed in our site
in the Technology section. New features may be added by the time with your
feedback and ideas.
3TE Team
Cem UZUNLAR Hakan YÜKSEL
[LINK http://3TE.freeservers.com]
[LINK mailto:turing@anet.net.tr turing@anet.net.tr]
(L) [2001/04/12] [DavidGaleano] [dgc@eresmas.net]
The terrain size is 16 kilometers by 16 kilometers and the far plane is
located 5 kilometers away of the camera. This map has more than 100,000
plants.
The terrain is a simple quadtree rendered using static LOD. The plants close
to the camera are pre-lighted models with 2 LOD, when they are far away they
are draw as impostors depending of the angle with the camera.
The water is simulated using 2 quads with the texture tiling and moving in
opposite directions. The water reflection is rendered to a texture than
later is blended with the water applying a vertical blur.
The Sky is formed by a semi-sphere with a gradient of color from white to
blue than is blended with a clouds texture that fades to the fog color in
the distance.
For more screenshots:
[LINK http://rt000s2p.eresmas.net/photo.htm]
[LINK http://usuarios.tripod.es/davidgaleano/photo.htm] (Mirror)
Also, there is a demo available for downloading where you can see more
effects that those I have described:
[LINK http://rt000s2p.eresmas.net/downloads.htm]
[LINK http://usuarios.tripod.es/davidgaleano/downloads.htm] (Mirror)
(L) [2001/04/14] [Pet] [psoroaga@websci.ro]
This are some screenshots of one game I'm working on now called SkyGuard (don't laugh :) ).
It's nothing fancy about my 3D Engine... I'm just tring to make a game (or more...:) ). It
supports now loading 3D Worlds from 3ds files, camera animations and some primitive objects
animations. After many attemts to use octrees, portals I decided that not to use it at all.
Some culling is made only on large objects, objects with many triangles... It supports now
only static light maps and animated textured ( offcourse vertex light is supported ).
You can check this out on my site: [LINK http://www.geocities.com/green_balls_ro/index.html], but I
warn you that it is under construction.
(L) [2001/04/17] [GabitaSoft] [gabita@gabita.com]
This is a screenshot of a landscape sample made with the TrueVision3D Engine
It hase a realistic landscape with a detail texture, multi textures ,skybox, lens flares, water effects, a mesh with gravity and a lot more.
You can download the sample at: [LINK http://www.truevision3dsdk.com]
And you can download also the engine at the site to develop your own games with special terrains/bsp/mesh/...
Regards,
TrueVision3D Support
(L) [2001/04/19] [KevinKennedy] [kevin@dropdesigns.com]
This is my first image of the day. I just finished writing a screensaver for fun
using directdraw. It only uses directx for access to video card memory and the
surface flipping. The basic idea was to have a bunch of different particle
system effects that can be smoothly transitioned. It works sort of like a dj
spinning records. It plays one effect for awhile and then "crossfades" to
another. You can download the screensaver from [LINK http://www.dropdesigns.com/astral www.dropdesigns.com/astral].
(L) [2001/04/20] [MattiasFagerlund] [mattias@cambrianlabs.com]
Here's images from a website we've created (
[LINK http://www.cambrianart.com] ), where you can evolve your own art - it's
similar to Evolver that was mentioned here a while back (
[LINK http://www.flipcode.com/cgi-bin/msg.cgi?showThread=02-02-2001&forum=iotd&id=-1 link] )
except you can evolve your own images online.
These images can be stored or sent as electronic postcards.
If you need sci-fi looking textures for a game, for instance, you can
evolve your own - or use the ones that are allready published on the
site. Just let us know.
/Mattias Fagerlund
(L) [2001/04/24] [PeterKoen] [koen@kema.at]
The aim of this intro was to simulate non realistic handdrawing and
watercolor/aquarell-like texturing.
64k intro released at mekka&symposium 2001:
[LINK http://www.farb-rausch.com www.farb-rausch.com]
-entro[fr]
(L) [2001/04/26] [JavierArevalo] [jare@jet.es]
This is a screenshot from the little intro "Durantro", which was presented
at the Durango 2 demoparty in Spain. The intro is available in the
downloads section of my [LINK http://www.terra.es/personal3/jare70 web
page], together with the Visual C++ 6 source code & project. Note that
you will have to download MiniFMOD from the [LINK https://www.flipcode.com/archives/www.fmod.org Firelight Multimedia] web site, in order to
recompile it. I think the source code is fairly well organised, even if not
too feature-rich, and could serve as a starting point for people beginning
to work with D3D 8.
The intro requires a Direct3D 8 - compatible 3D accelerator. Note that it
also has to be the primary card, so users of Voodoo1 and 2 cards can't
watch it. What can I say, we were in a hurry. :-) In fact, we only tested
it on NVidia cards and the laptop's S3 whatever-it-is card.
(L) [2001/04/27] [AndyMaddison] [andy.maddison@btinternet.com]
Here are 4 screenshots grabbed from a video (avi) I made for my final year
project when I was at university. The project's subject area was Augmented
Reality, which is the composition of computer generated graphics with real
images at interactive frame rates. The project involved moving a computer
generated object (cube) around a real scene (lego arch on a piece of board)
in real time. The cube was moved around the scene using a mouse and
collision detection was implemented so the virtual object would 'collide'
with the real object. The screenshots show inter-object shadowing between
the scene and the cube, and occlusion of the cube by the scene.
The original idea was to have a virtual ball rolling around the scene, but
the hardware I had to work with (combined with my inefficient code) was not
up to the task.
Thanks,
Andy.
(L) [2001/04/30] [AntonKnyazev] [anton@crytek.de]
Not much to explain about it, actually. Just real time attenuated light+radiosity+soft \
shadows combo in real time. Oh, did I mention it was real time :) ? Yes, I know that the
scene is pretty simple (not to say basic), but at least soft shadow part is independent on complexity.
Regards,
Anton Knyazev
(L) [2001/05/01] [nolan] [kijiki0@netscape.net]
This is a shot of a java applet game I wrote a couple of years back. It
evolved from an even older (1997 or so) wireframe pong applet. It uses
AWT to draw the actual polygons, to get decent performance. On modern
machines with modern JIT compilers, even if you get multiple "multi-ball"
powerups, gameplay is still fluid (Multi-ball causes each ball on screen
to explode into 8 seperate balls). The code is pretty ugly; to prevent
stuttering caused by the garbage collector, I had to structure the engine
and game so that no objects are created or destroyed during play. Hidden
surface removal is hard coded. The sides and front of bricks are not
drawn if they would be blocked by an adjacent brick.
[LINK http://sigbus.net/breakout Click here to play.]
It features a server side high score list (which gets 'hacked'
periodically by dorks decompiling the applet =). The current high score
was from an actual game though.
I haven't done any Java development in years, but it was (and still is) a
fun way to get back to the good old days of slow CPUs and no 3d
acceleration.
First person to complain that the shot is 'too dark' gets a beatdown.
nolan
(L) [2001/05/02] [LennoxAntoine] [lbantoin@ic.sunysb.edu]
I had a previous release of the engine a while back (I pollute flipcode
with landscape shots). This fixes a lot of things that were wrong, and
overall better performance. The things present in this demo are :
- Lod landscape (improved, very simple)
3ds file import
Multiple actors controlled through scripts
Progressive meshes
Simple physics
particles posing as birds/fairies (just sprites)
Get it at : [LINK http://www.sinc.sunysb.edu/stu/lbantoin/]
There are however a lot of stuff that I left out so that the speed would
be acceptable for most users. These include rippling water and realtime
swaying fractal trees. Feedback/flames would be greatly appreciated on
what is missing, or what you would like to see.
-Lennox Antoine
(L) [2001/05/07] [TopcaT] [topcat@bsod.co.uk]
Well, this is the beginnings of a RTS game engine. It's in a bit of a mess
at the moment I'm afraid, and the graphics are suffering badly from
'programmers art'. The transparency effects won't work properly on a lot of
older graphics cards, don't blame me, blame their dodgy OpenGL support.
Still, it's feature list is fairly long, if not that impressive:
- LoD based on distance and terrain variation
Bodged "almost A* algorithm" for path finding
View frustum culling
Procedural landscape texture generation
Completely seamless texture tiling [a b*tch to do]
Shadow maps
Detail texturing [but only not if you've got a lame gfx card]
3 kinds of units [only 2 are textured]
Some trees!
Lame particle effects
Rubbish sounds effects
etc
The code is fairly slow and unoptimised, it was more of a test of algorithms
than an attempt to get a supa fly engine. You can download the source and
executable from my website [LINK http://www.bsod.co.uk www.bsod.co.uk]
Cheers,
TopcaT
(L) [2001/05/11] [Bunnz] [Bunnz@gmx.at]
Here's a screenshot of the game Hase and I developed.
It's a 2d side scroller, but uses 3d interface of DirectX 8.0.
Some features:
- hardware alphablending, rotation, ....
splines for movement of the enemies
level is described by some scripts
...
You can download the game at: [LINK http://www.Bunnz.com www.Bunnz.com]
Have fun
Bunnz
(L) [2001/05/13] [GeorgeZiniewicz] [zin1@home.com]
This is a screen of a recent OpenGL app I wrote for the OpenGL Challenge.
Nothing that special (a joyriding simulation), but curious is a round noisy
lightmap I added over the scene when I was done with a frame. The noise is
procedurally generated about 20 x a second (I run around 100 fps on a GeForce2),
rides atop a fixed noise value per line, and a cone, providing an effect of an
"old-time" television: noise, discrete horizontal line noise for a slight
banding effect, and corner vignetting.
The effect is better when viewed animated:
[LINK http://zintel.com/apps/HiwayZ.zip]
The OpenGL Challenge site has it w/ source: [LINK http://OGLChallenge.OTri.net/].
The effect can be toggled (key "i"), noise level adjusted (), and size
adjusted ([]). Or try for a popup menu, and select "Options",
there are plenty of adjustors.
Also of note in the app is a retro 3-2-1 intro, and a closing screen
"splintering" effect, which does 255 variations of "chop the screen into bits
and move them". Toggle key "x" to demo.
zin
(L) [2001/05/14] [akbarA.] [syedali011@earthlink.net]
the details are over at
[LINK http://www.angelfire.com/ab3/nobody/pplRendering.html]
(L) [2001/05/16] [JulienHoullier] [julien.houllier@wanadoo.fr]
You can download and try current version of my OpenGL 3D engine, called
KoolEngine v1.4.
- I've coded a mini-raytracer for lightmaps calculation, but this one is not
perfect, as you can see between some surfaces.
Collision is not perfect, but runs well.
There is many improvements that can be done on KoolEngine, and every
suggestion is welcome...8-)
Try pressing F1 key to see stats.
You can download this demo on my website : [LINK http://point.free.fr] in the
folder "PROJECTS"
SeeU...and enjoy KoolEngine !
Julien Houllier
(L) [2001/05/17] [LarsBirkemose] [larsmose.spamm.proof@post4.tele.dk]
Heres a very rough demo I made a couple of years ago, showing realtime
shadows.
This is old, and parts of the code might be ugly or just plain buggy :)
The demo uses tesselation to calculate the shadows.
I was in the progress of writing a simpler (and much faster) tesselation
than what OpenGL supplies, as the tesselation takes much of the rendering
time, but I never got time for it.
The dark shadows from the internal light is only partially calculated, ie no
shadow is cast on the wall.
And no shadows are calculated from the light in the corner.
The EXE and sourcecode (250KB) for BCB5 can be downloaded from
[LINK http://home19.inet.tele.dk/lava-sys/demo.zip]
To navigate and alter settings
Cursor Move around
+/- Sun intensity
L Toggle lights
S Toggle shadows
Z/X Sidested
F Toggle fog
Shift+Cursor Move slowly around
Shift +/- Light intensity
Ctrl+Cursor Head tilt and height
Alt+Cursor Time of day
Alt +/- Texture offset
Hope this is of some interrest
Lars
(L) [2001/05/18] [Brebionflavien] [brebionf@club-internet.fr]
These are screenshots from my 3d MMORPG engine. They were taken on a P2-400
with a GeForce. I tried to show a few interesting effects, such as true
volumetric clouds and detail objects (grass) on the ground. The performance
is rather low due to many factors: no LOD (this will be my next big task),
true 3d meshes for everything (including the landscape), on-the-fly computed
soft shadows (look the mountains and the house; the sun can be moved),
and mostly, everything is dynamic (vertex buffers are refilled every time).
The application is CPU limited.
The sky and grass are animated. I tried to not abuse of the lensflare
effect, which can be disabled by users anyway. There is also the usual
stuff (particles, 3d sound, procedural terrain textures, detail textures,
collision detection, frustum culling, 3ds importer, shaders, state groups,
etc..). I am sorry for
the poor quality of the models/colors/textures used -i'm definately not an
artist-.
I am seeking a job in the game industry in France. If you are interested,
or know someone that could be, feel free to drop me a mail. I'll release
a public demo in a few days.
Thanks,
F. Brebion
(L) [2001/05/20] [StanislavScorb] [s_scorb@mail.ru]
Yes, it's a terrain stuff once again (as it's awful popular nowadays).
Here's the feature list:
- Geomipmapping as the base LOD (with geomorphs implemented), 1024x1024
terrain stuff, 1km visibility with 1 meter terrain mesh step. By the way,
fog here is just for fun, nothing about to hide view frustum culling work;
Skybox with multiple clouds layers and diurnal cycle;
Flexible object management system (under development).
This shot has been taken using Cel-600 + TNT2 Vanta (8Mb video memory).
contact with team [LINK mailto:s_scorb@mail.ru s_scorb@mail.ru]
Stanislav Scorb
(L) [2001/05/22] [FelixWeiler] [Felix@Virtual-Threat.de]
Here's a screenshot of our project called "Crimson Steel". It's a
Fantasy-Beat'em up with pre-rendered graphics.
It has a RPG-like character system (skill improvements, etc.) and several
campaigns for the two races (Dwarves & men). Furthermore, there is a
thrilling arcade mode (single and multiplayer).
The game will probably be published in germany soon.
Our homepage: [LINK http://www.virtual-threat.de www.virtual-threat.de] (german)
Greetings,
Felix Weiler
(L) [2001/05/23] [ParasharKrishnamachari] [cpi@wwa.com]
Not that long ago, someone posted an IOTD about an engine that made a scene
look hand-drawn... When I saw that, I just slapped myself on the forehead
and realized I never posted a screenshot of the 3rd version of aEmber to
IOTD... D'oh!!!
Anyway, for those of you who are unaware, this is a product of UIUC
SIGGraph which paints a 3d model to the screen in realtime. The screen you
are seeing was running at 1.7 FPS on a P-200 with no 3d hardware, and in
fact... an ISA video card *gasp*. Bear in mind that at SIGGraph conference
2000, we were given Nvidia Quadro's, so the models are tesselated to an
extent that reflects that.
The older screenshots:
- [LINK http://www.flipcode.com/cgi-bin/msg.cgi?showThread=03-09-2000&forum=iotd&id=-1 IOTD March 09, 2000] (Painter v1 screenshot)
[LINK http://www.flipcode.com/cgi-bin/msg.cgi?showThread=08-26-2000&forum=iotd&id=-1 IOTD August 26, 2000] (Painter v2 screenshot)
[LINK http://www.flipcode.com/cgi-bin/msg.cgi?showThread=09-13-2000&forum=iotd&id=-1 IOTD September 13,2000] (Comparison of Painter to ordinary rendering)
This is an entirely different method from our previous versions. This one
is dependent on the projected coordinates of the triangles and an offscreen
GL render of the scene. We tesselate the 2d triangles and sample from the
image at the resulting pixels (jittered of course). Then paintstrokes are
rendered as textured tris to the window with said color and location.
The artist who creates the model has the control over
- specific paintbrush for a given model (you can get vertex-specific
actually)
Direction and curvature of the brushstrokes
size, skewing, and other features of brushstrokes
background image (if any)
depth of tesselation for each object
degree of jittering for tesselation and color
morph response (brushstrokes changing randomly or to sound input)
What you see here is the result of 1 guy locked in his hotel room coding by
the seat of his pants at the very last minutes before presenting the App to
SIGGRAPH... Oh, well... it was fun and the project really reached the final
goal, so here's the pretty part... behold the coolness of fruit.
- Parashar K.
(L) [2001/05/28] [Graham] [Graham at deadpenguin dot org]
[LINK mailto:Graham at deadpenguin dot org Graham]
this is a screenshot from my game in development, which i [eventually]
intend to turn into a full game, ill just have to hire some others to do my
media (textures, modelling etc) anyways, onto the techy stuff
first the console, the heart of my game. the console consists of an output
and input (displayed in a dos console for servers and an on-screen display
for users and clients). when an input is proccesed, it splits up the char*
to match the command to a list in a hash table. commands are added with a
name and a function inside my code (yay function pointers) as are variables.
theyre either added beforehand as actual variables (pointers to
screenwidth/height etc). this great console allows me to test stuff quickly
and easily. oh and it loads cfg files too :]
next the terrain; (everyones doing it! <-- ive given in to peer pressure)
the whole map is tile based, with a grid of 4x4 heightmap per tile. when a
tile is drawn, it matches up the corners with the adjacent tile, so theres
no gaps(theres a bit on this at the end)
i load an image and get the average greyscale and set the height of that
particular tile's heightmap. rather than pre-determine the normals i work
them out on-the-fly as in the future the heightmap will be changed
(destructable :D)
as for drawing, ive recently switched to a new "scaledistance" (its a
varible in my console) so, (based on the viewdistance/culling distance and
the scaledistance) the further away the particular tile being drawn is, the
lower quality the tile (tiles per tile :) with just a level of 1,2 and 3.
this has helped me speed up the cfgs for lower range gfx cards :]
lastly, what i render, rather than a basic for(x=0) for(y=0) pair of loops,
i worked out a new method for what i should draw; i have a grid of bytes
(the same size as the amount of tiles existing on the map) and work out a
bounding rectangle of tile that should be drawn based on the viewdistance,
and less behind and to the side etc. then i just use a floodfill algorithm
to fill in the grid. this works a treat, saves a lot of cpu time, and is
very efficient :]
ive moved onto bringing in the networking stuff now (the site has a quick
mention on how to use it) and its going fine.
the *only* problems i have are that the method of the floodrender (as i call
it :) is that i cant to a total tri-strip render (its just per-tile atm).
Also when the scale changes, you can see gaps in the terrain as not as many
points match up (in-betweens of the heigtmaps on the tiles). my other
problem is my programmers art syndrome :]
anyone feedback is much appriciated and any solutions would also be cool.
the latest demo is avaible (and updates to the site) at [LINK http://www.uberspace.net www.uberspace.net] :]
-- Graham at deadpenguin dot org
-- [LINK http://www.uberspace.net www.uberspace.net]
-- [LINK http://www.deadpenguin.org www.deadpenguin.org]
-- icq 13548542
(L) [2001/05/29] [TimC.Schröder] [tim@crytek.de]
This is a picture of a research project I have done in my spare time here at Crytek. I
got interested in doing some Direct3D stuff, and inspired by Doom3 my work had to
be about lights and shadows. This demo uses per-pixel attenuation for the lighting,
thanks to Ron Frazier for is awesome tutorial. Unlike him, I do the setup for the PPA
inside a vertex shader, only 9 instructions. The shadows are implemented with shadow
volumes. Take a look at nVidias developer site and head for the whitepaper of
Mark J. Kilgard if you want to learn more about this. The shots were taken on
my slower home system, GeForce 256 DDR + Athlon 700. Still runs pretty fast
with 75 - 125FPS. I hope you like it, maybe you have some suggestions for a
better lighting / shadow implementation, I would love to try them out...
Tim
(L) [2001/05/31] [EricFortier] [eric.fortier3@sympatico.ca]
I decided to send you a picture from a tutorial I'm currently writing for
DirectX 8. My tutorial builds on the basic triangle sample in the DX SDK up to
what you see in this picture.
This image contains fog, lighting, black-light effect, mip-maps, Anisotropic
filtering of textures, hardware T&L, backface culling and z-buffering. This
scenes takes less than 1 ms to render in windowed mode on my P3 450, with an
Asus v7100 GeForce 2 MX video card. As you can see there's not much polygons to
draw!
As a sidenote, the lamp post was modeled and textures in Milkshape 3D, and
imported using an import class, which imports native .MS3D objects.
All of these will be covered in my tutorial which will be posted on my web site
soon. I'm finishing the second part, and as soon as I'm done with lightmaps,
I'll post them. Site is at: [LINK http://www.techlogic.ca/directx]
(L) [2001/06/02] [BrettHarrison] [loric@dnai.com]
This is a screenshot of a small java applet game I recently wrote. All the
graphics were taken from screenshots of my Iksar warrior in Everquest. It plays
like a standard columns game. The added goal is to complete Slistak's plate
armor. At first only leather pieces will fall for each armor slot. When you've
successfully connected 3 of the same armor piece together, they disappear, you
get points, and Slistak dons the new armor graphic. Progression goes from
leather -> chain -> plate.
You can play the game using your browser at
[LINK http://www.invis.com/phatlewt/phatlewt.html]
hint: once Slistak is wearing a piece of armor, a new piece of armor of that
type will drop in its place. So if Slistak is wearing a chain tunic, the only
tunic pieces that will fall will be plate. This also means any old armor piece
of a previous type can never be removed, therefore try to elimate all of one
armor piece at a time so these 'extra' pieces don't end up costing you valueable
space in the late-game.
Trying to get a foot through the industry door,
Brett Harrison
(L) [2001/06/04] [EdgarVigdal] [edgar@datapart-as.no]
Here are some screenshots of my first PC Game. It's called Warblade and some
Amiga fans may recognize it from the Amiga version called something else.... :-)
I am busy recreating the game for the PC, and also adding now stuff and goodies
to it. Playability is quit good and getting better by the day.
The game require DirectX 7.0 or later and take advantage of 3D cards.
You can get more info on the game and download an early beta version at :
[LINK http://www.warblade.as]
Edgar Vigdal
(L) [2001/06/07] [JetroLauha] [jlauha@cs.Helsinki.FI]
Purple player is having a reveng after blue had spoiled nice
hot-water-surfing-session! Blue ship is taking a bath in small pond and the
evil purple ship has just tossed in toxic waste spoiling the water
effectively. Red ship is making green's life hard and looks like that green
ship is really going to be history after one more of those big blasts.
This is a screenshot of my game I originally made back in 1996. Now I have
ported it to Windows and released the game as completely free version with
all the features originally available only in registered shareware version.
The game is aimed for 2-4 players on a single computer & keyboard as you can
see from the 4-way splitscreen screenshot. The game point is flying in
cavernous levels while shooting at the other players using some of the many
floating weapons available for picking up.
The original game worked with 486's and early pentiums pretty good, now the
recommended set is some Pentium with 32MB memory, although it should work
with a lot less. Features are roughly as follows: 640x480x8bpp (256 colors)
mode, parallax scrolling, digital soundtrack&fx.
The home page for the game is [LINK http://iki.fi/jetro/kops/]
(L) [2001/06/10] [StuYarham] [s_yarham@hotmail.com]
For my final year project at uni, I did some research into Non-photographic
Rendering (NPR) methods, especially in an area called Sketchy Rendering.
After seeing a few NPR images recently, I thought i'd send my own in. The
image is of a Quake3Areana model in various states: wireframe, textured, and
sketchy.
To achieve the sketchy effect, I do the following:
- To shade, I do a multitexture render pass using addative blending. The
first texture is a 1-d (grey-scale) texture that is indexed using Light
Direction dotted with the Vertex Normal. This is used to darken the areas in
shadow. The second texture is projected from the viewpoint of the camera, so
that it "wraps" the model. The actual texture is just a bunch of "scribbled"
lines (in grey-scale).
Manually find the silhouette edges - I have a pre-calculated list of all
possible candidates.
Add "noise" to the silhouette edge vertices (to make them look "rough").
Render them several times (3x shown) in differing shades of grey. The
z-buffer removes hidden lines from view.
The application was run on an Athlon 800 with a Geforce2 GTS (using D3D).
Without any optimisation (just got it to work :), this model (526 triangles)
is rendered on a 1600x1200 display (up close) at ~90 fps. A model with
10,374 triangles is rendered at ~42 fps. The models (or lights) need not be
static, as the silhouettes are found dynamically every frame. Although not
implemented, animated models are quite feasible.
Please ask any questions you have.
Cheers, Stuart Yarham.
(L) [2001/06/11] [dataman] [dataman@cyberdude.com]
Just another terrain engine.
Nothing special to say for now
... only that is adaptive quad tree based and it uses the "GeoMipMap"
technique (done several months before the white paper with the same
name). I use DX vertex buffers to store the patches. They are stored in
a special way, so the rendering performance does not suffer much on
cards without T&L .
You can see the dynamic lighting. I use the method presented by Klaus
Hartmann ("Texture Synthesis for Terrain" paper) to generate the vertex
normals (however, i modified it, so the grid spacing is no more needed).
The texture is dynamically generated. I use the hardware to blend the
different base textures. The terrain does not look so good (detailed) if
close to it. The problem is the texture size (512x512). I am working on
that problem. In the previous versions, i used a software blender
(sampler), but it was slow (30 sec for 2048x texture). Now, the problem
is the Blt operation needed to copy the blended texture from the back
buffer to the texture surface. It's very slow (~1.3 seconds). Rendering
to texture is not really an option, textures use to much memory.
I spent months searching for good texturing solution (big terrain +
detailed texture + LOD terrain support), but no luck for now. If you can
help me in this domain, don't hesitate. .... oh, i use detailed texture
too (not on the screen shot), but it's slows the frame rate as much as
50% (single pass multitexturing). Maybe, it's because i use the hole
fill rate and any additional operations impacts the performance.
Speaking performance, here some info : the current screen was taken with
the terrain with full detail (the Hmap is the Grand Canyon 513x513 from
Gamasutra ROAM article), 524288 triangles , directional light, 32 bit ,
resolution ~900x640 (windowed, but same performance with 1024x768) = 15
fps. But, there is no optimizations, i use borland VCL, many controls ,
and the program is full with other stuff (garbage, or not so).
My system is an overclocked celeron 300a ->450 , GeForce2 GTS 64MB
,196MB RAM.
I know, there is no sky. Do i need it really ? Yea, sure ..but later ...
If you have questions ..don't hesitate.
(L) [2001/06/13] [JesseLaeuchli] [jesse@laeuchli.com]
This is a screen shot from my 3d engine showing support for planets, which
I'm adding. There are 9800 triangles in the planet(so not a ton of detail
yet). The main feature I wanted to experiment with was using a a 2D fractal
that could be generated in real time to make the planet(as opposed to 3D
fbms or fault fractals). The land was generated with a 2D FBM multifractal.
The code for this will be on my site at [LINK http://www.laeuchli.com/jesse/ www.laeuchli.com/jesse/]
in a few days.
(L) [2001/06/14] [DimiChristopoulos] [christop@fhw.gr]
This is an effect I am currently working on, at work.
I work for the Foundation of the Hellenic World, which is based in
Athens. We primarily develop cultural and educational applications for
VR sytems (CAVEs, Immersadesks etc). So I thought I could snatch some
models from our database and do some tests with them.
I was amazed from the result and thought I could post some results to
show that you can do cool stuff with simple things.
In essence, what you see is a particle system. Each particle can have a
texture on it and change size, position, speed and color
over time. The attributes which I havent seen a lot in other particle
system implementations but look very nifty and add a lot of flexibility
are:
1) The texture changes over time. Animated textures which are preloaded.
2) The particles can be created (start vlolume) and start from random
points on a specified gemetry. The geometry has to be in .raw format.
In the first picture an ancient greek dome is put on fire. The original
geometry has been saved in .raw mode in a file. To render the scene
the original dome is rendered, and the .raw file is given as the start
volume for the particle system. An animated texture of a fire flame
(15 frames) was used as texture. In the second picture a skull model
was used as the start volume.
I also use dparticles for snow, smoke, water, foq and even light
effects.
Unfortunately we are using IRIX SGI boxes so I cant sent you any demo :(
(L) [2001/06/15] [HectorYee] [yeehector@hotmail.com]
It's output from a montecarlo path tracer I wrote. It demonstrates motion
blur (flamingo), caustics (the reflection of the gold ashtray on the wall),
color bleeding (green of the leaves on the petals), soft shadows and area
light sources.
The lighting is physically accurate global illumination. It uses irradiance
caching for indirect illumination computation, augmented by a model of the
human visual system that takes into account visual importance as well as the
sensitivity of the human visual system to spatial frequencies and movement.
More on:
[LINK http://www.graphics.cornell.edu/~hector/art/art.html]
(L) [2001/06/18] [ChristianOfenberg] [AblazeSpace@web.de]
Convey is a new Sokoban clone packed with a lot of new elements. Especially fans of
logical games will be zesty.
You control a small green and cuddlesome alien-slave which is made to transport cargo.
You have to move containers to the place that is slated for them. Such a container is easy
to move: You've to route your little alien to an object and move it in front of you ...
inasmuch there's no obstacle. The problem is not to move into a dead-end street.
However, if it happens the only thing that can help you is an extra. Beside this
basic principles there are some other defiances. As an example some boxes can
only be moved into special mountings, fields of force obstruct your way until
the correct switcher is pushed or you've to swat your enemies with the containers. But
there are some aids to help you. You're able to move the containers over a long distance
with the help of 'beamers'. The beamers can be used to bypass dead-end streets as well.
Small extras help you by giving you the force to move several boxes simultaneously or by
giving you the ability to pull the containers, what can be quite helpfully.
Some features:
- Multi-texturing
Particle system (also using mesh data)
Midi music
A demo (1.5 MB) of my game could be found at my homepage: [LINK http://www.ablazespace.de/]
(L) [2001/06/21] [TodBaudais] [tod_baudais@mac.com]
This IOTD shows the Physics Simulator/Game Engine that I have been writing
in my spare time for a little more than a year. The first image shows the
truck flipped over in the lowlands and the kinds of problems I am running
into because my tires aren't rigidly connected. The second demonstrated lens
flare. The third shows a bunch of tire tracks (the brown stuff). The fourth
shows a different truck pushing around a ball.
Images really don't show this thing in action. The Truck has full suspension
and is actually pretty neat to drive. The demo can be found at
[LINK http://homepage.mac.com/tod_baudais]. It requires a fast G3 or G4 Macintosh.
Quick list of features:
- Very extensible C++ design with minimal platform dependency
Accurate physics including:
real friction (not some hack)
collision detection/response (simple spheres for now)
constraints like spring, damper, gravity, etc. (no rigid connections
yet)
Landscapes
Geo-Mipmaps
LOD morphing
Textures generated on the fly from 5 source textures & Perlin Noise
Landscape streaming
Quadtree rendering
Tire tracks and rub marks
Lens flare
Multiple light sources
Skybox
QuickTime Support for texture loading
OpenGL
(L) [2001/06/25] [JanMarguc] [jm@kampsax.dtu.dk]
This IOTD shows an inverse kinematics engine, that we did for our final project
of a virtual reality course. The IK calculations are based on techniques found
on Hugo Elias' great page: [LINK http://freespace.virgin.net/hugo.elias/]
All geometry and bone hierarchy information was generated using 3D Studio Max
4.0 and exported using a script into a proprietary text file format. A simple
method in the skeleton class of the code lets you directly affect a specific
bone by some force vector after which all IK calculations are carried out
iteratively by the system. The IK system supports bending bones and rotational
bones, but you have to specify them yourself, since we could not find direct
equivalents to these types in 3D Studio Max. For this particular model, all
bones are bending bones except the 3 bones that connect the 3 necks to the root
bome in the front part of the dragon. This enables the dragon to turn its head
to the sides. As we didn't have specific documentation of how 3D Studio Max
stores bones and bone hierarchies, we tried out a couple of different
techniques. What we ended up with here is a representation in which Max defines
each bone as a startpoint and the name of it's parent bone. At the ends (of the
necks for instance) there will be short terminating bones. Still, we don't
guarantee that this is the way it actually works in Max (and for any model), but
for this model it worked out very well.
Things start to get funny when the program is compiled and executed on the IRIX
computer at the Virtual Reality Centre of VR-C at our university ([LINK http://www.vr-c.dk www.vr-c.dk]).
They have 3 n-vision datavisor hires head mounted displays there. Part of our
project was to add support for these HUDs such that they can actually control
the positions of the heads of the 3 dragons -- that is why the dragon has 3
heads after all ;-) To enable this option, you have to set USE_HMDS to 1 in the
main.cpp file. Due to lack of time we didn't implement rendering of individual
views for each of the dragons heads (such that a person wearing the HUD can see
what it looks like from the dragon head associated with the HUD). This shouldn't
be hard to do though, and we have been told, that there even exists a special
OpenGL library for rendering multiple views of the same scenery.
Finally, just for fun, we added a particle system for the head in the middle to
add some more action to the scene. ;-)
You may find the complete source code, executable binaries as well as the max
exporter script on my homepage at [LINK http://www.kampsax.dtu.dk/~jm/dragon]
In the demo there are a few key, that you can press:
- 'A' toggles animation on/off
'S' toggles display of the animated and initial skeleton on/off
'W' toggles wireframe mode on/off
'+'/'-' can be used to scroll through the different bones of the models.
Coloured points will show which vertices will be affected by the bone (and how
much)
You use the mouse to navigate through the scene. It works much like a
trackball:
- Use the left mouse button to rotate the scene.
Use the right mouse button to zoom in and out.
Additionally the middle mouse button may be used to move the scene
horizontally and vertically.
Jan Marguc
(L) [2001/06/26] [JadMeouchy] [Jad@Jadware.com]
"Jadlings," as I egotistically call it, is insipred by the cross-platform
game concept of Lemmings(TM), by Psygnosis, DMA, et al. The gameplay is
similar; the player guides the creatures from entrances to exits by
utilizing attributions such as climber, floater, and exploder. By
minimizing fatality rates, the player achieves high scores and recognition
by his or her peers. Eventually, the player becomes the god (through his
own eyes) that Jadlings allows him to be. On a psychological level, this
scheme appeals mainly to Populous enthusiasts; those who revel in the brief
two seconds when Neo flexes his muscles and bends the walls and world around
him.
Anyway, allow me to explain the photons above: The screener in the middle
is what the main menu looks like. "Configure" just takes you to the level
editor, where you can use the arrow keys to change tiles and the mouse
buttons to place them. Invert your eyes to the upper-right and view an
in-game screenshot. If things just aren't going your way, click on that
mushroom cloud and watch as all the Jadlings get a five second counter
hanging over their heads. Five seconds later and their innards bounce
across the map.
Features:
- Windows AND Linux
Slow Motion
Fast Forward
Pause
Level editor
24bit color
Gravity
Scaled solidity minimap
Quake-style console with commands, command listing, environment variables,
EV listing
Particle System with gravity, bouncing, fading
Visually pleasing interface (soft colors)
Nostalgic gameplay
As for the actual programming, I chose an interesting path. Just about
everything that is calculated is based on dt, the change in time in
milliseconds since the last time the world was updated. There is a big
advantage to this - the game time matches real time so it runs at the same
speed on every computer, regardless of processor. There is a big
disadvantage to this - if dt gets too high, collision detection accuracy is
pretty much out the window. So there is a rudimentary check in there
already to split up dt to the point of reasonability, but of course bugs
still exist. When using fast forward, Jadlings are often stuck inside
rocks, etc.
The game is about 80% complete and will stay that way unless someone is
interested in helping me finish it. This was more portfolio work to keep me
busy while I seek employment. Speaking of which, my resume is available
upon request ;)
A playable demo will be up at my website as soon as I upload it:
[LINK http://www.Jadware.com www.Jadware.com], Software section. Anyone interested in seeing the source
code needs just pledge a few hundred lines of code towards the ultimate
completion of the game. Thank you for the time.
Thanks,
Jad Meouchy
[LINK http://Jadware.com Jadware.com]
(L) [2001/06/27] [MartinMittring] [Kosmokleaner@Kosmokleaner.de]
These pictures were rendered with my own raytracer (with Monte Carlo
extensions). I wrote it just for fun.
The geometry is generated procedually. Some pictures are edited afterwards
to give the bright areas a glow.
I´m a computer science student. For one of my subjects (Renderig and
Animation)
I added RIB loading support. (renderman format). This is partly working.
You can find more pictures at: [LINK http://www.kosmokleaner.de/raygallery.html]
Sorry, but the explanations are in german.
Now some technical stuff (If you use this for our own work, please mention
my name - and
it would be nice to inform me about your work):
First I experimented with the distribution of the MonteCarlo directions. I
use a spiral with some random values. Take a look at Picture 25 (130min).
Then I developed a post filter. This filter blures all the pixels in a
special range. Distance between two samples is measured with this function:
f = (x1-x2)^2 + (y1-y2)^2 + (z1-z2)^2 + ( (nx1-nx2)^2 + (ny1-ny2)^2 +
(nz1-nz2)^2 )*const.
nx1,ny1,nz1 is the normal at sample 1
nx2,ny2,nz2 is the normal at sample 2
x1,y1,z1 is the position at sample 1
x2,y2,z2 is the position at sample 2
const is a tuneable value.
The blur is only done with the diffuse part of the global illumination (this
is not
perfect, I know ) and should only be done with the same materials.
The results are very good. You can get an image without grain (my shadow
sampler still
generates grain). But the best is: it is very very fast for much better
results. You
have to tune the blur constants, but this could be done in near real time.
It can be easyly extended to do futher sampling at pixels that don´t have
enouth
neighbours for good blurring.
Please forgive my english grammer - I´m from germany.
(L) [2001/06/29] [Chazz] [onethreethreesevenone@hotmail.com]
I am/was working on a game engine called 'Heylow'. It was originally
intended to resemble the game HALO by Bungie software ([LINK http://halo.bungie.com halo.bungie.com])
and I guess it still does.
It's a first person shooter, and it is terrain based, like HALO. It has 4
layered 3D texturing (rock, dirt, grass, and an optional detail texture) and
supports the Half-Life mdl model format. It's got all the essentials, a
skybox, particle system, entity system, etc.
At the moment, you run around on an island in the middle of an ocean, with
map-objects like trees/rocks/grass blades or whatever, and shoot 'bad-guys'
that are placed around the map. Your gun has a clip of ammo that needs to be
reloaded whenever it runs out, etc. There are only two guns though. I was
planning on putting a vehicle system in, but I am lazy and finish 2% of all
my projects so it's a lost cause, really.
I have an older version uploaded somewhere. ICQ me if you want the link (I
can't seem to locate the URL at the moment). 120943431.
I haven't touched this project in about a month, and before that, I had only
been working on it for two weeks. I have only recently discovered flipcode,
so I decided to submit these pics. Some of you may recognize the gun model
from Counter-Strike (the P90), I just needed something to test it with. :)
This picture was too big for me to put fullsize onto flipcode, but you can
see the fullsize version [LINK http://members.gotnet.net/chaz/heylow_screens.jpg here].
-Chazz
(L) [2001/07/02] [JoshuaShagam] [joshagam@cs.nmsu.edu]
I haven't done any graphics programming in way too long, so tonight I
finally decided to get around to playing with an idea for
hardware-accelerated radiosity algorithm I've been pondering for a while.
These are two screenshots from the 6-hour hacking session, both with two
passes of my algorithm applied.
The algorithm is actually quite simple. Basically, for every vertex in the
scene, render a low-resolution version of the scene from its viewpoint.
Take the average of all the pixels and add in the surface's emission, and
there you have the light value. I played with various weighted averages to
try to account for angle of incidence and such, but I actually got the best
results by just taking an unweighted average of the pixels on a 128x128
image rendered with a 60-degree field of view.
The algorithm is pretty slow. Each pass took about a minute and a half for
the top image (the bottom image was a lot faster, though I didn't time it).
However, once the lighting is computed, it renders at about 150FPS on my
machine (Matrox G400 running under Linux on a Duron 850). Of course, after
the radiosity is calculated, the engine is a pure polygon-pusher, so the
framerate isn't really *that* impressive. :)
A fun thing about the implementation is that you get to watch the radiosity
calculations as they're going. I got pretty dizzy when it was working on
the spheres though. :)
--
Joshua Shagam
[LINK mailto:joshagam@cs.nmsu.edu joshagam@cs.nmsu.edu]
[LINK http://www.cs.nmsu.edu/~joshagam www.cs.nmsu.edu/~joshagam]
(L) [2001/07/03] [WarrenMarshall] [warren@epicgames.com]
This is a shot of the level editor for a Lode Runner clone I'm doing. The
reason I'm doing it is to give my 2D GUI a good work out. So far it's
performing well.
It uses DirectX 8 for rendering. The GUI, and this editor, are entirely 2D
applications but the renderer DLL I have set up is capable of doing 3D as
well. I'm doing this quick game to give them both a good run and see what
breaks. Heh.
Using my GUI I was able to get this editor up and running in a few hours.
True, it's nothing too fancy, but it proves the GUI works under real world
situations and that was the important thing.
A full description and more shots of the GUI can be found at my hosted site
right here on Flipcode, [LINK http://epicboy.flipcode.com/].
(L) [2001/07/05] [JamesFingleton] [jimfing@yahoo.com]
This IOTD shows my engine (The FingleTron Engine) at
work running my small version of Star Wars Episode 1Âs
pod racer game. The Âgame allows the player to
control the pod using the mouse. It has sound (just
the engines at the moment) and pretty accurate
collision detection (polygon-polygon), which isnÂt
quite perfect yet. You can have a bit of a joyride
around a track I knocked up. The pod racer itself was
created by a friend of mine. The landscape is just a
flat plane with various mountans and rocks, but the
engine is not supposed to be a landscape engine.
The engine features loading of .3ds files (thanks to
all who those in the forums at flipcode who helped me
on this recently), OpenGL rendering, polygon perfect
collision detection where filtering is done on the
scene to speed things up, full scene hierarchy, object
hierarchies, full 3d position sound (achieved through
FMOD) and sky domes.
My VERY temporary web site where you can download the
game is :
[LINK http://www.uea.ac.uk/~u9937102 www.uea.ac.uk/~u9937102]
A friend of mine is currently in the process of
building me a much much better website that will
contain a lot more information about the engine, the
games I will create with it, and hopefully projects
other people will create using the engine.
Bye
James Fingleton
(L) [2001/07/07] [JamesBond] [raiderr1@lycos.com]
After months of on and off working, I finally finished my game. It's a Busta
Move clone, in some places Puzzle Bobble, which I created in C, using the
Allegro games library. Found at, [LINK http://www.allegro.cc www.allegro.cc]. One day I really got into this
game, so I decided to create my own version of it which is what you see today.
As far as the technology goes, it's nothing too special. I recently read an
article on particle flow in Game Developer, so I decided to put that into the
title screen of the game. I hope you like it.
The Busta Move game can be found at: [LINK http://www.cs.pdx.edu/~raider1/busta.zip]
(L) [2001/07/09] [PeterHall] [peter.hall@stones.com]
This is a screenshot of something I've been working on for my final year
project as a computing student at Imperial College (in London, UK). The
project is based on cloud rendering, and is based on a paper which can be
found at [LINK http://www.eml.hiroshima-u.ac.jp/~doba/papers/sig00_cloud.pdf].
My work runs at interactive frame rates (for interactive read > 1 fps on my
Celeron 433 with GeForce 2 MX 200). It quite happily pushes the graphics
card as far as it will go, and that's the bottleneck. I think it can be
sped up to reach real interactive frame rates with some more optimization
though...
The method uses a large 3d array to store the clouds, the cells of which are
then rendered as metaball textures on billboards. Oh, and it uses Open GL
for rendering purposes.
The work also implements [LINK http://www.cs.utah.edu/vissim/papers/sunsky/] to
draw the sky correctly, and (though you can't see it) the sun will rise,
move through the sky and then set again. In fact it's just setting in this
picture, as you might have noticed from the orange glow along the horizon...
And before anyone asks, no, you can't have a demo. It's not finished (and
it's never likely to be either... :-).
(L) [2001/07/10] [3TETeam] [3tegames@3tegames.com]
We have been working very hard for a long time. We have just finished our 2.Tech
demo. You can download the demo from our site. We are waiting your critics about
it.
In this version:
- 1) We made many changes and improvements to the training level as you will see.
2) We added Shader technology to our 3D engine. It will be improved in later
versions. Some of the features you will see are:
Water
Transparent surfaces
Animated textures
Moving, rotating etc. textures
Environment mapped surfaces
3) Dont forget to turn your speakers on to hear the background music and sound
effects.
4) You can change many features of the 3D engine&Game by using our console.
5) We improved the physics of walking, running, crouching for a better
experience.
6) We corrected the collision bug which causes you pass through the solid
surfaces.
3TE Team
Cem UZUNLAR Hakan YÜKSEL
[LINK http://3tegames.com]
(L) [2001/07/11] [LukeHodorowicz] [gollum@flipcode.com]
This is a screen shot from once of the scenes in a demo I made called
'Electric Hairgel Rave'
The demo is powered by my 3D engine, Vapor, which I have been developing in
my free time. You can download the demo and see a few more screenshots on my
website: [LINK http://gollum.flipcode.com/]
(L) [2001/07/13] [DarshanPatil] [darshanp@vsnl.net]
These are screenshots from a terrain engine I am working on.
I started with the ROAM algorithm but found the vertex popping a
little irritating and discarded it.
This is a simple quadtree (ish) algorithm (no LOD whatsoever) I
implemented in about 2 days.
I have used something I like to call coherent frustum culling.
The lighting is precalculated and the shadowmap is ultra low-res
with 1 pixel/sample.
I havent measured the fps but it feels ok on my Celeron 400
/64MB/i810.
I know the texturing is awful (its a texture tiled on the
landscape). I just put it together to send my first iotd ;)
I am working on a texture synthesizer at the moment and am toying
with the idea of using the ROAM algo to create static optimal meshes.
--Darshan Patil
(L) [2001/07/16] [TeemuVeikkoIlmariOjala] [tvojala@cc.hut.fi]
Here is some screen shots from our project called 'JäÂäkäri'. The word
jäÂäkäri is in Finnish and means 'Jäger' in german or basically anyone
fighting in the infantry, but it is quite hard to translate to English.
Anyway, this game is about Finnish army and is supposed to show realistic
Finnish scenerys, which basically means a lots of forests and rural areas.
The main specifications of the engine at this moment are:
- Forests entities with a LOD, and a super-LOD, which makes scenerys
appear to have a huge amount of trees in them.
- Procedural roads, with junctions
- Heightmap based LOD landscape engine with Quadtree visibility
determination.
- Basic collision detection for objects in the landscape, characters and
the land. Means that you can't run through trees and that you can shoot
other soldiers.
- 3DSMAX character animation system with animation layers. Ability to link
things to characters, such as weapons, helmets, radios, granades etc.
- The normal stuff : particles, fog, day/night
All the screenshots are running at interactive framerates between 30
and 50 frames per second on P3/733/Geforce2 and K7/900/GF2.
The images:
Top left: A scenery with a procedural road and some forest entities. A
barn next to the forest.
Top Right: A JäÂäkäri takes a bullet in his back. Lots of blood. Two other
soldiers standing further.
Bottom left: A JäÂäkäri standing in the scenery. Super-LOD can been seen,
but where :). The soldier is holding a 7.62 RK 62 which is the Finnish
version of the russian assault rifle AK47.
Bottom right: First person look of the game, a camp with some tents. A
medic is fixing a person who lost his guts.
There is so many things to do in this project so I won't even list them,
but our intentions is to do a full scale war game including enemies,
vehicles, multiplayer. This project has been under development for about a
year. I have been coding it by myself and I have a friend making the
3D-models, so our resources are quite limited, but I think that we have a
great job. When I started this project I hadn't heard about FlashPoint and
when I heard about it, I was full of expectations, but I got a bit
dissapointed with the demo. My idea with this game is that 'War doesn't
need one man'.
There is no demo available at this time, it is our current priority to
make a playable demo with AI enemies. More pictures will be on the net
later when the pages are finished.
The WiredMan development team
Coding : Teemu Ojala
3D graphics : Mikko Monto
(L) [2001/07/17] [Henri] [12949442@narga.sun.ac.za]
Greetings - yep... its an ATR - Another Terrain Renderer.
- this is my claim to fame :) my post-graduate research focusses
on developing a new continuous level-of-detail algorithm for terrain -
the pictures above demonstrate the algorithm in action.
Ignore the abysmal frame-rates... my PC and graphic hardware
was new back in 1996. On more up-to-date PCs the frame rates
are on average in the range of 60 to 120. (The terrain data is a
1024x1024 heightfield, no far-clipping is performed.)
The algorithm utilizes split/merging (ala ROAM) - but ignores the
idea of priority queues in favour of 4 constant-time LIFO queues;
additionally the underlying mesh structure is completely different to
ROAM's RTIN approach in favour of a form of ETRN (equilateral
triangle regular network). This mesh structure tesselates faster and
requires less work from top-most to bottom-most LOD compared to
other approaches.
Additionally the mesh structure varies quicker from high to low
detail. And it is extremely hardware friendly (in the sense that it
can be used to generate long triangle strips).
Note from the screenshots: on average there are only about half as
many vertices that require processing as there are tris in the scene.
The executable and (surprisingly short) source and a basic
description of the algorithm are available here:
[LINK http://www.cs.sun.ac.za/~henri/diamond.zip]
Press "v" a couple of times when executing to texture the terrain.
The official theoretical paper will only come in a couple of months...
so don't wait up for that one. ;)
I'd love some (constructive) feedback... so go and gimme some.
(L) [2001/07/19] [MichaëlSchoonbrood] [mfhschoonbrood@chello.nl]
I've started games programming last august. After reading "tips and tricks for
windows game programming gurus" I started working on the required first game...
a tetris clone.
Now.. A lot of the time has been spent on trying to get the 2D engine flexible
(OO design) and the rest on trying to make my Tetris clone have something
special.
This screenshot shows of the CoOp mode in action... and the comments I received
on the game so far are very positive (I never expected them to be this good!)
I would still like to know what you proffesionals think of it ;)
the game (9MB) and source (450 k) are available on my homepage:
[LINK http://play.as/madbutch]
Direct links:
HaCKeR: [LINK http://users.bart.nl/~mschoonb/downloads/hacker/HaCKeR.zip]
Source: [LINK http://users.bart.nl/~mschoonb/downloads/hacker/HaCKeR_Source.zip]
(L) [2001/07/20] [RobJames] [greeneggs.ham@virginnet.co.uk]
Latest pics from my Procedural Planet Demo. Some of you may remember my last
IOTD about 3 months ago. Things have got better since! The code is now much
faster thanks to some almost decent recursive culling - both horizon culling and
view cone culling. The whole planet is held as a bintree, with the initial
(level 0) structure containing a simple octahedron. This is split down using a
ROAM-type algo with splits based on min distance to tri plus some split tri
difference metric. The height of each vertex is set by a call to a multifractal
function. The same multifractal is used to generate the terrain texture at the
start of the demo (which can take a minute or so).
Tri's are merged when they fall outside the viewcone or fall beyond the horizon.
A tricky bit is ensuring you dont try and merge tri's which,in turn, will merge
child nodes which you want to keep split.
The wireframe show what happens if you turn merging off and zoom back out.
The bintree depth can get down to 30 or so and still remain interactive. If you
apply that split level to the whole planet you'd get 8^30 triangles!
The cloud layer is fake volumetric (10 slices of blended perlin noise).
Still to do - a decent ocean (working on GF3 per-pixel environment bump cube
mapping).
demo soon ;)
ttfn
Rob James
[LINK http://www.pocketmoon.com]
(L) [2001/07/22] [AndreKönecke] [AndreKoenecke@gmx.net]
This is my first IOTD, and it shows some screenshots from my latest
game Lemmis. Lemmis is a Lemmings-clone, and offers you most of the
originals abilities...
There are 10 different maps to complete, 4 music-tracks(mp3), sounds
and self-made graphics.
Your goal is to rescue as many Lemmis as possible, and lead them to
their home. That's it! Sound easy, but it isn't...
For graphics I am using OpenGL in Ortho-Mode(640X480), which enables
me to work on pixel-basis, and exactly determine Lemmis' positions.
I think the TGA-textures I am using are really important part of the
game, 'cause I use their Alpha-channels for collision-detection, so
that the collision-textures are easy to create and use. Of cause there
is a small particle-engine, used for the Lemmis, smashing into pieces.
The background-music is a mp3-stream using the FMOD-Library, while the
real soundeffects are played with windows multimedia-standard-api...
For Input I use DirectInput8(keyboard) and windows-mouse-input.
Lemmis is freeware, so visit my homepage, and give it a try ;-)
[LINK http://www.snake-programming.net]
SnAkE's Programming Resources
(L) [2001/07/24] [KurtMiller] [kurt@flipcode.com]
Today's image is a screenshot of an application I recently released
entitled 3D-Exe.
It came about when an artist friend of mine (Max Shelekhov) asked me
if I knew a way for him to distribute his models in such a way that people
could download and view them without needing an application like 3DSMax,
which mostly only other artists would have. After a few idea exchanges with
Max, I implemented 3D-Exe. It takes 3DS model files and TGA textures,
to produce a stand-alone executable that serves as a
viewer (requires OpenGL) for the models.
In the screenshot you see both the main application running, and an example
of an executable produced by it. The slick space ship model in the image
was created by Max Shelekhov. By the way, if you like the model, I highly
suggest you check out some of his other great artwork [LINK http://www.ghoul.pisem.net/ here].
3D-Exe is available on my recently launched company site,
[LINK http://www.gradientstudios.com/ Gradient Studios].
In addition, the full C++ source code has been released under the GPL.
I don't have time to work on this project right now yet
there's quite a bit that could be done to make this sort
of program more stable, feature-rich, etc.
If anyone out there feels like picking it up where I
left off, you're more than welcome to. Some suggestions for
improvements are in the readme.txt included with the source.
That's all. Hope you enjoy it.
(L) [2001/07/25] [GrzesioFurga] [gzesio@astercity.net]
i submited the pic to show u a blockout game i'm trying to make...since a
couple of months...
i'm using dx for input (and maybe sound in the future) and have a very lame
render function...
my first try was to compose the level of solid cubes, but now every time a
block is dropped i'm building a list of quads to be drawn to create a solid
shape of the current level....
it still get's slow when u look at it from downstairs
(due to the high occlusion and the fact that everything
depends on gl's depth test),
but with the new algo the fps stays above 30
this is my first object oriented program, my first c++ program and my first
ogl program...
i've learned a lot in those months and many times when i read bout "the
right approach" to sth it was often to late becouse i've already implemented
a stupid (but my own ;))) solution...
(if u care to look at the source u'll rotfl of the "stos" class (in
obroty.h) wich hold's every rotation the block has been through to prevent a
gymbal lock)
exe: [LINK http://www.astercity.net/~gzesio/blok.zip www.astercity.net/~gzesio/blok.zip]
(use the arrow keys, space and q,w,e to move and rotate,
1,2 to change levels and hold x to change the view)
src: [LINK http://www.astercity.net/~gzesio/bloksrc.zip www.astercity.net/~gzesio/bloksrc.zip]
big thanks to all of u and nehe (the vc workspace is still called lesson2)
pozdroofki
(L) [2001/07/27] [JanTuran] [elesgal@3dpeople.de]
Here are some screens from our isometric diablo like game engine.
The game is far to be finished but we have already a playable tech demo ( [LINK http://www.3dpeople.de/game/setup.exe www.3dpeople.de/game/setup.exe] )
Some features of the game engine are:
- rendered through directx7
fake dynamic per pixel lightning
particle system
scripted ingame movies
diablo style gameplay
true 3d objects
advanced shadow casting
great object oriented ingame editor with layers, events, fast editing
unlimited zoom
etc
The entire engine is my work, so if you have some questions, feel free to contact me ([LINK mailto:elesgal@3dpeople.de elesgal@3dpeople.de])
Jan Turan
(L) [2001/07/30] [Thomas Terkatz] [n/a]
[LINK mailto:n/a Thomas Terkatz]
These are images rendered with my machinaDX-engine ( my first directX engine (
di,ds,dd and now d3d ) ). My engine is not a very good one, but like you can
see, it supports height-maps. It's just a graphics demo and not a game, I would
give it to you, but it doesn't work anymore( why? don't know, can't find the
error, lucky that I shot the pictures before the crash!! ). There is not much I
could write about the images:
There's a terrain rendered using heightmaps, two texture layers ( stone in low,
grass in high regions ), and a lot of trees ( billboards ). The sky is a simple
plain.
(L) [2001/07/31] [SamuelCantin] [CANTIN_Samuel@ticket-accor.com]
OK OK !!!!
Ship are not mine but i like a lot HomeWorld.
Here 's 2 screenShot of my Space Application.
- Firts you can see Octree
Second you can see ship in action with collision détection.
This is not a project but just an application to learn again and again !!!!
Ok see you soon !!!!
(L) [2001/08/01] [FedericoColetto] [ninjacross@yahoo.it]
Here you can see some screen shots of the game i'm
developping from a while.
It's name is "Eternal Eclipse" and it has got some
interesting feautures like:
- Extremely big maps (100 square Km)
Dinamic terrain tessellation with auto adjusting
resolution.
Animated sky with clouds and transparent gas
3D holografic map
Quake-like controls (first person shooter)
You can find more detailed infos, screen shots and
downloads about it in my website (Programming area).
The url of my site is [LINK http://www.ninjacross.it]
If you have some suggestion, please let me know, all
your help will be fully appreciated :)
You can contact me by email at [LINK mailto:ninjacross@yahoo.it this address], or by ICQ at this number:
48885908.
Thanks in advance to all for your help !
Federico Coletto
(L) [2001/08/03] [Crowe] [n/a]
[LINK mailto:n/a Crowe]
While this is not done in real time, this is a particle system I have been
working on for some time. It contains 4 distinct partcile systems and over
3000 particles per frame.
While this is not an application but simply graphics, I wanted to share it
with the rest, as it was quite an undertaking. I wrote the shader in
Renderman's script and wrote the tornado script in 3dsmax's script. I can
select a path and apply my script. The tornado will start on one side of
the path and dissipate on the other. The funnel is fully animated and
twists on its own via a noise modifier.
I have yet to add the debris element, but that is next, allowing random
meshes to be used as debris within the tornado.
(L) [2001/08/05] [OztanHarmanci] [oztanharmanci@hotmail.com]
This is a game project(totally amateurish) I've been working on for about 4
months.(Actually we are a group of 3 but I am the only coder) Features are:
- Lightmaps(Radiosity or simple raycasting. But radiosity is not optimized
yet so these shots are raycast lighted)
Collision system(Greatly modified version of Paul Nettle and Telemachos's
ellipsoid-poly collision detection and response)
CSG to WorldCraft 3.3 MAPs
Some eyecandy: glows, transparent surfaces, animated textures, switched
textures, simple water wave effect)
MD2 support
OpenGL for rendering
DirectX 5.0+ for DirectInput and DirectSound(why not 8.0? I dont have the
SDK and samples from my MSDN CD were for DX5.0)
Releasing this tech. demo was a deadline for me, now I will go back,
optimize and polish the preprocessing tools and start working on enemy AI. I
hope I can finish this project because I am really really sick of seeing
things in first person view :).
Your feedbacks are greatly appreciated(more if you test the demo and post
resulting FPS and your machine properties here)
Download Website: [LINK http://www.geocities.com/proje_x/]
Cheers.
PS: Guns are from Action Quake2, textures from CS, HL.
(L) [2001/08/06] [EliEmerson] [eemerson@gamebox.net]
I'm a flipCode fan, and come to your site almost everyday. So I had to let you
guys be the first to know that one of the games I worked on in the past, is
finished and available to the public! "Matrix Attack" won an IGF student award,
and was first seen at last years GDC. I'd like to point out that this game is a
student project from [LINK http://www.digipen.edu DigiPen] from 1999. My team and I finished
version 1.0 in one semester (3 months) the updates over the summer took about 2
weeks. I hope to polish and release the other titles I've worked on, as there
are allot of good games that my fellow classmates and I have made that need to
be released.
Matrix Attack doesn't really show off anything technically, its all about
game play with this one. In fact the gameplay is so different that I strongly
suggest you read the readme file to understand how to play. Once you guys figure
out how to play though, it's a BLAST!
Please play the game before you put a message on the board! I'd love to hear
what you guys actually think about the game, rather than the screenshot you see
above. And if you want, let me know how well you did in Time Trial mode and/or
Puzzle mode.
Alright enough talk, go play it!
You can find Matrix Attack at the digipen project download area:
[LINK http://www.digipen.edu/downloads/MatrixAttack/]
At my personal website you can find out more about Matrix Attack and its
development.
Goto the projects section of my website to find Matrix Attack.
[LINK http://www.eemerson.com]
A fellow code monkey in the jungle,
Eli
(L) [2001/08/07] [Louis-CharlesDumais] [lcdumais@hotmail.com]
Hi, First let me introduce the URL then I will explain what Genu is all about:
[LINK http://www.gel.ulaval.ca/~dumais01/genu/]
Genu is an interface to C++ which responds to some hiatus of the langage. Genu
is here to respond to the none intuitive approach of text base c++ and the
increasing complexity of projects generated by the open source community.It
brings to the user:
- Intuitive approach to programmation with the analogy of C++ and tree.
Interface for managing complex projects and instant recognition of important
part of the program
Thank you
louis
(L) [2001/08/09] [AustinAppleby] [aappleby@austin.rr.com]
8,000 Butterflies at 100 frames per second - no assembly, no hardcoding, no
hacks.
These are three shots from a test of the particle system in my experimental
engine (currently named Pandora). The butterflies are completely dynamic and
are independently animated - no precalculation. When the butterflies flap
their wings they climb higher, and when the don't flap they glide down. The
butterflies are all different sizes, and smaller butterflies are faster than
larger ones. There's also a simple physics model (a force field) that
corrals the butterflies into a donut-shape.
Each butterfly is a separate C++ object, and each uses virtual functions to
implement its behavior (they derive from a CParticle base class). Before
people complain about the performance penalties of virtual functions, I've
extensively benchmarked the virtual function overhead here and it's
practically negligible. The particles are moderately memory-inefficient, but
that can be cleaned up quite a bit with a custom allocator. There are
exactly 0 lines of assembly code used in the particle system code - the
particles themselves are straight C++, and the vector math routines
underneath them are hybrid C/C++.
The geometry for each butterfly is essentially a square folded down the
diagonal, and is built with 8 vertices and 4 triangles (4 verts and 2
triangles per side). The current version renders 8,000 butterflies at 95-100
frames a second on my development machine (a P4-1.7ghz + GeForce 3), or
approximately 800,000 particles per second (3.2 million triangles per
second). It doesn't use any GeForce 3 or Pentium 4 specific features (no
vertex shaders, SSE, etc.) though it does use some NVidia-specific OpenGL
extensions (mainly NV_vertex_array_range).
I wrote this demo just to prove that you can get excellent performance out
of a C++/OpenGL engine without any sort of hacking or assembly
optimization - as long as you keep your code efficient and benchmark every
one of your changes, you can usually avoid any performance bottlenecks. I
probably won't be releasing the full source code to the demo (as that would
require releasing huge chunks of my still-in-development engine) but I can
write up a quick overview of the techniques I used if enough people are
interested.
-Austin Appleby
[LINK mailto:aappleby@austin.rr.com aappleby@austin.rr.com]
(L) [2001/08/10] [YordanGyurchev] [yordan@gyurchev.com]
The CurvCloth demo is a simple cloth effect that uses lattice of springs and
curved surfaces. (very simple, trivial, unstable, unoptimized
implementation).
You can find more tech details in the text file included in the zip archive.
(CurvCloth_v1.0.zip) [LINK http://www.gyurchev.com/files.html]
I'm trying to measure the quality of my coding style (readabilty,
maintainability). If you are interested in helping me with that, please
download the source and send some feed back on the following questions.
- Do you think the code is readable?
What do you think I should change in my coding style?
Were you able to understand the code or you had to look through it
several times?
How about the comments? Too many? Insufficient? Senseless?
What did you like/dislike about this source code?
Please send your comments, responses, suggestions to this thread or mail to:
[LINK mailto:yordan@gyurchev.com yordan@gyurchev.com]
Thanks,
Yordan Gyurchev
(L) [2001/08/11] [flipCode] [web@flipcode.com]
Assuming your web browser didn't explode while trying to load
that enormous image, you'll have surely realized by now that today is the Image Of The Day's
2nd anniversary! Just before August 11th, 1999, I managed to talk Luke Hodorowicz into snapping
a [LINK http://www.flipcode.com/cgi-bin/msg.cgi?showThread=08-11-1999&forum=iotd&id=-1 shot] of his engine
for a new feature I wanted to launch on flipCode.
2 years later, as Luke and I discussed ideas for the 2nd anniversary image, he suggested featuring them ALL at once.
Take a moment to look over more than 450 reader-submitted images!
That's a heck of a lot of pixels, many of them arranged in ways that've no doubt inspired us all.
Cheers to everyone who's featured an image here. Keep 'em coming!
-Kurt
(L) [2001/08/12] [RyeTerrell] [ryeterrell@ryeterrell.com]
This is a screenshot of a game I have been working on for a little bit. I put
it together with DX 8.0 and VC++ 6.0 while soldiering in Bosnia for four months.
I was working on a laptop at the time, and needless to say, was lucky if I could
pull 30 fps out of it.
When I got back home though and tried it out on my 600mhz PIII with a voodoo 5
card, it fairly screamed. I haven't done an fps check on it since I got back,
but I had to lock it down to 30 fps to keep the game playable.
Anyways the object of the game is to avoid getting crushed by the blocks.
Cursor keys move you around, while spacebar makes you jump.
I'm pretty sure I'm going to give up on this game - the eye candy isn't SO bad I
guess, but I find it monumentally boring.
I'll put the game up on my website so you guys can download it and end it's life
with your critiques. ;)
Should be a pretty short download, like 2.5 megs.
Oh, and before I forget, the music and textures are not mine. I just downloaded
them and plugged 'em in. ;)
Enjoy!
[LINK http://www.ryeterrell.com www.ryeterrell.com]
Rye Terrell
(L) [2001/08/13] [Sven] [udu7@rz.uni-karlsruhe.de]
This Demo, Spooky-3D, was part of the Karlsruher Museumsnacht last weekend (
4.8.2001 ).
It was presented in front of the Kalrsruhe Palace on two video-beamers which
projected from the balkony to the floor in front of the Palace.
The first projection was aimed to the tracking area, i.e. if someone
entered/crossed this area, he or she was followed by a lot of theese yellow
points (bottom right image).
This was made possible by an infrared-camera with 2 infrared-spotlights which
was mounted beside the beamers. The camera was connected to a computer with a
tv-card, which evaluates and sends tracking-data of persons in this area via
midi (coordinates as notes) to my two computers, where the demo was running.
But it was really difficult, to set up the projection so that the position of
the people matched the projected position of the yellow points.
The second Projection was a complete demo which integrated the tracking area of
the first projection in 3D (upper left image) and 2 other effects (bottom left
and upper right image). In the 3D-Version, you also can see the Karlsruhe Palace
as wireframe (thx to Julia) and a lot of camera flights.
The Demo was coded in alround 3-4 weeks and it is based on my 3D-Engine (3DED)
which uses OpenGL for 3D-Acceleration.
The soundcapturing from line-in was done by using the standard wavein-commands
(no direcx or something) of the multimedia-libary. I've also implemented a
simple fourier-transform to get the beats of the music.
If you want to take a look at he Demo in action, you can get it [LINK http://wwwrzstud.rz.uni-karlsruhe.de/~udu7/cgi-bin/Source?x86demos.html here] (simple
click on a screenshot)
The source is included too.
[LINK mailto:udu7@rz.uni-karlsruhe.de Sven]
[LINK http://islands.cjb.net islands.cjb.net]
(L) [2001/08/14] [cgk] [cgk.d@gmx.net]
This is a screenshot of the editor to my gfx engine "Vision3". There is
still a lot to be done, but the engine already features:
-sector/portal visibillity using sectors and portals generated with a CSG
based algorithm. I've never seen such an approach in any app, but i think
this is a very innovative technique, as it generates really good
portalization with nearly no processing time and not too much to care for by
the artist.
- an advanced high lvl CSG algorithm, which leads to damn fast rebuild times
damn fast rebuild times :)
a geometry optimizer caple of removing practically all unnecessary geometry
splits introduced by CSG
collision detection using per sector BSPs and portals
lightmaps and vertexlighting
rendering using DirectX8
the nemesis of every MFC programmer: an editor with an UI which can
actually handle resizing windows and dialogs! ("bla.Anchors := [ akLeft,
akRight, akTop ]" ...) ;))
the next things i want to do are:
- add support for external objects (like decoration, done in 3ds or
something)
add more material features (or better: implement them :) )
improve the lighting system by adding more light types. (i'm very
optimistic that you can fake equal or better looking results than most
radiosity implementations feature with simple stuff like normal raytraced
pointlights, ambient pointlights, "ambient directional pointlights (:))" and
stuff like that ... and still have an acceptable rebuild time^^)
I'm kinda proud of the project, mainly because i've done it on my own. The
ideas and algorithms for the CSG, geometry optimizing and portalizing were
all 100% generated in my mind :) (although that doesnt necessarily have to
mean that no one generated them before *g*). I've come farer than i
expected...
I just released the first "public" preview of my Editor to show off my tek a
bit ;).
The project homepage is at [LINK http://pc.exit.de/vision3]. There you can find
more infos, screenshots and - of course - the editor download (although the
demo "level" still suffers from "programmers art" quite a bit... so if
anyone would make something cool with it, i'd like to see^^).
Gerald "cgk" Knizia
(L) [2001/08/15] [RobinWard] [robin@robinward.net]
I used to be heavily into game and graphics programming back in the early
nineties
when it was all about mode 13h. I let it slide for a few years in order to
concentrate
on web programming and Java development.
It's back with a vengeance. I decided to build a simple 2-D shareware game,
and this
screenshot is the result of my efforts. The game engine is 95% done (I have
to
program a few more enemies), and I have about 10 out of 30 levels complete.
It's more of a puzzle game than anything else. Different levels have
different
objectives (such as eat all the pizza, flip all the switches, etc). It's a
fairly
standard 2-D game. I originally wrote it using DirectX 8, but after I found
that it
wouldn't work on NT and computers that haven't upgraded, I decided to port
it to SDL.
SDL is great, in that the renderer will actually use the GDI if no DirectX
install is
found. It's really reducing the DirectX barrier of entry.
In the end, I plan to self-publish the title. I'm going to sell it on my
web site
as well as by mail order.
The game is lacking a title, so I was wondering if anyone can suggest one?
Also, how
much do you think someone would pay for this kind of game? Bear in mind,
I'm not making
it for the hardcore gamer, but for children or adults or who want to play a
puzzle game.
I was thinking $20US.
You can e-mail me at: [LINK mailto:robin@robinward.net robin@robinward.net]
(L) [2001/08/17] [JaapSuter] [J.Suter@student.utwente.nl]
Here are some shots of my very first Gameboy Advance (GBA) programming
adventure. The past few weeks I've been on vacation in France, and every
afternoon I would do some GBA programming on my laptop. Lying by the side of the
pool, programming, with a view on the mountains. Very nice!
Anyway, I started working on a project called Socrates. It's an object oriented
library for the GBA written completely in C. Object Orientation in C? Yes, it's
possible.
The library is written for MODE-4 graphics. This is the only full-screen video
mode that supports double buffering. The only drawback is that it's a 8 bits
palettized mode, and that you can only plot two pixels at a time. So if you have
to write one pixel, you must read-modify-write. However, this proved to be quite
a funny obstacle in my polygon drawing routines.
About the images, from top to bottom, left to right.
- 1. Some crossfading of images. Speeding this up was quite difficult. It's still
not at full speed. I probably gonna need some ASM for this.
2. Shows a couple of flatshaded cubes, with frustum clipping as well.
3. A couple of flatshaded cubes without frustum clipping.
4. Title-screen.
5. Kind of texturemapping, plasma, -ish effect
6. Two texturemapped cubes with frustum clipping
7. 8. 9. 10. More of the same.
The 3D engine is completely fixed point and I'm quite happy with the speed raw C
delivers. Soon I'll add some inline ASM to speed thing up, but for now I'm
focusing on getting some more functionality done. Though, Quake like 6DOF is not
gonna happen on GBA. Unless somebody proves me wrong.
Currently I'm working on a voxel landscape on GBA but I'm rather pessimistic on
performance issues. I suppose I'll have to start doing some sprite, tile,
background scrolling stuff soon.
Overall, I love it. Working for a machine with low performance but a complete
set of fixed functionality. No more compatibility issues. Jippie.
By the way, it works on the real thing as well. Thanks DarkFader.
(L) [2001/08/18] [TimC.Schröder] [tim@crytek.de]
Well, I thought it's time to share some new pics from my current engine.
Basically it is a GeForce 3
optimized FPS engine, with 100% dynamic lighting as the main feature. All the
shots you see here have
a preprocessing time of 0ms, except the 500ms for the Octree during the level
compilation;-) I tried to
get the lighting model working on GF1/GF2 cards, but I failed. Not possible. At
least it screams on the GeForce 3. Well, I guess you want to see the feature
list, here it goes:
- Vertex.. ahh... SMARTSHADER(TM) for basically every triangle on the screen
Pixel shaders for the entire lighting
DOT3 diffuse + specular per-pixel lighting on every surface (Well, not on the
skybox...)
Per-pixel normalization cubemap or pixel shader normalization for every
surface
Tangent space setup done by vertex shaders
DOT3 self-shadowing
PPA for every surface
Realtime general shadow solution, everything shadows on everything including
on itself
Colored lights
Blinking, flickering and pulsating lights through a shader definition file
Lights can be assigned to splines
Detail texturing
Hyper texturing
Advanced vertex buffer optimization code to gurantee best T&L performance
Light flares + coronas, implemented through vertex shaders
Ellipsoid based collison detection / handling
Realtime in game light editor, modify every aspect of the lighting without any
reloading
Configuration system allows you to change basically everything without any
code rebuild
Basically any damn 3D feature in the world. If it is not supported yet, it
will be in the future
The engine is incredible CPU limited at the moment, this is my main problem.
Rendering brute
force is sometimes even faster than performing HSR. I can render 4 quad texture
passes without
much drop in performance. The CPU code isn't sooo unoptimized, but the GF3 is
card that handles
everything you throw at it and just screams for more, so my crappy 700Mhz
machine can't keep up.
If you are interested in a discussion about realtime lighting algorithms, you
know my mail. Note:
A discussion is a conversation between to similar skilled people that learn from
each other. So please
no "Teach me how to do this !!!" mails. I'm quite busy with my work and writing
my engine, so really
no time for tutorials / explanations, sorry ;-(
Anyway, comments welcome.
Tim C. Schröder
(L) [2001/08/19] [BrunoHeidelberger] [beosil@swileys.com]
The above picture shows a few models animated with [LINK http://cal3d.sourceforge.net Cal3D],
a free skeletal-based character animation
library I am developing in my spare-time. It will be used in the 3d clients
for [LINK http://www.worldforge.org WorldForge], but its design is very general
and flexible, so many other projects can benefit from it too.
Here is a list of the most interesting features:
- Transformation of vertices and normals according to one or more weighted
bones (no hardcoded limit).
Powerful animation system that allows seamless blending and mixing between
different animation tracks.
Flexible material handling with unlimited materials and map-channels.
VIPM for level-of-detail that takes material borders into account.
Platform- and graphic API-independency. Written in "vanilla" C++ and STL.
Unified exporter framework to support different 3d modellers, currently
working with 3d Studio MAX / Character Studio.
Released under a free license, source-code and all specifications are open.
A short description of the stuff you can see in the screenshot:
- An animaton cycle of a segmented skeleton with rigid bone-assignments on
the bottom.
A one-skin paladin with about 18 different materials and up to 5 influences
per vertex on the top-left.
Tux doing some sort of hip-hop in the middle.
A high-poly model (~50'000 faces) that was used to test the LOD algorithms
in the library on the top-right.
An animation system is hard to present with a screenshot, so I suggest you
take a closer look at The Cally Demo which shows many features in an
interactive way. It can be found on the [LINK http://cal3d.sourceforge.net project website] with everything else, such as more
screenshots, source-code, file-formats, message-board etc.
That was my humble part, now I am eagerly awating your critical feedback ;)
Regards
Bruno Heidelberger
(L) [2001/08/20] [DavidHunt] [david@huntd.demon.co.uk]
Here are a couple of shots from our game which is in mid development.
The game is called Ghostmaster - the idea is you've got to scare people from
their homes - the more you scare them the more energy you get the better the
hauntings you can command.
Our company is Empire and our team is called Sick Puppies, we're based in
Oxford England.
The game features fully photon mapped pre-lighting. What this means is that
we generate our light maps by simulating photons flying about the scene from the
various light sources. Each time a photon hits a surface it splats a bit of it's
energy onto the surface and some of it is reflected. Eventually if you leave the
compiler running long enough you get wonderfully warm, diffusely lit scenes
which look unlike anything you've probably seen in games before. A level has to
be lit over night to get good quality.
For more shots see [LINK http://uk.geocities.com/ghostmaster_stuff/] - these are
all in game shots, not pre-renders and the game is running at speed.
David Hunt
(L) [2001/08/21] [JeffH] [jefftoe@scarbowl.com]
Does anyone remember this board game? Avalon Hill, went out of
print about, oh... 1979? Well, it was and is still one of my
absolute favorites. I was a teacher a few years ago and while
the students were working indivdually, I made this game on the
instructors' PC on the projection screen so they could watch.
I like how it ended up, and is about 75% complete.
Because of what I was teaching, this is done in Visual Basic
6 and DirectX 7. Although I would definitely use Vis. C++ now,
it really works well as it is! It's a turn-based wargame, and
the animated explosions look great. The ships are rendered in
TrueSpace 4. The textures on the ships are the front of an
Albertson's grocery store(stone, windows with fluorescent lights
inside) in Fort Worth, Texas. I have moved to Phoenix, AZ...
While not complete, the AI is simple influence mapping.
I wish I could post it here, but the board game is owned by
Avalon Hill, owned by Hasbro. Uh oh, right? I ain't gonna be
sued. They would never release it, the market for this kind
of game is so low... I just wish I could speak to the guy who
made the board game twenty-some years ago... [Garret Donner (Also made
"Wizard's Quest" and "Dragonhunt")] I am working on another
project, which you will see soon. I'll get a publisher then.
[LINK http://www.negativeutopia.com www.negativeutopia.com]
(my page is down because I moved, but these "picts of the day"
stay up for a long time, so I gave my URL anyway. It will be up
in a week or two...)
(L) [2001/08/23] [Pet] [psoroaga@websci.ro]
This is a screenshot of a small screen saver I wrote in the past to test my
particle system. I just want to make it available to other... maybe some will
like it :).
Each particle, like usual, have it's own life time, speed, direction. The
particle system is just a small part of a 3D engine I'm working on.
Onother feature used in this screen saver is camera key frame animation.
The rest... just ordinary 3D.
You can download the screensaver from [LINK http://www.geocities.com/whiteblobs here].
Pet
(L) [2001/08/24] [JohnKelly] [seacowgames@msn.com]
These are some screenshots from my game in progress titled Offshore Sailing.
Some of the features are:
BST for collision detection between objects (mainly the boat and the water).
Realistic physics that you would normally experience while sailing between the
boat's heading, angle of the sail, and wind.
Billboards are used for the pseudo-LCD wind/boat speed/directions. I flip
through different uv coords to simultae them turning, and do the same for the
buttons (I just created a bunch of textures with the different buttons in their
down state).
Alphablended skydome used with a hazy blue fog color blends the horizon pretty
well. If I can state how I did this, I created a texture with a rainbow effect
around what I thought were the edges of the skydome. Then, when placed in the
game, I could see which color appeared on the edge of the dome, near the
horizon. I took that color off, then had my template for creating the sky
texture (white clouds, black background, turned on alphablending, the sky gets
drawn with the blue fog as background and white clouds showing).
Some of the things I am working on before releasing it for this holiday season
are:
More scenery, shorelines, boats and weather.
Multiplayer support.
I am really excited about finishing this, now that the physics work correctly,
the engine can be used for other types of simulations. Any games I create, as I
said in a flipcode thread of yore, are meant to be education, fun, and
non-violent (and hopefully not boring).
What I need help with is some constructive feedback from fellow Flipcoders, and
would really appreciate if you could download my demo at [LINK http://www.seacowgames.com www.seacowgames.com] and
let me know if it runs!
Sea Cow
(L) [2001/08/27] [JustinEslinger] [blackscar@ticz.com]
The screenshots above are from our recently released tech demo, called
"Tropical Storm".
Currently, the engine supports the following :
- Huge Outdoor Levels.
Deformable Terrain; Dig trenches, hide in craters made by artillery fire,
etc.
Dynamic Skeletal Animation System
Multiple Levels of Detail for models
Advanced Particle System Effects
Advanced Menu System (Including windows, text boxes, etc)
Direct Input
Direct Sound w/ 3d Doppler Effects and Customizable Effects
Direct Show for MP3 playability
The story is not finalized yet. Basically, it will involve a variety of
realistic scenarios over the course of a campaign. Expect to storm beaches,
defend against counter-attacks, and lead offensives.
This tech demo demonstrates what we have been working on for several months.
It suffers from a severe case of programmer art and animation. We are
currently looking for students to fill the following positions :
- 2d Texture Artists
2d Model Skinners
3d Modellers (Experience with bones/MilkShape 3d is a plus)
Character Animators
Sound Technicians
Music Composers
We are hoping to have a fully playable game for the Student Showcase in
January of 2002.
Justin "BlackScar" Eslinger
Project Leader/Character Programmer
[LINK mailto:blackcar@ticz.com blackcar@ticz.com]
Digital Awe - [LINK http://www.impact-gaming.com/digitalawe/]
(Expect a second and final tech demo within a month or so, which will
include killing and playing against mutliple players!)
(L) [2001/08/28] [DominicMorris] [dominic.morris@eidosnet.co.uk]
This is a combination of yet another terrain algo. and some basic physics
for flight modelling. It's nothing special, and will only look right on
geforce series: it's been developed and tested on a GF2 GTS.
VC6 source and Win32 EXE are available at
[LINK http://62.255.178.44/x7d_flipcode.zip] and
[LINK http://62.255.178.44/x7d_flipcode_source.zip].
Press Alt+1 when you run it, to move the camera to flight mode). Cursor keys accelerate and break, stear
w/ the mouse. Ctrl+Alt+1,2 and 3 change the fighter's skin, and Alt+S and
AlT+1 are the two camera modes. Ctrl+W for wireframe. Apologies in advance
for any bugs!
The only thing that I'm really proud of in it is the performance increase
that I've got compared to my last app. I get a throughput of around 3MT/s
which is much better than my previous effort. Also collision-detection
doesn't kill performance as it used to before...
Tech stuff:
terrain heightmap is 512x512 split into 8x8 patches.
each patch is precomputed at 64x64, 32x32, 16x16, 8x8 and 4x4.
patches are organized in a quadtree for vis. culling.
texturing is 2 tex single-pass with fixed-function shading - this is where
non-gforce cards screw up!
Hope you like it!
dom.
(L) [2001/08/31] [SeanWilson] [wilson@smiley-face.freeserve.co.uk]
I thought I'd send in something a little bit different. I've written a Java
applet that combines a depth-map and a pattern to produce
stereogram/"magic-eye" images. If you've never heard of them before, they
are pictures that hide a 3D image which can been seen by focusing your eyes
in a certain way. The algorithm for producing these is actually very simple
to implement.
Here is a diagram of light-rays bouncing off a point on a object and into an
observer's eyes, who is focused on that point:
Object point
/\
/ \
/ \
/ \
/ \
/ \
/ \
Left eye Right eye
The way you see is very complex, but basically both eyes are seeing the same
image so your brain can tell how far away the object is based on you focus.
Now, imagine placing a piece of paper between yours eyes and the object and
colouring in where the light-rays intersect it:
Object point
/\
/ \
/ \
---x------x--- Paper
/ \
/ \
/ \
Left eye Right eye
As long as your eyes are still focusing at the same point (*not* on the
paper) your brain is fooled into thinking that the light coming from the two
nearby points is actually from one point further away. Also, observe that if
the object was to be moved closer, the intersections would be closer
together. So, by placing matching pairs of points in an image and focusing
differently, you can fool the brain into seeing a 3D image from a 2D one.
If you have trouble seeing stereograms, I'll give you some tips. Make
sure your eyes are parallel to the horizontal edge of your monitor and you
are positioned in the middle of it, otherwise the matching points won't
align properly. Focus behind the screen to start with by going slightly
cross-eyed and keep adjusting focus until another image begins to appear. If
you don't have this much control on your focus (some people find that
difficult), just stick your eyes against the monitor and slowly move your
head back without trying to focus on the monitor. There's no reason why
anyone can't see them, so just keep trying.
Also, viewing this image at a 1280x1024 resolution, I can see the stereogram
easily at sitting distance from my monitor. If the image appears bigger on
your screen, you will have to move further away to see it (which most people
will find much harder).
If you want to try out some more stereograms and view the source code for
producing them, along with some other applets, go to
[LINK http://www.smiley-face.freeserve.co.uk/programming/ www.smiley-face.freeserve.co.uk/programming/]
(L) [2001/09/01] [ZhuYuanchen] [wedelec@online.sh.cn]
Shown in the screen shots is the implementation of my terrain CLOD algorithm at
work.
Features of the algorithm include:
- quadtree based VFC.
frame coherent view-dependent CLOD meshing.
geomorphing.
LOD accuracy adjustment, my version of the "cluster ROAM bintree",4x subdivide
in the implementation.
low mem consumption, 1-4 bytes per height sample, further 4/16/64 cut by LOD
accuracy adjustment.
and a lot more.
Features of the implementation include:
- optimized for TNT2 class hardware, as I developed it on a PIII 500+TNT2 pro.
(yeah I know about the debate of CLOD on T&L hardware, but it's really possible
to get fast CLOD implementation on T&L hardware, see the ROAM discussions in the
gdalgorithm list).
2M tps on TNT2 agp2x+PIII500 @40-50 fps. 4M tps on my laptop GeForce2 GO! agp4x
+ mobile PIII 1G @ 60fps.
SSE optimized geomorphing code.
the usual "landscape stuff":sky box/texture systemization,etc.
A demo is available at [LINK http://www.tbns.net/davidz www.tbns.net/davidz]. Note that the sky-box texture
quality is quite bad because of JPEG compression, and the size of the landscape
is 1025*1025. A NVIDIA TNT card or better is recommended. I once noticed texture
seams artifacts on a ATI Rage 128, so please avoid ATI cards.(sorry, never got
the time to fix it). Ah. And the thing is done in OpenGL, really nice for
prototyping.
Happy coding.
Zhu Yuanchen
(L) [2001/09/03] [JariKomppa] [solar@icon.fi]
Here are some images captured from my textfx4 library.
Yes, it's sanity check time.
The library supports two output modes; 'blocky colors' mode and 'ascii art'
mode. It all looks *much* better in action, naturally..
The library can be downloaded from my site at [LINK http://iki.fi/sol]
(L) [2001/09/05] [ShlomiFruchter] [shlomif@bezeqint.net]
The picture is taken from my demo "Per Pixel Lighing and Bump Mapping". In
my Demo I combine two features:
- A. Per Pixel Lighting:
Using GeForce's Register Combiners I calculate the Intensity (= 1 -
Attenuation) per pixel, When the attenuation is (distance from light
source)^2 / (light source's radius)^2. I calculate this using two textures,
and using the Vertex Program in order to set the UV coords. for more info
please check nVidia Developers's homepage or email me.
B. Per Pixel Bump Mapping:
I am using Normal Map in order to get a normal per pixel. I am also using
the Vertex Program in order to set the color of the vertex to the light
vector. Than I can calculate N' Dot L Per Pixel (Using the GeForce's
Register Combiners).
If you want the demo, please contact me. Note that the demo will run only on
GeForce's Family product, with the latest drivers.
Thanks,
Shlomi Fruchter.
(L) [2001/09/07] [ChristianOfenberg] [AblazeSpace@web.de]
AblazeBall is an skillfull game with random generated levels. The game goal is
to bring up two big fire balls into an
ablaze space in the middle of each level. This could be done by pushing them
there.
Because your 'passengers' are not loaded at the beginning and therefore couldn't
be moved you first have to give them fire by
collecting sparks which you have to hand over to the big balls.
This task is complicated by steady increasing water... because fire and water
don´t like each other and therefore you should
avoid the water as good as possible.
But fortunately you have got the ability of terraforming, and so you have the
possibility to build something like an 'marble path'
on which you could move your protege in a save way. Further game objects will
make your life more comfortable...
Some technical details:
- Using Fmod for sound and music
Hardware-multitexturing
Use field of view culling to cut of the stuff which isn't visible
Using quadtrees to optimize the field of view culling
The terrain could be manipulated by the player (update of the quadtress
required...)
The balls burning the earth using vertex colors
The game speed could be changed using an cheat to create the well known
'slow-motion'-effect
Pictures created of animated particles
Lightmaps
Correct collision detection and response if two balls collide
Lens flare effects
Using the Intels-Jpg-Library to load in jpg pictures
Using the funny lock array function which has no influence on the framerate...
Buh, I think that enought for now...
The game is freeware and could be found at: [LINK http://www.ablazespace.de www.ablazespace.de].
The source-code is also free available!
(L) [2001/09/10] [VladAndreev] [goltrpoat@hotmail.com]
With all the references to 'programmer art' as of late, I figured I would
submit some of my own. This is a compilation of three drawings I did at
work, generally while waiting for people to check in their code so that I
could check in mine. These were all done in MS Paint and PaintShop Pro (MS
Paint to draw the outlines and fill in solid colors, PaintShop Pro to do
everything else). All handdrawn with a mouse and standard tools
(lighten/darken/soften/smudge, etc). No filters, except for the mosaic
filter on the old guy. The old guy's raincoat type thing and hand are
severely unfinished, I basically ran out of time on that one and never got
back to it, so they're basically a placeholder. The old guy and the gothy
looking chick went through a series of transformations, the old guy was
originally dead, but now he looks more or less alive. Still got some signs
of decay though. He lost his earlobes somewhere along the line, and I think
he's a little concerned about that, hence the wistful look on his face. The
goth girl originally looked like the guy from Rocky Horror Picture Show, and
was briefly a vampire, before taking on the form in this picture. She later
changed into a summer goddess type creature with leafy skin and green hair,
but that one's still very unfinished. The mask is the only drawing here
that I started out knowing what I was going for and ended up with exactly
what I wanted.
-goltrpoat
(L) [2001/09/14] [MeanFox] [meanfox@meanfox.com]
Here is a screenshot of a free 3D screensaver I made recently. ItÂs called
RocketSaver and you can download it and other free 3D Mean Fox screensavers from
[LINK http://www.meanfox.com]
My friend Calle Wollner modeled the rocket. Some of you may recognize the
design. It has several hundred polygons. I used 3D Exploration to export it from
a 3DS model into an OpenGL display list. The texture is embedded into the
screensaver as a bitmap resource.
The stars are just triangles of varying sizes. They rotate slowly and aliasing
causes them to twinkle.
The rocket trails are also made up of triangles. They look decent and are a
cheap alternative to the more usual particle system implementation based on
blended textured quads. My exhaust particles spin, shrink, and fade to black
RocketSaver is of modest complexity, obviously, but I had fun making it. Feel
free to email me if anyone has specific technical questions: [LINK mailto:meanfox@meanfox.com meanfox@meanfox.com]
Mean Fox
(L) [2001/09/17] [BrunoCesteiro] [brunomtc@hotmail.com]
This picture is from an Engine i'm making..,
When it's done it will be used for a game me and some friends are planning
to do for quite some time.
The outdoor rendering is handled by a quadtree, indoor is a portal engine.
There are two types of possible structures on the landscape, structures that
have a connection to an indoor level, and structures that don't have a
connection.
This structures are stored at the quadtree nodes.
As a result the engine can have connections to any number of indoor levels.
I'm currently optimizing the engine to be faster.., collision detection( on
the outdoor) is eating lot's of processing power and it's not very precise..
to check it, just stop moving while in the landscape to see the fps
increase.
well, that's it, hope you like it
It has been tested on Gf1/2/3 and it runs ok
read the text file attached as there are several options on the console
More screenshots and a download at [LINK http://brunomtc.no.sapo.pt my webpage]
Bruno
(L) [2001/09/19] [RobertPasquini] [rpasquin@digipen.edu]
Well, lets take a couple steps back and I'll show you an interesting an ASCII
game. :]
I helped make this game three years ago at DigiPen for my first semester
project. It's
a adventure game called Super Adventure Puzzle Fighter Alpha 2 Gold Text
Addition. Nice game title eh?
The link to the game is [LINK http://www.digipen.edu/downloads/SAPFA2GTE/]
There are more pictures on the site.
There's some really damn good ASCII animation that one of my friends made by
hand in an ASCII editor.
If you press 'D' at the main menu, there's a music video that you have to see.
Pretty wicked if you ask me.
There are some codes that enable you to view some of the better animation during
the game, like a blood code that enables fatalities. If you're interested in
more game details there is some readme.s and an in-game help option to explain
some other things in more detail.
Enjoy!
(L) [2001/09/21] [LasseS.Jensen] [lasse@funcom.com]
Here's a few images from my and Robert Golias water research presented
at Game Developers Conference Europe. Check out the following site for
more images, paper(s) and slides:
[LINK http://www.swrendering.com/water]
Hope you all enjoy it...and of course don't hesitate with feedback,
questions etc...Flipcode rules :-)
Cheers,
-Lasse S. Jensen, Da Technical Manager/[LINK http://www.funcom.com Funcom]
(L) [2001/09/22] [AlbertSandberg] [thec@home.se]
Our company is cutting down but before I leave I would like
to share with you all, what I've been doing for the last
year or so.
This is a shot from our poker game (texas hold'em,
the most entertaining poker favour in the world)
which can be found on [LINK http://www.riverkingdom.com www.riverkingdom.com] (total download
of ~6MB). Please note that this isn't a plug or something,
we're abondoning the project.
I've been doing most of the stuff that you can actually see
in this shot, the graphics displayed and the game code
itself. The server is programmed by a guy called Daniel
Frisk, the network and underlying code in the client by
Anders "breakin" Nilsson and the window code (directx etc)
is coded by Robin "gosub" Håkansson. The nice graphics are
made by Jori Helminen.
As you can see, we have included a dialog system (dirty
rectangles) in the game, order of dialogs and a lot of
other stuff going on with the dialog system over there. As
you can see, there are a lot of items which can be used as
well (buttons etc). I know there is a bug in the lower
right of the image but that has been taken care of.
It's a multiplayer game where up to 8 persons can play at a
single table, of course, we offer a lot of tables.
And of course a lot more...
It's been very nice to work with the project, and it's a
shame that we can't continue, but I still wanted you to see
the shot, because I'm proud to say that I finally released
a project I've started with. And that's really something.
Thanks for viewing.
Albert "thec" Sandberg
(L) [2001/09/23] [ChrisEgerter] [powerrender@home.com]
Here are some new screenshots taken from my Landscape Studio editor, which is
part of the Power Render 4 engine.
In the two top images you see the new reflection code. Objects are clipped to
the water plane, so anything below the water (including moving objects, no
preprocessing here) will not appear in the reflection. Since you can't have
user clip planes and multitexturing on Geforce cards this required some tricks
and an extra pass. The scene has over 70,000 triangles and is drawn with 3
passes per frame. The water uses per vertex colors along with additive blending
and camera space projection for the reflection texture.
In the bottom left you can see a BSP level modeled in Q3Radiant with shadows
projected on the terrain. Shadows are drawn directly on the terrain texture
using a software rasterizer rather than using shadow maps or shadow volumes.
Since parts of BSP buildings can be below the terrain in this engine, you don't
want underground parts projecting shadows. To solve this I am transforming the
BSP to world space, then checking the height of the terrain at every vertex. If
all vertices of a face are below the ground no projected shadow is drawn from
that face. You can move, rotate, and scale the BSP buildings with shadows and
reflections in realtime in the editor.
On the bottom right you can see inside the building that is shown on the left.
It has dynamic lightmaps and PVS culling just like Quake3, and can use EMBM for
walls. Walking between indoor and outdoor areas is completely seamless.
You can download a slightly older version of the engine and editor from
[LINK http://www.powerrender.com www.powerrender.com].
Chris Egerter
(L) [2001/09/25] [JaniImmonen] [jani.immonen@inmarsoftware.com]
Here is some screenshots from 3d demo made for PocketPCs. Demo is made with
'under development' graphics and sound SDK called 'DieselEngine'.
Some of the features of DieselEngine
- 'DirectX alike' programming interface
BltFast, DrawPrimitive, Surfaces, VertexBuffers, 3DDevice etc. (you love
those..don't you? :)
2D and 3D graphics engine with particle systems and object animations
Sound engine with 3D sound
Input engine which maps the 'keyboards' and 'mices' to work similarly
independend of the device
see [LINK http://www.inmarsoftware.com www.inmarsoftware.com] for full list of features.
Screenshot demo is also available at that site along with other 3D demos for
PocketPCs. Currently only ARM versions are available, but versions for other
PocketPCs will be available with DieselEngine release. And those who do not
have a PocketPC, some demos include win32 emulator version to run them on
desktop PC.
(L) [2001/09/28] [JariKomppa] [solar@icon.fi]
Sorry for such a quick textmode IOTD follow-up.
What happened was that someone posted some matrix-trailer-inna-textmode
production, and I figured that my textmode renderer probably would look
better (although it's far from perfect - aalib for instance makes much
better results)... so I downloaded some mpeg software simulation group
sources and made an mpeg player for textmode. Then I talked about this
on #coders for a bit and someone tossed the idea that I could make an
avi player.
... "yeah right", I said ...
Anyway, then I was bored again and glanced at the DirectShow API and
figured I might actually do it. The result is here - windows media
player that outputs in NT console. It can play almost everything
windows media player can, so yes, if you have a DivX codec installed,
you can watch DivX AVIs with this, in textmode.
The images:
- top left, Unreal Technology Demo (mpg)
top right, 'show our power' assembly01 winner animation (mpg)
bottom left, 'Lapsuus', assembly01 winner demo (DivX avi)
bottom right, Max Payne E3 2001 video (wmv)
The binaries can be found on [LINK http://iki.fi/sol]
Unfortunately I won't be releasing the source, since it's such
an ugly mess. The ascii art renderer source can, however, be
downloaded from my site.
(L) [2001/09/30] [Zed] [sexybastard@clear.net.nz]
rather than trying to fit fifty million + one shots into a single 640x480 image,
ill post just the one. further shots and engine
info can be found at the address below.
as you can see I aint quit working on my game götterdämmerung, contrary to
appearances its a strategy game quite like chess.
sorry this is a bit rushed and theres no demo but im moving to funfilled
adventure capital of the world, queenstown.
[LINK http://uk.geocities.com/sloppyturds/gotterdammerung.html]
(L) [2001/10/02] [AlexJ.Champandard] [alex@ai-depot.com]
This engine is a Quake 2 level renderer, based on BSP. It's a bit old
admittedly... It was developed by a small company in Texas called Id Software,
by a guy some of you may have heard of called John Carmack. That's nothing new,
I just wanted to get that out of the way before I start mentioning the cool
stuff ;)
The two levels are from a pack named Gothic Revolution, both very good
looking even by today's standards, which just goes to show it's all about
content. They're not by me either.
So what are you looking at? If you look really closely at the bots, you will
see a very small neural network! (I'm kidding by the way... you don't have to
squint at the monitor ;) The neural net is used to guide the bot around. In
the screen shot on top, the bots are evolved to avoid walls with genetic
algorithms. The basic idea is to cut open the bot's brain with a scalpel, and
delicately insert the NN. In green you'll see the distance sensors working:
these are the inputs for the neural network. Then its just a case of locking
the speed at maximum (I don't always treat bots this badly), and seeing what
happens.
At first the neural network goes "Whoops, how the hell do I control this
thing? ... ka punk!" Every time the bot hits a wall during a trial, he is
punished (deduced fitness points). The performance of the bots increases
quickly over time, as the best bots are mated together to produce potentially
fitter ofspring. It takes about 40 generations of 8 bots each to have a pretty
much perfect obstacle avoidance, by which time the neural networks is begging:
"Is there any way of boosting the speed of this thing? These corners are
pretty easy..."
In the screenshot, the bot running down stairs doesn't in fact make it fully
intact. He runs into the wall at the corner, turns and over compensates,
thereby falling off the stairs into the small pool. It took him about 6 more
generations to make it. You have no idea how pleased I was when those things
actually ran up-stairs: it was quite a feeling of pride (close, I can imagine to
the first steps of a child - virtually ;)
The image at the bottom shows a few waypoints - those horrible pyramid type
things connected by green lines. They were placed by an automated way-pointing
system as I ran around the level. The algorithm is something new I came up
with, and I call it the "Hansel and Grettel" algorithm. If that's not
self explanatory, then tough... I won't go into the details here, since it will
be covered in detail very soon in the [LINK http://ai-depot.com/BotNavigation/ Robot
Navigation] tutorial on a newly created site called the [LINK http://ai-depot.com/ Artificial
Intelligence Depot].
Anyway, back to the bots in the bottom image. They're given the same basic
information as the bots on top, plus the position of the target waypoint. The
target is the one linked to the bot with a green line (Quake 2 doesn't have any
colour options!). Again, it takes about 50 generations for the bots to be able
to follow a randomly chosen path, AND avoid obstacles. This is all done by the
neural network, marvellous things...
Right, that's about it. No flames please, I admit this is a shameless plug!
I'm going to be doing a lot more development work and academic research on the
subject, and I'm looking for people potentially interested in this technology.
If you'd like more information, don't hesitate to [LINK mailto:alex@ai-depot.com contact me].
(L) [2001/10/03] [DanielZuidinga] [Zuidinga@t-online.de]
I am a 18 year old student from Germany. In the 12th level we have to do
a scientific work - the so called Facharbeit. My task was to code an
application which simplifies the measurement and displaying of electric
potentials in an electrolytical trough.
On the upper left picture you can the see the main application (coded
with Delphi/DelphiX) which controls the hardware over the serial
interface (upper right pictures). The program grabs a raster-scan of the
electrical potential distribution and displays it in a two-dimensional
way on the screen. Morevover the application allows the user to restore
the errors of measurement and to display the measurement result in
different ways (colors, frames, text...).
On the lower right image you can see a three dimensional projection of
the measurement results. It is displayed by an external viewer which i
coded quick and dirty with Delphi and WdirectX.
Finally, in the upper left corner, you can see a measurement which i
edited with Photoshop. It should show the electrical potential
distribution in a classical way with the so called potential-lines.
You can get more informatoin about my scientific work on
[LINK http://www.zuidinga.de/facharbeit/einleitung.htm www.zuidinga.de/facharbeit/einleitung.htm] (only in German!)
I would be pleased if i get feedback ;-)
(L) [2001/10/05] [GabrielRABHI] [gabriel.rabhi@z-oxyde.com]
This small demonstration show a spring based dynamic simulator with a muscle
feature. A muscle is a length variable spring. The structure of the animal is
only animated by muscle and all behaviors of the structure are generated by
simulation of collision particle on the ground.
This is a research demonstration : we are integrating a mesh preservation
mechanism and full collision detection. This engine will be used as a full
inverse cinematic, skeleton based character and soft and rigid constrained
bodies simulator, and should be integrated in our programming tools and in our
advanced content creation real-time networked environment now in development.
You can download this demo here :
[LINK http://www.z-oxyde.com/research/download.html]
(L) [2001/10/07] [ClusterGLTeam] [clustergl@hotmail.com]
ClusterGL is a Real Time Ray Tracing library with an
OpenGL like API, developed at University Of Salerno by
Rosario De Chiara and Ugo Erra.
The CPU power needed to obtain real time performance
with an computationally heavy algorithm such as real time,
is provided by a cluster made up six PCs (PIII 650Mhz)
on a 1.28Gbit LAN(Myrinet) under Linux.
ClusterGL uses the SEADS (Spatially Enumerated Auxiliary Data
Structure) to speed up the ray-triangle intersection and
obtain a load balancing among the nodes.
ClusterGL can manage shaded, mirrored, trasparent triangles
and colored light.
In ClusterGL is implemented a subset of OpenGL commands
that permits fast traslations for simple OpenGL sources.
ClusterGL is full CPU power no 3d accellerator needed.
More to come:
- NURBS
Texture mapping
etc...
Contact address: [LINK mailto:clustergl@hotmail.com clustergl@hotmail.com]
Rosario De Chiara
Ugo Erra
ClusterGL Team
(L) [2001/10/08] [JamesMatthews] [jmatthews@generation5.org]
Here is a screenshot of the latest version of A* Explorer (v1.1). It shows
all of its features, including:
- Dynamic search space indication (red/blue squares)
Node highlighting (blue square w/magenta arrows)
A* Stepping
Breakpoints (Red circle between O and D of Flipcode)
Open/Closed list viewing
Drawing your own large maps.
A* Explorer should be one of the most comphrensive A* learning tools out
there. A* is very important to AI game developers, so I thought you'd all
appreciate this. Plus the source code is available for download, along with
the binary and help files at [LINK http://www.generation5.org/ase.shtml].
Comments and improvement suggestions are very welcome!
Later,
James.
[LINK http://www.generation5.org/]
(L) [2001/10/09] [NathanielMeyer] [nath_meyer@hotmail.com]
Well, I guess I'll just post the info below, and you guys can post it,
should it be worthy =) The image is also attached to the e-mail.
Well, after a year of development (though never steady, sort of a past time
hobby), here's a little snippet of my engine I call "Nutty". It's nothing
really fancy, though I hope for it to support a wide variety of features in
the near future (and fix some of the old ones too =). The shots you see here
are from one of my programs called NuttyWorlds. Its sole purpose is to load
and play around with objects, which you then save them in .nut format to
load in other Nutty engine based apps. This app is my mainstay program
demonstrating the nutty engine's features. I have also listed on my website
(the link is below) three other demos (rather old ones) I made for fun.
Since I'm in my 2nd year of University, I'm learning some cool stuff that I
can apply to the engine to spruce it up (like AI). I also plan on sharing my
ideas with the public under my openGL tutorials section, so that's a bonus
once I learn more interesting stuff. Feedback, is of course, welcome =)
Here's the link to my website:
[LINK http://hideout.cjb.net] (it's a local server, might not be all the bells and
whistles on speed =)
(L) [2001/10/11] [MeanFox] [meanfox@meanfox.com]
Here is a screenshot from our first, just released, shareware screensaver called
World Saver 3D. Here's the product blurb:
"World Saver 3D is a new, unique, fully-featured 3D Windows screensaver by
MeanFox.com. It features a beautifully rendered 3D world slowly spinning against
a backdrop of stars, including the Sun, correctly positioned in relation to the
Earth. You can mark the location of hundreds of major cities around the world
and show their names if you desire. But World Saver 3D is more than this. It
also allows you to tell at a glance the approximate time at any location on the
globe!"
This was a major product for us, there were very many issues to handle,
including:
- jpg decompression from a resource
registration codes
anti-piracy security
longitude/latitude data
seasonal calculations
serious performance optimization
significant use of the registry
quite a lot of configuration options
fast, efficient moving text
installer/uninstaller
registration service
obtaining diagnostics from the end-user
many others...
In retrospect, it was too much to chew on at once. Going from freeware to
shareware is a big step in itself, I advise you to do this with a very small
product first !
Please download and try the free trial from
[LINK http://www.meanfox.com/uploads/WorldSaver3DSetup.exe]
Thanks for any feedback -
Mean Fox
(L) [2001/10/13] [PierreTerdiman] [p.terdiman@wanadoo.fr]
Yes. You're right. This is Konoko, indeed.
Directly hacked out of ONI from Bungie, one of my favorite PC games despite some
major flaws. That game frustrated me as much as I enjoyed playing it - read: a
hell of a lot. So as a revenge I took the liberty to hack my way through the
file format, cut the whole thing to pieces, and here's my new pet project:
KONOKO PAYNE !! ...you guessed it, that means ONI with the swell moves + a
bullet-time mode (absolutely compulsory for such a game!) + all the special
graphic stuff we like, and which lacks from the original game (shadows, shaders,
more polygons in characters, yadayada).
Ok, I'll probably never finish such a daunting project (we waited for both games
many years and I want to mix the two all alone? DOH...!) but it was cool enough
for an IOTD ! :)
[LINK http://www.codercorner.com/Oni.htm]
(L) [2001/10/15] [AlesHolecek] [ales@viewpoint.com]
This image is a screenshot of a scene rendered in the Viewpoint Media
Player and represents an Internet banner ad demo
(seen in action [LINK http://developer.viewpoint.com/developerzone/5-142.html here]).
It showcases the integration and interaction of various media types,
including flash movies, streaming 3D, composited 2D elements and
HyperView all within one scene.
The model was created in 3D Studio Max by Viewpoint's Chris Iorillo and
took 2½ days to create. Lighting and additional features specific to
Viewpoint Experience Technology (VET) were edited using the Viewpoint
Scene Builder. The model has 10,682 polygons and 5,011 vertices. The VET
proprietary software renderer, renders the scene at 11 fps while fully
compositing against the html and desktop background. The scene runs at
800 x 600 resolution on a P3, 450mhz with128 mb memory.
(L) [2001/10/17] [BenadibaLaurent] [benadiba@hotmail.com]
Here is a screenshot of my new cartoon rendering based engine ( k- Engine).
The engine currently features : Cartoon rendering, shader system with mesh
deformation, multi - layers effect, texture animations, landscape ( with really
low memory usage , and dynamic deformations ), skinning, animation, exports from
MAX using FlexPorter, D3D8 TnL support, console, profile, debug, memory
management systems, effects system ( particles, halos ), Anti Aliasing ...
The cartoon rendering, as you can see in the wireframe shots, use a fatter and
black object precalculated at the load time and drawn with inverse backface
culling.
This fat object contains only vertex buffer with the FVF XYZ ( without normals,
and so on), so it is only 30 % more memory usage than using only the normal
mesh.
The fat object is precalculated using the normal of each vertex, instead of an
uniform scale wich does not give correct result for angles.
The rendering is done using the ZBias function as mentionned before, to avoid Z
Fighting, and can involve Anti Aliasing for nicer borders.
The shading is a two layers shader, with the texture and an environment mapped
texture on it,
If you want to participate to the engine, just tell me, I like to work with
other programmer !
Thanks !
Benadiba Laurent
(L) [2001/10/18] [BernhardGlück] [gluber@gmx.at]
This is an early shot of our in development game ÂStartrek Realspace it
will be a completly free game, and is under active development. It is
based on our own ÂRealspace Engine a completely modular game engine,
which allows to create any game with no or little C++ coding.
It is the basis for my book "Game Engine Design and implementation with
DirectX 8.1" which is due out in Q1 2002 , by the German publisher
"Markt & Technik"
Here are some features and facts:
General:
- Modular architecture due to use of plugins for almost everything.
Runtime loading of plugins.
Resource manager for caching, loading and unloading data as needed
making optimal use of present RAM. Also makes sure every file is only
loaded once.
All data files [ except really standard ones, like WAV,MP3,TGA ] are
saved as XML documents, making them easily understandable / convertable.
Abstracted inter object communication using a compact messaging
system.
Event system using messages as backend.
Object system, managing all runtime created classes, and allowing
standardized access to their properties.
Easily write new object classes in plugins and export them to scripts
and the main engine core.
All systems are designed to be easily extendable by 3rd party plugins.
Easy to use debugging console.
Support library: [ Useable in any project, not just Realspace ]
Sophisticated DLL aware RTTI System.
Extensive debugging support with callstack traces, memory leak
detection, smart pointers and the likes.
Automatic bug report over the internet.
Detailed debug log.
Safe array and linked list templates [ to be independent of STL ]
Template and DLL aware support for Singletons.
Support for dynamic binding of DLL files.
Dynamically resizing data buffers.
Vector, Matrix and Quaternion math modules.
Multi threading primitives [ Thread class, with mutexes and semaphores
]
Unicode aware String class.
Window abstraction class.
DirectX helper methods.
Graphics:
- Entirely written with DirectX 8.1 in mind, completely optimized for
it, making heavy use of state batching, triangle strips and other
optimization techniques to achive maximum performance on todayÂs and
tomorrowÂs graphics cards [ geForce1 class card is required]
Hierarchical Scenegraph with hierarchical view frustum culling.
Some numbers: Pushes about 18 million triangles / sec on a P3900 with
geForce3.
[ using fixed function pipeline without any hardware lights ]
Using vertex shaders for almost everything form lighting to special
effects
Using DirectX 7.0 style multitexture pipeline for per pixel effects
Highly configurable shader system supporting Textures, Detail maps,
Glow maps,Per Pixel Bump mapping using Dot3 Product blending.
Configurable and extendable particle system, using DirectX 8.1 Point
Sprites.
Xml based mesh format, supporting attachment points, shaders and other
things.
Custom 3DSMAX 4.x plugin to export meshes to the custom format.
Skybox support, for space backgrounds.
Additional support for using DirectX X File meshes, and adding shaders
to them.
Several additional special effects [ lens flares, glares ].
Collision detection and response.
Trilinear filtering.
Configurable alpha blending.
Full screen Anti Aliasing.
TrueType Font rendering.
Static Level of Detail system.
Standardized Orientation system allowing to control objects with so
called ÂOrientation providers can be anything from scripted to
dynamically calculated.
Sound:
- Support for WAV,MID and ADPCDM Compressed wav files.
Full 3D Positional sound using DirectSound3D.
Streamed playback of MP3 and WMA files.
Speech synthetization.
Networking:
- Transparent networking system, automatic serialization of all objects
Totally transparent to the user.
Support for TCP/IP communication using DirectPlay.
Planned: Voice communication using DirectPlayVoice.
Planned: Messages are packed and encrypted for sending over the
network.
Input:
- Completely abstracted input system, allowing arbitrary input device to
be assigned to different actions.
Keyboard and Mouse input using DirectInput.
Planned: Joystick support.
Planned: Speech recognition input device.
Scripting:
- Easy to use scripting system, allowing complete customization of the
engine as well as implementing complete games without writing a single
line of C++ code!
Embeds the RUBY Scripting language [ Version 1.6.5 ], a fully object
oriented, fast scripting language.
Derive from any of the C++ classes defined by the engine, and extend
their functionality.
Respond to arbitrary messages, or even send out your own.
Internet:
- File system accepts not only local filenames but also URLs, files are
transparently loaded from the web.
Embedded Internet Explorer browser for display of standard information
[ embedded into the graphics engine, can even be drawn as a texture on
an arbitrary surface. ]
A demo will not be released very soon, since DirectX 8.1 is required.
For more information go to [LINK http://www.realspace.at]
Ps: We are looking actively for graphics artists willing to help with
the game.
(L) [2001/10/19] [PaulNettle] [midnight@FluidStudios.com]
I guess this is just as much a public announcement as it is an IOTD. So if
you're not interested in any announcments I might be inclined to make,
then feel free to ignore the text and enjoy the pic.
I've been working on some radiosity code lately. I've paid a lot of
attention to accuracy and correctness. In the process, I found myself
comparing my results to the original cornell box results.
On the left, you'll see the original cornell box image (as generated at
Cornell University) and on the right, you'll see the one generated by the
new radiosity processor I've been working on.
If you look closely, you'll see that the images are not exact. This is for
a few reasons. First, the original cornell box was not processed with RGB
light, but rather using a series of measured wavelenghts. So I guessed at
the RGB values and surface reflectivities when I generated my image. I
also didn't bother matching their camera position and FOV -- I just
"moused" it. :) The image on the right was post-processed with a gamma
value of 2.2 -- no other post-processing was used. Finally, the image on
the right is rendered using lightmaps.
I don't know how long it takes to generate the original cornell box, but
it takes me about 12 seconds on my 1Ghz P3. It required over 1200
iterations to reach a convergence of 99.999% (theoretically, you'd need to
run an infinite number of iterations to reach a full 100% convergence.)
If you're impatient, a very reasonable result (negligible difference to
the one above) can be had in just a couple seconds.
About the tool:
It's also a lightmap generator/packer; it will generate tightly packed
lightmaps for an entire dataset and generate proper UV values for the
lightmaps. In other words, you want lighting for your game, you just hand
your geometry to this tool, and it spits out your lightmaps and UV values.
A lot of new concepts went into the development of this tool:
- No use of hemicubes or hemispheres; uses a completely analytical
solution with a perfect visibility database generated by a fairly
well optimized beam tree. There isn't a single ray traced in the
generation of the image above.
Geometry is stored in a clipping octree, and at each octree node, a
clipping BSP tree is built. The BSP uses the a new generation technique
that has proven to vastly improve the speed of building the BSP as well
as great reduction in tree depth and splits. From this, we perform
the radiosity process on the precise visible fragments of polygons.
New adaptive patch technique which is anchored to the speed of the
processing itself. As with all progressive refinement radiosity
processors, the further along you get, the slower it gets. This
adaptive patch system is keyed to the progress, and almost keeps the
progress running at a linear speed. This trades accuracy for speed,
but only when the amount of energy being reflected is negligible.
This is also completely configurable.
Other accuracy options, including using the actual Nusselt Analogy
for form factor calculation (about 5% slower, much more accurate.)
Also, for accuracy, every single light map texel is an element, and
it gets this almost for free. :)
I'm considering doing a 12-week course at GameInstitute.com on radiosity
somtime in the future (if they'll have me :). The course will most likely
include this technique as well as other common techniques. It will
probably also cover lightmap generation as well as the other techniques
(new and old) employed in this tool.
At some point, I also hope to release full source to this tool to the
public.
(L) [2001/10/21] [PaulKahler] [pndkahler@yahoo.com]
This image is a screenshot from our game "rtChess".
The rt stands for Ray Traced. I'd been working on a fast "real time" ray
tracing engine for some time when I realized you can't make an engine in
a vacuum. I needed a real project to find the holes. That's when I
recruited Ray Kelm to help with the project. Great choice, he tracked
down the most significant bug in my RT code and made substantial
contributions to the game.
Try rtChess at:
[LINK http://www.newimage.com/~rhk/rtchess/]
The engine itself uses an axially aligned octree for spatial
partitioning. This regular structure allows rapid insertion and deletion
of objects, and I've got an amazingly fast algorithm to fire rays
through it, but the released game uses a less optimized version to
support older CPUs. I've run as many as 8M triangles in a scene at a
couple FPS on an Athlon 700. I could have done more but I ran out of
RAM. The chess pieces are mostly CSG quadrics except the high
triangle-count knight. There is support for proceedural textures, but
they are not used in the game (yet). When you grab and rotate the board
it renders at a reduced quality (interpolation between rays) and then
gets progressively better after the motion stops. When a piece is moved,
the 2 areas of interest are rendered at high quality - sort of a dirty
rectangle scheme. I'm waiting for a good performance increase from AMD
and then I hope to make some insanely complex outdoor scenes to run
around in. In the meantime, Ray asked if I want to do an OpenGL game he
started toying with.
OK, so it's not time for ray traced FPS games, but board games are
possible with some tricks.
G'day
Paul
(L) [2001/10/23] [PhilAumayr] [phil@rarebyte.com]
This is an up-to-date screenshot of my leveleditor called "Philmap". I work with
a little group of 8 people (Rarebyte) on a game called ParadiGm. It took me 8
months to create this program, though I actually learned OpenGL and MFC while
programming it (I got a lot of help from GA, another team member and lead
programmer, though)
Features:
- Recursive-Window-System: You can split every view into halfes and change them
to any kind of view you want (XY, ZX, ZY, Perspective)
Faces: Philmap Faces aren't limited to Triangles. They can contain any number
of vertices as long as they're convex and coplanar... Faces are automatically
split up if the translation of a vertex creates an invalid polygon
CSG: Subtract and Add. Optimized results. We used the BSP approached since
CSG is not so time critical in a leveleditor. (No, it doesn't take hours ;p)
Entities: Entities are placed in an external .dll and get are rendered
through the .dll (Event system (OnDraw, OnMouseMove, and so on.)). It's an MFC
.dll so the entity coders can use MFC Dialogs.
Lightmaps: Lights are Entities, but have internal Philmap support.. Lights
can be moved and are recomputed on-the-fly á la Serious Editor
Brush Morphing: Brushes are morphed from a bounding to diffrent objects.
Currently supported are: Cube, Sphere, Cylinder, ASE, 3ds, and a few others..
Terrain: Heightmaps are supported by Philmap. Sizes up to 2048 x 2048 ( not
recommended, a little slow ;p). Vertex Arrays are used to speed up rendering
Frustum Culling: Philmap uses Object Sphere based Frustum Culling to speed up
rendering... Overdraw is my main concern at the moment though...
Shortcuts for Visibilty of Dialogs: This was a great idea from one of my
team, Charlie. To maximize the working space you can show/hide different
toolbars. (that's why you only see the main toolbar in this screenshot =)
Textures: Philmap used the FreeImage library for it's textures, so there are
_a lot_ of formats supported (Jpeg, Bmp, Png, Gif,...)
Texture Shader: Our engine features a simple shader language for mirrors,
texture animation and so on... Philmap supports this.
Selection over the OpenGL backbuffer. (very accurate ;o)
all the other features a leveleditor should have: Translate Free, Locking to
different Axis, Rotating around different axis, Snap to Grid,
ToDos:
- Workflow: I still have to optimize the workflow of the program. It takes
quite some time to create a decent map.
Morph plugins: I want to implement a .dll system for morphing, so others can
write morph plugins without having to dig through the whole Philmap Code.. (for
stairs, trees and so on)
Sprites: Although you can therotically use sprites, I still want to give this
so common feature in engines some extra support
Optimize drawing of heightmaps: Currently we're able to draw about 2
millionen triangles / second... this could be quite some more.. (U2 has, what, 8
million / second? we'll top that =)
Occlusion culling: I mentioned above that we've got quite some fillrate
problems. It's not such a big problem at the moment, but later on I'll implement
something like that. (occluders)
In-Leveleditor game test: Like Serious Editor we'd like to be able to test
the game on-the-fly... Our engine is designed to fit this so it won't be too
hard, we'll see...
More entities: There are only 3 entities at the moment since I'm working more
on the core side of the program right now. I want to make a little SDK so you
can develop your own entity dlls.. You'll have to send them to me and I'll
approve them, then they might get into the official entity.dll.
Morph Plugin SDK... I'm still trying to figure out a good design so that a
morph can create multiple brushes not only one.. I think I found a way just this
moment =)
Ok, thx for reading it all :). ok guys, start posting.. If you've got any
questions, e-mail me ([LINK mailto:phil@rarebyte.com phil@rarebyte.com]).. Also, plz take a look at our website,
[LINK http://www.rarebyte.com www.rarebyte.com], thx alot!
cya,
Phil
(L) [2001/10/25] [FerryMarcellis] [ferrym@hotmail.com]
I am Ferry Marcellis Lead Programmer of Quest3D and I created this picture
with Quest3D. It is a screenshot of a screensaver that is also available for
download. The image uses a model exported from 3dsmax that I loaded in the
lightwave 5.6 modeler. There I remodeled most of the car so that it was a
little more useable for real-time work. I removed non visible surfaces and
made sure that surfaces that have a lot of polygons where remodeled
completely. In this way I managed to reduce the main car from 65000 polygons
to 44000 polygons. Then I created a reflection version of the model that is
completly striped from anything that is not visible in the reflection. The
reflection model is 16000 polygons. Then I used Quest3D to load the reduced
models texture them and created the spline based camera movement. There are
two point lights in the scene. With code to detect mouse collision over an
object the menus where created. A particle engine is used for the little
flame. The 3d menus control the light and color settings of the car and
together you have a sportscar screensaver. The car reflection is created
using the D3DXMatrixReflect function of dx8. The sports cars main body has a
two textures one texture that is white and uses an alpha channel to show the
basic car color. The other texture is a picture of a lake which also uses an
alpha image to be a little less visible. In this way the diffuse color of
the car can still be used instead of using a texture for the color of the
car.
Hope you like the pic and the screensaver. The screensaver can be downloaded
from the [LINK http://www.quest3d.com www.quest3d.com] site. Since the whole scene is about 65000 polygons
a ht&l accelerator is recommended.
Thnx,
Ferry Marcellis
Act-3D/Quest3D
(L) [2001/10/26] [PierreSaunier] [saunier@pt.lu]
This is an image showing ppModeler in action. The modeled head is done
with subdivision surface, and symetric object, two of the new features
of the program. A version for windows, BeOs Intel, and Linux can be
found [LINK http://webplaza.pt.lu/public/saunier/ppmodeler.html here].
I'm intrested in hearing back from you, in order to improve ppModeler.
(L) [2001/10/28] [JoshuaShagam] [joshagam@cs.nmsu.edu]
I've gone and completely rewritten the [LINK http://www.cs.nmsu.edu/~joshagam/solace/ Solace] rendering pipeline to support
shaders, rather than having a few hardcoded operations.
(Sorry about the lack of texture filtering, but these particular
screenshots were taken on a software OpenGL implementation and I didn't
want it to be even slower than usual.)
Every object is split up into three parts - "base" (for opaque things which
don't rely on lighting such as reflectionmapping), "light" (for opaque
things which do rely on lighting), and "blend" (for transparent effects,
which are deferred until later). Each shader pass contains a mesh, a
texture, a lighting material, an operation (solid, wireframe, or outline,
where wireframe and outline can also have a thickness specified), an alpha
test function, and a blend function.
As has always been the case, the engine can scale back the rendering
quality to try to maintain a constant framerate. At the displayed quality
on a Duron 850 with G400 I get about 30fps, though at 60fps it's passable
and with quality turned down all the way it actually peaks at 500fps
(though the shapes look pretty basic at that point). For slower machines,
options can be further disabled (for example, limiting the number of shader
passes).
As usual, I have a whole bunch left to implement on this. For example,
mesh functors (my generic mechanism for modifying mesh data for things like
environment mapping, morphing, and other fun stuff to follow), coming up
with and implementing a mechanism for representing physics engine stuff,
putting shadows back in, and working more on the network transport so I can
actually make the game I've been planning all along for this engine. :)
(It's an MMORPG which I've been planning etc. since long before the term
'MMORPG' existed.)
In any case, if you're running Linux on an x86 processor and have a working
OpenGL installed, you can actually check it out for yourself at
[LINK http://www.cs.nmsu.edu/~joshagam/Solace/Solace-test-20011018.tar.gz] (about
1.7 MB).
Enjoy. :)
(L) [2001/10/30] [NikolausGebhardt] [niko@code3d.com]
This is a shot from the techdemo of an alpha version of my Irrlicht-Engine.
It's a small 3D engine I'm currently working on. It uses DirectX8 but can be
extended with other APIs, like OpenGL. It has features like most other 3d
engines, like fast bsp-tree based indoor rendering, transparency, particle
systems, dynamic light and so on, but also provides build in Alias Wavefront
Maya and Quake2 mesh import, and - our grafic artists will love it - direct
PhotoShop .psd file import as Textures with alphachannel, if needed.
Because im just a programmer and not a 3D-Artist, the indoor level you can
see on the shot and in the techdemo is created at runtime, based on a
Wolfenstein-like 2D map, from a simple textfile. The most difficult part to
code was the ceiling.
When the engine is complete, I will make a DLL and a easy-to-use SDK, so my
engine is free of charge for using in your own games.
The techdemo can be downloaded at my homepage, [LINK http://www.code3d.com www.code3d.com].
(L) [2001/11/01] [JimAdams] [rpgbook@att.net]
The image is a screenshot from an engine detailed in the upcoming book
'Programming Role Playing Games with DirectX 8.0' written by myself, Jim
Adams. The engine allows 3-D models to move around within a pre-rendered 2-D
backdrop (ala Final Fantasy 7-10).
The demo (w/full source code) that comes with the book allows the model to
walk around, blocked by the various obsticals, as well as walking up and
down the stairs. The model, called Yodan, was created and used with
permission by Scarecrow and is freely downloadable from [LINK http://www.polycount.com www.polycount.com] (a
Half-life model). The book also details how to use Half-Life and other
format models in your own game.
Check out the book's web site at [LINK http://home.att.net/~rpgbook/] for more
details and some downloadable demos.
Jim Adams
(L) [2001/11/03] [LonFlickinger] [lflicking@mail.maxminn.com]
This is a screenshot from a FPS game I'm developing called Pencil Whipped. I
thought this angle looked really nice showing all the detail of the environment as
a backdrop behind the enemies. This is from a level called "The Temple Of King MugaFuga"
and the game is completely hand drawn giving the impression of experiencing a completely
pencil on paper drawn world. Each level in the game has its own theme and characters so
the player never knows whats coming next. the website is here [LINK http://www.chiselbrain.com www.chiselbrain.com]
Lon Flickinger
(L) [2001/11/05] [KoenVossen] [koen.vossen@pandora.be]
I'm currently studying Computer Science at Maastricht university, and this is the result of the
first project of the first year: a simple Mastermind game in java.
The most interesting part was thinking up the algorithms to make the computer break a code. We
came up with 2 solutions:
--- Heuristic ---
A random code is generated. We then compare our newly generated code to all the previous guesses
we have already submitted. The evaluation we get from our new guess and an old guess has to be
equal to the evaluation of that old guess and the secret code. If this is true for all the old
guesses, the new guess is possibly the secret code and can be submitted. If not, we start over.
Efficiency: 4.64 guesses average over 10.000 games (code of 4 pegs and 6 colors).
--- Optimal ---
This algorithm calculates the usefulness of every code. This is done by calculating, for each
marker, the probability this marker occurs with this code and multiplying this value by the amount
of codes that are invalidated when that marker actually is received.
Efficiency: 4.38 guesses average over 1000 games (code of 4 pegs and 6 colors). This algorithm
comes quite close to the theorethical minimum number of guesses needed: 4.34
We used a very modular and flexible design that separated the actual mastermind game from the
interface used. As a result, it's very easy to implement eg. a textual interface if need be.
Remark: Java is not as system-independant as Sun would have you believe. When I ran this applet in
linux (RedHat 7.1, KDE 2, JDK 1.3.1) the windows weren't resized properly. Additionaly, there were
slight alignment differences of the GIU components. Might be a KDE problem, but I haven't tried it
with another windowmanager.
You can download the zip file (including jar file, source code and javadoc) [LINK ftp://ftp.flipcode.com/demos/iotd-11-05-2001_mastermind.zip here] (320k).
To run the applet, open MastermindApplet.html in your browser.
Enjoy!
(L) [2001/11/06] [JamesStewart] [jbstewar@echidna.stu.cowan.edu.au]
This is a screenshot of a basic example program written in VPL, a visual
programming language for embedded systems I developed for my final year computer
engineering project.
The language supports most of the same constructs as text-based programming
languages, like constants, variables, arrays, pointers, expressions, and
functions with input parameters and return values.
Programs are structured into "libraries" of "components", the equivalent of
functions. A library has a public interface and a private implementation. The
implementation of a library can be specified independently of its interface,
making it easier to port programs to different hardware systems.
VPL is a control flow based visual language, and has four objects to control
program execution. The object that looks like an upside-down arrow is called a
"begin", and is used to specify the start of a component. The red square object
is called an "end", and is used to specify the end of a component. The
pyramid-like object is called a "select", and is used to choose the path of a
programs execution. Finally, the object shaped like a play-button is called an
"execute", and is used to specify which objects to execute.
The language is represented on disk as a collection of XML objects, and compiles
into both ANSI-C and 386 assembly source code.
If you want to contact me, email me at [LINK mailto:jbstewar@student.cowan.edu.au jbstewar@student.cowan.edu.au]
James Stewart
(L) [2001/11/08] [IvanKolev] [ikolev@nat.bg]
FreeGen is the game that we (Dimension Design - a small company based in Varna,
Bulgaria) have been developing for about a year already. We released our first
demo about three months ago. Since we are regular Flipcode readers, we decided
to post an IOTD and get your opinion, fellow flipcoders :)
FreeGen is a 3D tactical multiplayer first person shooter in space. Think of a
mix between Unreal Tournament, Tribes, Forsaken. Gameplay is mostly about
team-based tactics, with thinking and cunning usually prevailing over quick
reaction and fast mouse-clicking. Original multiplayer game types (like Collect
and Download) and lots of strange power-ups and devices make the game concept
unique (hopefully :).
The engine is developed in-house. Uses very heavy Lua scripting. Most of the
game logic is in easily modifiable Lua scripts. The eye-candy isn't too much -
yet. We are focusing on the gameplay first. After releasing the demo, we decided
to further emphasize the tactical element. So the final game will differ
significantly from what you can experience now, but the main idea will remain
the same.
The demo as it is now is a fully playable game. But it has only multiplayer, no
single-play, supports LAN only, and at least four players are required to make
an enjoyable game session - no bots for now. All these things will come in the
future. If you can't find company and a LAN to try the game yourself, you can
watch a recorded demo for each game type to get a feeling of the gameplay.
The URL's:
[LINK http://home.abac.com/ddag/FreeGen] - FreeGen's page at the old Dimension Design
web page.
[LINK http://www.chaoticdimension.com] - The new home of Dimension Design, together
with Chaos Group.
The preferred URL for direct download is
[LINK http://home.abac.com/ddag/dl/FreeGen010Setup.exe]
(note: the screenshot is from the current build of the game, don't wonder why
the radar in the demo is different :)
(L) [2001/11/09] [NickMcVeity] [nmcveity@iprimus.com.au]
This is a collection of screenshots from my 3d graphics engine, called
mercury. I created it for a games programming subject at my school, the
Royal Melbourne Institute of Technology. Essentially, it is a quake3 level
viewer that implements nearly all of the graphical features
implemented in the real quake3 engine. This includes:
- PVS optimised BSP rendering
Volumetric fog
Curved surfaces
Extensive shader support
In fact, all it doesn't include is dynamic lighting and a few of the
fancier shader operations (that is, the skyparms and deformverts).
The rendering code is only moderatly optimized because I consider this
project one which will continually evolve (and trying to extend highly
optimized code is hard). Even so, the engine performs well on most modern
multitexture capable accelerators including my own "low end" 400Mhz K6,
Nvidia Vanta equipped PC. There is a demo available on my [LINK http://yallara.cs.rmit.edu.au/~nmcveity/mercury.html website
] which you can download and run provided you have a copy of Quake3. At
the moment there is only a windows version for download, however, there will
be a linux demo available soon (most of the project was developed using
linux!). More information, plus full size screenshots are available at the
above site.
Oh yeah, I graduate soon and am looking for work as a programmer. I live
in Melbourne, Australia, but would consider relocating (especially to
Mesquite, TX :) )
Have fun.
(L) [2001/11/12] [LukeHodorowicz] [gollum@flipcode.com]
For all of you who wondered what I really look like...
(L) [2001/11/13] [LuperRouch] [flupke@wanadoo.fr]
Just a little screen shot from a little effect :)
Features :
- OpenGL rendering
mesh is constructed by recursing in an octree (only stores bounding boxes
and field intensities, there is a custom memory allocator for the nodes so
rather large trees can be generated without mem alloc penalty)
recursion takes into account visibility and metaballs bounding spheres, it
stops inside the volume (negative metaballs are not handled yet)
metaballs field values calculation is writen in asm (~10% performance
gain)
"highly" optimized bounding boxes view frustum culling (used ideas from
Ulf Assarsson and Tomas Möller, "Optimized View Frustum Culling Algorithms,"
([LINK http://www.ce.chalmers.se/staff/uffe/]) : implemented frustum planes
masking, temporal coherency (easy one but did not gave good results on the
allways changing octree), and tests on n-p vertices)
mesh is generated using marching cubes algorithm
There are 12 metaballs moving in a rather large cube, mapped with an
animated texture. The app runs at ~60FPS on my athlon 1GHz, geforce 256,
512Mo.
You can get the win32 executable and source code at
[LINK http://www.supradyne.fr.st]
Note that this is a part of a larger project named TOTTEUR, a (not finished
yet) 3d engine released under the GPL
([LINK http://sourceforge.net/projects/totteur/])
(L) [2001/11/14] [ThomasFeilkas] [tfeilkas@gmx.de]
This image show some of the elemts of the thesis work me and my friend have been
working on the last few months. The upper image is a screenshot of the Steering
Creator. The lower left image shows the Regensburg-Applet, the lower right the
A* pathfinding test applet.
The Steering Creator is a Java based editor to create and test scenes built on
the works of Craig Reynolds. It allows to load, save and create user defined
scenarios. XML is used for the file format an also for describing the objects
available in the Steering Creator. There are four basic elements to a scene:
- Vehicles
Obstacles
Minds
Behaviors
The vehicles are represented by the small triangles. Obstacles can consist of
any non convex polygon, predefined is a rectangle and a circle. The Mind of a
vehicle implements the action selection for the vehicle. It is responsible for
choosing how much force each of the assigned behaviors can add to the resulting
steering force. We only implemented influence based blending and prioritized
selection as minds. In a game you would normally use some more advanced ways of
choosing which force to consider. The final element of the scene are the
behaviors. Each mind can have any number of behaviors assigned to it. We
implemented nearly all of the behaviors described in Reynolds work, so there is
a lot to try out here.
We are using XML for storing the scene desriptions. XML is also used for
describing the elements available in the Steering Creator. New elements can be
added by simply describing them in the objects.xml file and adding a line of
code in the factory. This makes the whole editor pretty easy to extend. You can
also add your own custom attributes to any element of the scene at runtime.
The Regensburg Applet is a demonstration of the path following behavior in
connjunction with a simple pathfinding algorithm. By clicking on any street on
the map, a path is created from the current position to the destination. The
behavior simply steers the vehicle along this path. Since the non blocked nodes
are all placed on the streets, it looks like the vehicles is following the
layout of the map.
The Algorithm Test Applet is one of those traditional A* testbeds.
All applets and the Steering Creator can be found at
[LINK http://www.SteeringBehaviors.de] . The source code for the whole project is also
available for download.
The applets are unfortunately a bit huge (nearly 1 mb), since they use Xerces
for XML parsing and object creation.
(L) [2001/11/15] [DynaMite] [dynamite_feedback@hotmail.com]
So many Dark and Serious pics.. all very well. But every so often we want
something Bright, Bubbly and Fun. Like this.. my Dynamite Game. A freely
downloadable Bomberman game for the PC (Windows / Dos versions) using the
excellent Allegro Library (v3.9.39).
640 x 480 x 256 colour classic gaming fun.. 20 different powerups, random
maze maps, 4 players on one machine with upto 4 monsters as well..
For classic four player huddles around a keyboard and excellent multiplayer
fun.. what more do you need?
[LINK http://members.tripod.co.uk/DynamitePC/]
Freely downloadable as long as you give me some feedback - this is a
feedbare production!
(L) [2001/11/17] [StephenSchmitt] [sschmitt@u.washington.edu]
No, this is not showing off a real-time terrain renderer. The 3D
visualizations were done in pov-ray and are purely for illustration. Now
that that's out of the way.. :)
My hobby over the past half year has been improving the artificial nature of
the terrain you get out of a basic subdivision/perlin noise terrain
generation scheme. I've looked into a variety of methods including simple
function transforms on the heightfield, multifractals, and several other
schemes.
One method that has consistently produced nice results is the simulation of
small-scale weather and fluvial erosion. My algorithm is based on the Monte
Carlo method: In a nutshell, it drops running water randomly on the terrain,
picking up or depositing soil as the stream flows. You can simply run until
the desired level of erosion is achieved. With a bit more work, the creation
of a river system and large-scale water channels should be possible. The
algorithm is not suitable for real-time running, but it works fine as a
backend/preprocessing step.
I'd be happy to provide more details if anyone is interested.
-The top 2 images show the same heightfield, in a before/after comparison of
the erosion simulation.
-The overhead view shows 2 lightmaps created from another heightfield, again
contrasting the results before and after applying erosion.
-The middle-right screenshot shows the basic terrain modification dialog box
in my terrain tool.
-The bottom image is another Povray rendering of an eroded terrain.
As an aside, I had thought of trying to submit these techniques to GPG3, but
I reconsidered after realizing from the lack of information on erosion
methods on the Internet, that I may well be the only person who finds this
stuff interesting. :)
I'd love to hear any comments or discussion on what other people do to
improve their terrain heighfields.
(L) [2001/11/19] [VianneyLecroart] [lecroart@nevrax.com]
These screenshots was taken from our game (Ryzom, a MMORPG) developed by Nevrax
([LINK http://www.nevrax.com www.nevrax.com]) using NeL (Nevrax Library).
NeL is our GNU GPL library ([LINK http://www.nevrax.org www.nevrax.org]) used to develop our program. It
contains a 3d engine, ai engine, network engine, sound engine and lot of other
features. It is multiplateform and is developped under win32 and linux. For the
moment, NeL uses OpenGl and OpenAl.
The 3d engine handle indoor and outdoor scene with totaly different algorithms
(On screenshot, you see only outdoors scene).
Landscape features:
- Landscape texture mapping at a constant 1.5cm/ texel, with the possibility of
a second complete additive texture layer.
The landscape is mapped with tile textures using smooth material transitions.
Bezier patch landscape modeling gives NeL enormously more flexibilty than
traditional height fields. NeL supports vertical faces, overhangs, and so on.
An incremental ROAM-like algorithm is used to provide adaptive subdivision of
the landscape based on distance from the camera, steepness, etc.
Geomorphing is used between LODs (levels of detail) to eliminate popping. It
is computed with a vertex program.
Landscape colouring effects include vertex colouring and application of
pre-calculated shadow maps (with soft shadow and radiosity like alg).
Landscape is dynamicaly streamed into memory with background loading
Displacement maps (also known as geometric noise) is used at tesselation time.
These are taken into account during lightmap generation which means that they
can still be 'seen' at low levels of detail
A complete set of 3dsmax modifier and exporter plugins is available to edit
the landscape.
For other 3d features, take a look on
[LINK http://www.nevrax.org/docs/features_nel_3d.php3]
For other NeL features and docs: [LINK http://www.nevrax.org/docs/]
Nevrax Team
(L) [2001/11/20] [zed] [sexybastard@clear.net.nz]
heres some of the stuff ive been working on the last 2 weeks, not shown is my
collision detection/physics research ( though i might
dump that and use Russell L. Smith's dynamics library ODE which looks very
promising ) anyways the above shots have come about
because ive decided to up the minimum requirements for götterdämmerung to at
least a hardware t+l card. Im figuring when I finally
release götterdämmerung, geforce256's will be the voodoo1's of today :(. As we
all know hardware t+l == polygon pusher, but a lot of
polygons == lot of storage. so what ive been doing is procedurally generating
the models/textures (and sussing out how to do this
very fast during runtime) the trees at the top were 'grown' using a variation of
'grammer models' (see cgp+p for a description) the
rocks/wood etc at the bottom are noise generated. the top shot has about 200,000
polys so even my vanta is able to handle it (single
digit fps though :( ) which aids testing but I will prolly up the count when I
get my hands on a hardware t+l card.
zed zeek
[LINK http://uk.geocities.com/sloppyturds/gotterdammerung.html]
(big page the site will prolly overload just gotta be patient)
(L) [2001/11/26] [StefanJohansson] [stejo127@student.liu.se]
This a program/engine that i have been working on for some time. From the
begining i meant to create a game of it but lately i have mostly used it to test
stuff for my exam work.
The most interesting feauture currently in is probably the pathfinding used for
ground vehicles. Its about 20x faster than standard A* with an admissible
distance based heuristic while generating about 5% worse paths on my test map.
Another good thing about it is that while it need about 0.04s to
generate a 800 nodes long path it only need about 0.002s to startup the path
while the rest is used while the vehicle is moving. This has several advantages
such as spreading out the cpu load and not having to throw away that much work
away if the user decides to direct the vehicle elsewhere. The
pathfinding part of my exam work can be found [LINK http://www-und.ida.liu.se/~stejo127/path.pdf here]. The lower left image shows some
searches in progress and how the path get more detailed closer to the vehicle.
Another thing that some might find interesting is the finite element like
simulation model i use on the player controled crafts (lower right image). It
should in theory have several advantages such as regional damage, taking damage
on a craft into consideration for its movement and also allow the
users to create their own totally unique crafts without the ability for them to
cheat. In practice i havent got it to work that well though.
Since i have "borrowed" some 3d models from the old RTS Total Annihilation
(cavedog m:50) you might have to own that to legally download a demo from
[LINK http://www.tauniverse.com/SY/download/spring.zip].
//SJ
(L) [2001/11/27] [Jolle] [jolle@cfxweb.net]
Here is a picture showing my latest 3d landscape engine, supporting realtime
LOD, realtime radiosity and ultra neat hyper antialising. It runs at... ohh...
sorry, must have typed wrong there ;)
This is some pictures from a game I am making. It is called Blastup 2 (some of
you people might remember a game called Blastup in the lame game contest about
two years ago here at flipcode). I have been working on it about half a year in
my spare time, or in parts of my spare time you might say.
It is a simple shoot-the-other-guy-with-a-grenade-in-the-head-like-game (like
gorillas, except that you don't type angle and power, you just touch the
arrowkeys a bit). The whole game is working on the pixel level, and is about
98,3% software rendered (with a 0,02 margin of error). It works on most svga
cards (i.e. it doesn't require a FeGorce 58xmg with 2567 MB of memory etc).
Sooo, how about the performance? It is not anything blazing fast, with brand new
technology written in any % machine code. It is written in C/C++, and runs at
about 55 fps on my p3 500. Don't know how it runs on newer computers, but I
tried it on a old p2 300, and it ran at about 30-50 fps (depending on the
weather fx and water).
It is written using tinyptc for graphic output and fmod for sound output. Things
like timer and keyboard are wrapped up in classes. This will probably make the
game quite easy to port, but I am not planning to do that, so I don't really
know... (it have been developed on windows 98, but it probably works on 2000 and
the like as well)
Maybee some of you are pondering why I have written such a game. It has been
done many times before, and there isn't anything in particular new with this
one. Well, all I can say is that it have been very fun writing it, and that's
enough for me. (It is also a very addictive game, believe me ;)
Warning! Some of those popular feature lists coming up...
Currently features:
- 640x480x32 fullscreen/windowed mode
2d landscape generator, supporting custom themes
Really nice per pixel alpha blended sprites
Somewhat not realistic realtime animated water
Weather fx
Wind affecting shots/waves/snow/rain etc
Computer opponents
Sfx
Menus
Particles that are updated 500 times per second (don't ask me why...)
Satisfactory improvised physics
Simple timer slowdown for slowmotion
+ more small things not worth mention
Suggested todo features:
- Network play
Action replay
Screensaver mode (cpu players battleing each other)
Theme/level editor
Recording games
Music
The game and the sourcecode for the current version (beta 1.1) can be downloaded
[LINK http://web.neolite.net/jolle/blastup/files/blastup2beta11.zip here].
Thank you for reading (and please excuse possible bad english ;)
/ Jolle (Ola Frid)
(L) [2001/11/28] [NielWaldren] [nwaldren@yahoo.com]
This image shows screenshots from example applications using GLGooey, a
collection of GUI components that we're going to be using in a forthcoming game.
As the name suggests, GLGooey uses OpenGL and although the examples shown use
GLUT, this is not a prerequisite - infact our game does not use GLUT. The fonts
are rendered with the help of FreeType which is available from [LINK http://www.freetype.org www.freetype.org].
The colors and fonts can be easily customized on both a global or per control
level. The look and feel of the interface can also be customized by overloading
window and event classes. As shown in the screen shots, it is possible to give
the whole GUI any degree of transparency allowing a 3d scene in the background
to show through. I've tried to keep the project platform independent which means
that a bit of work has to be done to integrate GLGooey into an existing project
(see the documentation for more info).
There's still some work to be done: Basic things like exposing the ability to
customize colors and fonts to the application (at the moment it has to be done
within an overloaded Window class), aswell as more complex issues such as
implementing further controls and a good dose of optimization. But, basically
the project is up and running so I thought I'd make it available. The source
code for the entire project along with project files for MSVC++, a couple of
examples and documentation can be downloaded from [LINK http://www.puls200.de/gooey www.puls200.de/gooey].
Executables for the examples can be found in the samples folder.
Coming soon: The game itself is making good progress, so watch this space for
screenshots :-)
(L) [2001/11/30] [FredDuval] [fduval@networksystems.fr]
These screens show the engine i am writing and the game we are working on with
Universe team. Our first tech demo can be downloaded at
[LINK http://www.TheOldenTales.fr.st]
Below you'll find some screens of three tools i wrote for the game. The first
one, called "Comet" is a particles system tool...You can also see "Planet" our
world editor in action. I am rewriting it to deal with lastest features of the
engine. The last tool you can see on the screens is "Nebula" a Room generator.
We started the project a few months ago. Before you ask about the grass, you
won't see it in the Tech demo, i am currently working on it but we may now sleep
a bit before the Tech demo 2 to be out and you can see it in action.. :-))
Some words about the game...our story writers are working hard to have somthin
really not comon...This game is a RPG style in a fantasy world like Daggerfall,
ishar, Dungeon master and more. 3 different levels of scripts are
planned...We'll say more about but...later...!
Enjoy the demo but dont try it if you have less than a TNT 3d card or less than
600 Mhz Processor because some stuffs are not optimised yet.
Kanda / Universe
(L) [2001/12/01] [MichaelDonath] [gleditzsch@yahoo.de]
These screenshots was make from our little shooting game, which we have
released. In the centre you can see a picture of our new project. Were are a
game programming group called xcellence. For this pictures we used our own
engine XFire.
We hope we can interest some people for the new project, because we are looking
for more coders and gfxmans.Also we are looking for a publisher for the new
project.
Some more Info about XCellence and the projects you can see at [LINK http://www.x-cellence.de www.x-cellence.de]
Michael Donath
(L) [2001/12/04] [WilliamDahlberg] [william.dahlberg@telia.com]
There has been a lot of advanced graphics IOTD's lately, so I thought I'd
post a little more...not so...advanced one.
This image is taken from a little game that I've done, it's called Alien
Attack.
The game started out as a little experiment(I'm learning OpenGL) and grew
into this funny little game, so there's a lot of things I would have done
different if I would have amied for a game from the start. As you can see on
the picture it is a simple shoot 'em up and all graphics is rendered using
textured OpenGL quads, the graphics may be extremely simple, but the result
is pretty neat! don't you think? The music and other sounds is played using
the REX library, created by Nathan Davidson, so big aps for him!
Although Alien Attack is a very simple game, it's still a complete game so
go to [LINK http://w1.164.telia.com/~u16402943 my webpage]
and download it! If you want the source code(comments are in swedish), you
can send a mail to [LINK mailto:william.dahlberg@telia.com william.dahlberg@telia.com] and I'll send it to you!
Now, you may think: "what's up with the name! Alien Attack...looks like a
normal spaceship-blowing-up-comets type of game to me". Well, read the story
at my webpage and you'll understand...
//William Dahlberg
(L) [2001/12/06] [SteveStreeting] [steve@stevestreeting.com]
Here's a few shots from the Quake3 level rendering of my engine, OGRE
(Object-oriented Graphics Rendering Engine).
I know what you're thinking: ok, ok, another Q3A level renderer, yadayadayada...
but what makes OGRE a little different is that it's a highly abstracted OO
engine which is not designed around BSP scene management, or even indoor
rendering - it's designed to be scene oriented rather than level structure
oriented, with a class hierarchy dealing with specialisations like using BSPs in
an indoor environment. All the features used in the rendering of the Q3 level
(material/shader management, geometry buffers, texture loading, curved surfaces)
are all generalised and just used by the indoor implementation - this does lead
to a bit of conversion overhead as it loads the BSP though.
If you don't want to, you don't have to know that OGRE is using BSPs internally
for indoor rendering, just use the top-level interface which is the same for any
scene manager, and just give OGRE a hint that you're going to render an indoor
scene and it will do all the optimisations internally. Frame rates are pretty
good but little optimisation has occurred yet beyond the general culling
algorithms so there's room for more. To be honest though I'm pretty pleased with
the results - one of the main reasons I implemented a Q3A renderer in the engine
is to see whether OGRE's abstracted architecture could handle a large complex
scene at a fair speed. I think it does pretty well.
OGRE also abstracts the platform and 3D API - it currently it runs on Win32
under DirectX, but the interface exposes nothing of that - again subclasses deal
with the specifics and I've deliberately tried to ensure that the interface will
map onto OpenGL easily (probably more easily than DX to be honest! - hmm).
Take a look at [LINK http://ogre.sourceforge.net] if you like: all source is freely
available for non-commercial use.
Cheers
Steve Streeting
(L) [2001/12/08] [HellRiZZer] [dprpg@yahoo.com]
Here is the image of my open-source Bezier Patch
Editor I created lately. It has MFC/OpenGL framework
and its pretty flexible (easy to change).
It uses standart MFC interface (dialogs, menus) and
also has been build using MFC OpenGL AppWizard (Not
sure who make it, but it was some time ago on NeHe's
website).
It heavily build on OOP concept and uses it almost in
every part of code.
It features:
- Node-type link for patches (e.g main patch and its
children),
Selection of patch,
Selection of color for patch and anchors,
4 Rendering modes for patch (Points, Lines, Filled,
Textured),
Multiple selection and control of anchors,
Save/Load patch in text format,
Creation of new patch is simplified to creating a
default grid of given size on XZ axis,
TGA/BMP/PCX/RAW texture formats support,
and some others, which aren't so important to list.
Editor's Note: The demo is available for download [LINK ftp://ftp.flipcode.com/demos/iotd-12-08-2001_patcheditor.zip here] (482k)
Have a go and try it for yourself, and please report
any errors you spot, because it haven't been in
testing yet.
(L) [2001/12/11] [ChrisEgerter] [powerrender@rogers.com]
Here are a number of screenshots from the latest build of the Power Render 3D
engine.
Top left - Detail entities for grass. These are procedurally generated around
the camera according to a vegetation map as you move around the world.
Top right - A skinned character casting stencil buffered shadows on the terrain
and herself. (self shadowing)
Middle Left - Above the trees looking down at the character in the middle
Middle Right - Underwater view. The water now distorts the world above.
Bottom Left - Realtime reflective water on Geforce3 with proper water plane
clipping (only portions of triangles above water are reflected)
Bottom Right - Some rocks casting stencil shadows into grass/weed rendering
using simple volumetric texture layers.
Keep in mind this is programmer art. I only have one tree and a few other rock
and log objects I am testing with.
Full versions of these pics are available at [LINK http://www.powerrender.com www.powerrender.com].
Chris
(L) [2001/12/12] [A.S.HAINES] [ash796@bcssrv3.bham.ac.uk]
This is a composition of screenshots from the 'Flu' demo, for the
Codecraft#2 8k competition.
There were six entries in this category, and it won.
I should mention that this was some time ago; Codecraft#3 finished
earlier this year.
However, since very few of you will be aware even of the type of
computers existence, I doubt many of you will have seen it. For what
it is worth, the computer used was a RiscPC equipped with a
StrongARM processor running at 202.4 Mhz. ARM chips have a very
elegant RISC architecture and are pleasant to program in machine
code. There are now several manufacturers of ARM based
computers. If you are interested in learning more, search for RiscOS
(and perhaps ARM). If you are not, please don't flame..
The demo had five graphical sections, clockwise from the top:
Coloured metablobs. As far as I know, this hasn't been done before,
but I can't follow the PC demo scene so it may be a rediscovery. In
any event, it turns out to be quite easy to do using a two
pass algorithm. In the first pass I simply set up 3 pairs of
metablobs in separate channels. In the second pass these channels are
summed then processed to find the brightness, and the proportions
used to give the colour.
The rippling reflection part takes up a large proportion of the file;
the compressed moon picture alone is over 3kb. (This section was
added when the competition rules were changed with the maximum size
going from 4 to 8kb.) If the reflections look a bit blocky, this is
because interpolation was used to keep the speed up.
The 'Fish' section was written by Alain Brobecker, a very skillful
French mathematician. In his words this is "a rotozoom with edges as
quadratic splines and an RGB trainee". (I believe the fish tile was
by MC Escher.)
The yellow thing is meant to be the front panel of a computer (Coder
graphics), which slowly burns away in a 512 translucent particle fire
effect. (The 'Phoebe' was a yellow computer which was canned
before launch).
Finally, for completeness, "Flu Flash" was a quick animated logo. I'm
afraid it didn't convert to JPEG particularly well.
Perhaps it is not surprising with the concept of "fluid" that some of
these pictures don't look as good as they do in action. Nevertheless,
I hope you like it even if this is not a typical pic of the day
entry. No first person? No shooting? What was I thinking? :-)
Yours,
Tony
(L) [2001/12/14] [KurtMiller] [kurt@flipcode.com]
The screenshots in this image are from [LINK http://www.gradientstudios.com/strayfire/ Strayfire],
the first game by Gradient Studios, my infant game company. The main artwork was done by Max Shelekhov ([LINK http://ghoul.flipcode.com link]), the music was
done by Pete Burke & Jeff Jordan ([LINK http://www.lossofwill.com link]),
and I designed / coded the game.
Strayfire is an arcade-style shoot'em up with 3D accelerated graphics, hordes of enemies, gigantic bosses,
and gobs of special effects. It will eventually be released as inexpensive shareware, but I decided
to release a beta version here first. I'm still working on finishing/cleaning it up,
and I was hoping you could help me test it :D.
The game requires a 3D accelerator (TNT2 or better) and DirectX 7.0.
The test demo features the complete first level. Its quite similar to what the shareware demo
will look like, but the goal of this release is mainly compatibility testing. It has been succesfully
tested on a TNT2 32Mb, Radeon DDR 64Mb, and a Voodoo3 16Mb. If you decide to give
the demo a go, please send info about any compatibility issues, crashes, bugs, funky behavior,
etc, [LINK mailto:support@gradientstudios.com here],
with as many details as you can provide (including system specs) so I can fix them! Thanks a lot.
The only known issue at this time: if you have multi-monitor support enabled,
you'll likely need to disable it before running the video hardware configuration utility.
Its available for download here: [LINK http://www.gradientstudios.com/strayfire/private/strayfire-beta-12-14-2001-p1-setup.exe strayfire-beta-12-14-2001-p1-setup.exe] (8.2MB, updated 12/15/2001 - 3:55AM, EXE-only [LINK http://www.gradientstudios.com/strayfire/private/strayfire-exepatch-p1.zip here])
Please don't distribute the test demo. Have fun! Don't forget to use the shield!
-Kurt
(L) [2001/12/17] [MartinCronje] [mcronje@ing.sun.ac.za]
This is from a terrain generator that I've been working on in the last couple of
weeks. So you may ask what's the big deal? I know there are SEVERAL random
terrain generators out there but the problem with them is that they generally
cannot generate a full-sized planet. They are generally created on a square or
rectangular grid and therefor discontinous at the borders.
So here goes. The way I do it is to generate a sphere from 12 connected
pentagons (like a tetrahedron, but with pentagons instead of triangles). This
gives me 12*5=60 triangles to work with as a basic sphere. You'll see this in
the bottom left picture. I outlined three of the pentagons with red. To increase
the poly count in the sphere, I simply split each of these triangles into four
additional triangles. The middle and left picture contains 3840 and 61440 polys
respectively. This is done blindingly fast and doesn't seem to impact the
generation (which I'll get to just now) much. I store the vertices and the
triangles in two arrays; the triangles as a triangles list with each triangle
having three indices referring to its three vertices PLUS three indices
referring to it's neighbouring triangles (might be important for some reason
like triangle strips or something). Another reason I used 12 pentagons was to
have all of the triangles in the final sphere model almost the same size.
Tetrahedrons as base models normally have a wide size range, especially at high
triangle counts.
The terrain generation is very simple: I form a random plane at a random
distance perpendicular to some random vector eminating from the centre of the
sphere. This distance will of course be between 0 and the radius of the sphere.
Then I go through the vertex list and determine for each vertex whether the
vertex is in front of or behind the plane (simple dot product calculation). The
vertices on the one side of the plane is raised whereas those on the other side
are left as they are. I say here raised but for every vertex I have also
included a height property and this I increase or decrease, I don't actually
alter the spatial coordinate of the vertex (this can be done at a later stage).
Another thing to keep the continents balanced is that every iteration I change
which side of the plane heights are altered, i.e. Iteration 1: front is raised,
iteration 2: back is raised, etc. Otherwise you end up with Himalayas on one
side of your planet and the Abyss on the other.
The two half-spheres in the top of the picture are the results. You can see that
the terrain is continuous all over the surface of the planet. The spheres I used
consisted of 245 760 triangles. I ran the program on a PIII 600MHz machine (no
3D yet) for a 1000 iterations (top) and 2000 iterations (bottom). The first
terrain took about 4.5 minutes and the second 9 minutes. There seems to be a
linear increase in time with an increase in one of the variables (number of
polygons and number of iterations). You'll also see that with increasing number
of iterations some of the sharp "cliffs" are removed. The smoothness of the
terrain will improve with increasing number of iterations.
Possible applications I can think of at the moment would be planet generation
for a planet-wide strategy game or something like that. Anyway, if anybody wants
the code, just mail me. There's still some minor alterations that I'd like to
make and documentation to write. (all code in C++).
Rho
(L) [2001/12/19] [NicolaCandussi] [contact@fluidgames.net]
This my first IOD post. Beside being a fouder of FluidGames, my main ( and
of course, loved) job is
working on 3D engines. The above are some screenshots of The Rage, our first
3D game. It takes the playability of old style beat 'em ups like Final
Fight, Strees of Rages and Double Dragon adding a lot of moves and the 3D
graphics allowed by the new hardware.
The main features of the engine are:
- written on D3D
vertex skinning
animation blending ( for mixing the moves)
camera spline intepolation
particle system ( for explosions, water drops, blood)
chroma mapping
billboarding
A playable demo including two levels is available at
[LINK http://www.fluidgames.net/games/therage/download.html www.fluidgames.net/games/therage/download.html]
Best Regards,
Nicola Candussi
FluidGames
[LINK http://www.fluidgames.net]
(L) [2001/12/24] [AndrewBowell] [joAndrew.Bowell@havok.com]
This image is a screen grab of our Havokized Shockwave 3D Christmas
Card. Here is the link to the demo: [LINK http://www.havok.com/card.html].
Havok has developed the Havok Xtra which is a fully integrated rigid
body physics simulation engine for Macromedia Director.
In this demo the idea is pretty simple, just drive around the bedroom
and bag as many Christmas Puddings as you can in the shortest time
possible; I think our office record is 19 seconds. As soon as all the
puddings have been gathered, the timer records the time taken and
immediately restarts the clock. On the first attempt you have 100
seconds, but from then on you must always beat your previous time,
otherwise you get whipped! Watch out for the snowman and the spinning
top.
This demo illustrates some of the behavior you can get with Havok as
part of a production game. The entire environment has been created in
3ds Max and exported using the Havok Exporter for max. Most of the
objects in the scene are physical, and the car itself is a modified form
of the older raycast car demos available from our Xtra Developer site
([LINK http://www.havok.com/xtra/index.htm]). If you don't have Shockwave 3D
installed or need to upgrade you'll automatically get our Xtra when you
do so.
Best regards and Happy Holidays,
Andrew Bowell.
(L) [2001/12/28] [Matt] [mfoggin@btinternet.com]
These are a few pictures of the particle system that I've been writing over the
past few days.
The top left picture is the standard flame type particle effect that you see in
most pictures of particle systems.
The top right picture is of a cool nebula effect that I stumbled upon while
playing around with the settings.
Below that picture is nice little water fountain.
Finally the two pictures in the bottom left are of another nice effect that I
discovered.
The upper picture shows a funny little wobbling star and the lower image (after
a few changes to the settings) shows that same star exploding.
A lot of the main particle system code itself is based upon the source code to
Richard Benson's Particle Chamber (sorry, can't find his website) so a lot of
the credit should go to him. The main things I've changed is convert it to VB
and add support for DX8 point sprites.
Now you may be asking "Why VB?"
Well there's a simple answer to this. VB is a great platform for testing ideas
out and it's also the programming language I know most about. I'm still learning
to use DirectX and I'm not that familiar with C++ so why make it hard for myself
and try to learn two things at once?
Current speed of the particle engine (which you may be able to see in some of
the screenshots so I won't lie ;) is about 45fps with 1000 particles on a 1Ghz
Athlon with GeForce 2 GTS.
Comparing the speeds with Richard Benson's Particle Chamber they are only about
10% to 20% slower. (more than likely because of VB)
The code at the moment is totally un-optimised and a lot of it is basically a
hack so there's no public executable or source at the moment.
Once I've cleaned it up a bit I'll update my (VERY out of date) website at
[LINK http://www.mfoggin.btinternet.co.uk/].
Matt
(L) [2001/12/29] [StefanSandberg] [stefan.sandberg@o3games.com]
Bacon-Trace 3.14 Beta...
Funky volumetric raytracer I tossed together in about 2 days.
Rather fast.. 32 spheres & a uv-animated box as the tunnel...
Try the executable at [LINK http://blocc.nool.nu/files/raytracing/volray.zip]
Stefan Sandberg / O3Games/Starbreeze.
(L) [2002/01/01] [OhadEderPressman] [ohad@visual-i.com]
Since 1989 Bomberman has been defined by gamers as the ultimate multiplayer
game. IMR-Bombers is a Palm version of the classic Bomberman & DynaBlaster
games.
From a developer point of view, the game includes a heavy Palm-Graphics-Engine
that manages to run the game at a rather fluent 20 fps.
We've worked on the AI for a long time (twice as long as it took to write the
rest of the game). We've re-written it twice and we hope that now it's strong
enough to play-smart for up to 4 Computer-Driven opponents on a 24-33mhz device.
Downloads and Movies (for those of you who don't have a palm) should be
available on our site by now. Visit the IMR-Bombers site for more info :
[LINK http://ohad.visual-i.com/PILOT/PILOT.HTM]
(L) [2002/01/02] [Cybermike] [cybermike@worldonline.co.za]
This is a montage of screenshots from a game is called 'The Colony 3 Chronicles'
that I have been developing.
I have allways wanted to see a strategy game that combined the four major combat
environments. So, about a year ago I set out to write the game that I would like
to play. So here I am a year (and I dont know how many thousands of hours later)
and I have now got my game to the beta testing stage. It takes place in space,
air land and sea. The game engine supports : 24 hour daylight profile editor.
Sun moon cycles, animated clouds and water, specularity and shadow, alpha
blending, blurring. Powerful AI and Motion dynamics for underwater craft,
surface craft on land and water, air craft, space craft and fixed defensive
turrets. Flexible camera options allow the player to set up optimal zoom and
FOV, Cameral modes include Tower, Target, Chase, Tactical, Pilot, and Padlock
views. Weapon dynamics cater for bullets, shells, lasers and missiles to be
assigned to any of the four craft. Upgrades for fuel capacity, damage, speed and
strike points. Proviion is made for up to 8 sides with a maximum of 100 'units'
per side. A maximum of 1000 objects can be brought into the game although, it
must be stated that a 16 frame explosion effect uses 16 objects. Not all objects
are displayed simultaneously. Usualy there are about 50 or so objects in the
field of view at any given time. There are 16 combat unit types. 4 sea (sub,
ptb, cruiser, destroyer) , 4 land (soldier, truck, apc, artilery) , 4 air
(fighter, chopper, bomber, transall) and 4 space (fighter, corvette, destroyer,
shuttle). Each combat unit has a maximum of 16 loadout slots. It is on to
these that the weapon systems and craft accesories are attached. and this is
where the fun comes in. There are a variety of weapon systems that can be
'bolted' on to each craft, and upgrades for each. Example, The machine gun is
fixed. Then it can be upgraded to a tracking gun, then to predictive targeting
and then you can upgrade the firing rate and the damage points.
The game
scenario setting is AD2550, when a group of colonists upset a bunch of baddies
and all hell breaks loose. The battle takes place in space, on two colony
planets, Mars, the Moon and Earth. The result of a hyperspace jump from the
outer colony worlds back to earth is a negative time shift and the battles
around earth occur 10 000 years in the past. The screenshots below are from the
Atlantis scenario. The process of creating 'maps' is very easy and i'm sure that
players will start creating their own worlds real soon. The game engine will be
liscenced will sell for about $10, but I am going to make all the artwork
public domain. I estimate that I will be releasing the game in about June
2002. The game is written in Visual Basic, using direct X8. The models were
created in 3D Studio Max, the 2D Artwork was done with Paint Shop Pro 5. My
development system is a P3 733, 128 Meg ram, Riva TNT2 Pro. The Compiled game
engine .ExE is 2.4 Megs and the total directory size with all artwork, meshes
and audio files is 1.25 Gig. . For more info, you are welcome to visit my site
[LINK http://www.cybermike.za.net www.cybermike.za.net] or u can [LINK mailto:cybermike@worldonline.co.za mail me] . Pop in for
a visit or a chat.
Best regards,
Cybermike.
(L) [2002/01/04] [Augusto] [boogie@usuarios.retecal.es]
Well, this is my little contribution to the IOTD. I've had to program a little
application that allows you to describe an L-System for a subject I've got. An
L-System is a kind of grammar that can be used to describe the shape of trees.
The picture shows four trees I've obtained with simple grammars, and this
technique seems to be very powerful. The application has two weeks of life since
I started it, and it was proposed to make us learn a bit of OpenGL, so it's
drawing techniques are pretty awful, but I like the results. (It was my first
experience with OpenGL).
I encourage anybody to download the source code from
[LINK http://duero.lab.fi.uva.es/~augurui/p3ig] and to improve it. It has a lot to be
done, such as variable width of branches, texturing, etc. In this URL there is a
brief explanation about how to write grammars (in spanish :( ).
Feel free to contact me by e-mail, if you liked it, or if you want to modify
it.
Merry XMas and a happy new year.
Augusto.
PS: The source is for Linux, using LessTif (I had to make it work on a Sun
machine with Motif), and MesaGL. Perhaps you will have to modify the makefile to
compile it....
(L) [2002/01/07] [Thomasv.Treichel] [thomas.von.treichel@codecult.com]
Code Creatures is a new Game Development System with State of tomorrow
technology. On the screenshots you see the first demo done with
CodeCreatures.
Some informatuion about the demo content:
- Using Vertex-Shader for the animated Gras
Using Vertex Shader for the realistic Sky-Dome with correct
Atmosphear- calculating
250.000 - 300.000 Polygons per View
aprox. 35.000 Polys per Tree
Right now it runs up to 15.000.000 Polygons per second on a P IV 1.5
Ghz
More information about codecreatures you can get at [LINK http://www.codecult.com www.codecult.com]
Greets,
Thomas v. Treichel
(L) [2002/01/08] [KisnémethRóbert] [kichy@pragma.hu]
This image is a screenshot from my game named Oxygene.
This game is a part of Boulder Dash and a part of Pac Man and a part of Bubbles
(which is also written by me).
It uses SDL (Simple Directmedia Layer). I wrote it in Delphi6 with JEDI-SDL. It
was written for the SDL Game Competition. It uses my SpriteEngine library which
is also available in the JEDI-SDL package. The game runs in 640x480x16
resolution. You can download it from my homepage: [LINK http://www.extra.hu/kichy1975 www.extra.hu/kichy1975]. From
my homepage you can download only the windows 9x version of game. The source
code is included in the package so if you want to recompile it under Linux (with
Kylix) just do it. The game is released under the GNU Licence.
The main features are:
- 640x480x16 bits (or 15 bits if your videocard doesn't support 16 bits)
Sound effects
Music (created by WoRRioR: [LINK mailto:worrior@freenmail.hu worrior@freenmail.hu])
Command line parameters to adjust or turn off music and sound.
Command line parameters to change the colordepth to 8, 15, 16, 24 or 32 bits.
Windowed or fullscreen mode (from command line).
The game is a quite hard one. Some hints: you can refill your oxygene from the
small bubbles. The big bubble hurts you. The small fishes doesn't hurt you. You
must collect all diamonds to complete a level, so doesn't allow the rocks to
fall onto any diamonds!
Hope you like it!
PS: sorry for my English...
(L) [2002/01/09] [WarrenMarshall] [warren@epicgames.com]
I've been overhauling my renderer DLL and over the last few days have
made some good progress. It's nothing state of the art, but it's more
than adequate to do the stupid little projects that I like to do.
The shader system is not all that fast either. The "388 fps" in the
screenshot looks good and all, but if I add more objects into the
scene it plummets pretty rapidly. :) Gotta work on that ...
The screenshot shows a 5 layer texture effect. It looks a lot cooler
in motion, but there are a variety of blending modes going on there
along with texture matrix manipulation. The latest update on my
hosted site explains it in more detail, [LINK http://epicboy.flipcode.com].
(L) [2002/01/11] [Martinknuth] [knuth@rbg.informatik.tu-darmstadt.de]
These screenshots where taken from a 3d-engine (editor) project I'm doing in my
spare time.
The figures are completely dynamic and animatable.
I use a shader concept, which can be compiled for static scenes to speed up the
rendering.
The shaders support all opengl blending modes and some more general, abstract
things like shadow buffering (self shadowing included - as you can see in the
image), environment mapping, phong shading, etc
the abstract rendering pathes (for example environment mapping) are
automatically optimised, if a grephics card supports a better version (for
example qubed environment mapping is then used instead of spherical env-mapping)
With a graphics card with more functions the engine doesn't get more features,
it simply gets faster, performing more effects direkly in hardware.
in the picture above you can see shadow buffering and embossed bumpmapping, the
figures are lighted with a radiance table.
the dragon runs with 10 fps on my voodoo3 / K6 II 500 and has 1700 triangles,
the code is absolutly unoptimised c++ in the moment.
the only extension which is needed is gl_arb_multitexture (for the use of both
texture-units)
w.b.r.
M.Knuth
p.s. I think I'll explain the shadow algorithm in the "tip of the day gallery",
since there are some tricks needed till it works, but it is as fast as simple
texture mapping.
(L) [2002/01/13] [Michi] [gamsi@chello.at]
These are some early Beta-Screenshots from an upcoming trailer which will be
introducing our game.
Some of the currently supported features:
- advanced particle system to create all kinds of particle effects
realistic skydome
layered fog
weather effects like: lightnings, rain, snowÂ
halos & lens flare effects
dynamic lightning
vertex shaders
multi texturing for lightmaps & simulated caustics
Â
The tool we programed to create the effects is also able to import complete
Lightwav Scenes and convert them into our own format.
Screenshots from this tool will be coming up soonÂ
at least we hope so :-)
Anyway, thats it for now ,-)
Best regards,
David & Michael
[LINK http://www.atteam.com]
(L) [2002/01/14] [OlivierZEGDOUN] [olivier-zegdoun@mediaone.net]
These screenshots are taken from the game "De profundis" I just started 6 months
ago. It is supposed to end as an action adventure simulator where the player
takes the role of a submarine pilot in an underwater universe.
It's a kind of "Elite" under the sea : do commerce and make profit, or be a
pirate and steal (but in this case, watch the patrols). Upgrade your hull,
equipment, weapons, and engage in non-linear random adventure.
A demo is available at [LINK http://people.ne.mediaone.net/olivier-zegdoun]
Some technical highlight:
- OpenGL for the graphics, DirectSound (did you hear a whale ?) and DirectInput
(with universal device mapping configurator available)
Brute force terrain algorithm with frustum culling (quicker and nicer than ROAM
or CLOD on my GeForce3 so I stopped trying)
"Infinite" terrain : the relief is repeating every 4096x4096 tiles, but not the
object contents.
true 6 DOF flight model (I use quaternions to avoid the "Gimbal Lock" problem
relative to Euler angles) : looping available ! (you better have a Joystick
here) and nice HUD
Fast sphere-tri collision detection with tri-tri detection when necessary
Particule system (explosion, torpedoes trail)
This should be considered as a pre-alpha version since there is nothing exciting
to do yet except feeling the ambiance, shooting some torpedoes, and going back
to the base for reloading...
Olivier
(L) [2002/01/15] [ScottRamsay] [sramsay@gonavi.com]
My IOTD is not an actual fighting game. The four shots are taken from a demo
that uses my 2D sprite library that I've been working on.
The sprites and background were ripped from the Capcom game: Street Fighter
Alpha 2 (using [LINK http://www.mame.net/ Mame]). In the demo you can move Sakura around with the arrow
keys. Pressing 'A' or 'S' will make her punch or kick. You can also press
ALT-ENTER to toggle fullscreen mode. In the background there are about a hundred
bikers moving across the screen. Pressing the number keys will change the
shading effects of the bikers
Since the library uses Direct3D to display the sprites, it gains all the nice
features of 3D games such as hardware acceleration and alpha blending.
Highlighted Features:
- Hardware sprites
Sprite mirroring and rotation
Alpha and additive blending
Colorkey and per-pixel alpha transparencies
Sprite color tinting with global sprite alpha
Supports BMP, PNG, and TGA files
Comes with a drag and drop Win32 GUI tool to generate multi-frame sprite files.
Windowed or fullscreen switchable modes available during runtime
Primitive drawing functions. lines and rect fills
A nice base support of core functions
IMHO, one of the neat things about the library is that it uses a quadtree to
manage images and sprites on large precreated textures. This allows sprites to
be of any dimension instead of the power of two size requirement that is typical
3D card textures.
The snapshots were taken from my Dell Inspiron 8100 laptop (WinXP Pro, P3-M
1.3Mhz, Nvidia Geforce2Go 32meg). The frame rate will probably vary on other
video cards. I've only been able to test the library on Nvidia cards since they
are the only cards that I own. You'll need the latest version of DirectX to run
the demo (Ver 8.1)
The Sakura demo executable and libary source are available on my web page
[LINK http://www.gonavi.com/ http://www.gonavi.com]. The library is in a very alpha state. In its current
condition, I don't think its ready for an actual project. I'm releasing the
source now for people who want to take a peek in the current development of the
library.
(L) [2002/01/17] [JonFrain] [jonfrain@hotmail.com]
This is a screenshot from my first game, and yes it's another asteroid
clone. I am posting this at flipcode because I am hoping someone may be
kind enough to give me some critiques on the code, which can be downloaded
at:
[LINK http://www.geocities.com/jonfrain/subdirectory/programming.html]
I am hoping for critiques both in terms of optimizations to be made and the
overall use/misuse of classes. Any and all suggestions are
welcomed/desired, including gameplay issues.
This project has been my first foray into DirectX. The goal was to design a
complete game utilizing some basic features of DirectX. I think I've done
that. Because the overall design itself wasn't created from the beginning,
I started just messing around with directX and moving the ship around, the
organization of the C++ design suffers.
My hope is to get some usefull information that will enable me to better
design this type of game. I will likely start over from scratch and try to
do it as best I can and utilize OOD principles to the best of my abilities.
(L) [2002/01/18] [Daren] [info@qubedesign.co.uk]
This game was conceptualised, designed and coded within 3 weeks using Director
8.5 for the main game, and Flash 5 for the front end. The aim of the game was a
christmas greeting to our clients.
You can have a play at:
[LINK http://www.qubedesign.co.uk/stopderek]
The Dereks were animated by using modelling clay figures and stop motion
photography with a digital camera for the animation. The gameplay is fairly
simple, but great fun for a while. The whole idea of the game was simplicity due
to the limited timescale, and only 3 people (2 artists, 1 coder) on the project.
All the graphics are 2D except for the scenery which is a very simple textured
cylinder and a textured ground plane. As the game is rotational in nature, all
the coordinates are stored in angular and distance based form. This makes
rotating the sprites to face the camera very simple. The shadows were handled by
simply using the sprite animation texture darkened and alpha'd and rotated and
finally repositioned.
I hope this helps more people consider Director for internet games, as the
latest version contains a simple to use 3D engine with some cool features - and
of course - it's multi-platform.
Daren
(L) [2002/01/21] [JohnSchwab] [johns@mysticgd.com]
Greeting fellow flipcoders. Over the years I have seen many posts on Games,
Landscapes, Effects, and Engines of all sorts. Well this time I decided to post
something that would bring them all together and is hopefully usefull for future
posts.
I am presented a set of pictures from my program called Shader Studio. It is a
utility for Direct3D 8.1 developers to design and develop Vertex and Pixel
Shaders. Currently I have just opened up beta testing and welcome any who dable
in advanced graphics to participate. Of course you will need the best video
cards to get the real features. A GF3 for Version 1.0 Pixel Shaders or a Radeon
8500 for everything.
Well to continue on with the posting, let me explain the pictures. In the upper
left is a picture of the standard cornell box with my technique of bump mapping.
I use an alignment of the textures to determine the mapping from light to
texture space, this way I can completely do the math in the vertex shader and
allow for any geometry so long as it has the proper texture coordinates. Then
the Pixel Shader processes the bump mapping using a simple dot3 combine of the
base texture with the bump map.
The next picture in the upper right is the same bump mapping Vertex Shader put
onto one of the DirectX spaceship models. The only difference is the subtle
attenuation of the light, done in the pixel shader.
The lower right picture shows the shader development interface, this is only one
of many controls to manage shader development, but it is the most important.
And last, but not least, is the best one. You will see what looks like an
ordinary landscape, but be fooled for this is actually the first implementation
of Real-Time Per Pixel Displacement mapping I know of. Yes, 1 polygon, 2
triangles, many FPS. Though it's in a higly experimental state, I just had to
post a pic. It currently has many limitations, one is that it will only run on a
Radeon 8500, next is it breaks down at sleep angles, but the effect is very
real.
For further information and to participate in the beta please see
[LINK http://www.shaderstudio.com]
(L) [2002/01/22] [EricB.] [eric_hcr80@email.msn.com]
This is a shot of my second game written with C++ , a Dr. Mario clone.
(Apppropriately but stupidly named 'DoctorC++'). I submit it as evidence to
those who might be struggling to break into the development field that it
can be done -- if you have the patience, persistance, and a good library
to handle the gritty details until you are ready to tackle them yourself.
It was written with the help of the '[LINK http://www.clanlib.org/ ClanLib]' cross-platform gaming library which
I discovered thanks to a news item here on FlipCode. It does all those things
like interfacing with your OS, loading images, and registering keystrokes that I
was struggling with before. It also has the added benefit of making your game
accessible to many different environments; I would definitely get a kick out of
seeing it run on something like BeOS.
The game itself took about two weeks to build and has good stuff such as
animations, configurable controls and play options as well as a high-score
section that demonstrates a way to serialize structs into a file. The code is
available along with a win32 version of the game here:
[LINK http://www.gla55pak.com/lameduckie/january/doctorc++/]
Eric B.
(L) [2002/01/24] [MikeSpencer] [mike@spacebirdz.com]
Hi, the images you see are of my game 'Space Birdz'
It's a modern reworking of several early 80's shoot'em'ups.
I've been working on it for quite a few months now,
and keeping up my motivation has been difficult.
The ship and enemies are all modelled in 3D. (if it's not clear)
I won't pretend i'm doing anything special, but it's no small project,
and there is still so much left to do.
Currently there are only 9 levels and a few power-ups,
but hopefully it is still worthy of your attention.
Highlights include a colourful particle system and flare effects,
100% programmer art, sound, and music! (the music sucks, trust me)
Also worth mentioning is that the levels are not hard coded,
as you can see from the bottom image, I have a beast of a game editor.
The editor has many, many, screens and controls, the shot I have
included is of the path editor, currently editing a bezier curve.
(the mad camera angle is purely to show it off :)
The editor is also used to create the in-game eye candy,
which can be chained together and assigned sound effects.
Most of my time has infact been spent coding the editor rather then
the game, and I haven't yet began to use it to it's full potential,
especially with regard to attack patterns and enemy behaviours.
Eventually I plan on at least 50 levels, a similar number of power-ups,
and a few large bosses to defeat. Hopefully there's still enough people
out there like me that appreciate this kind of game.
You can download an alpha version at: [LINK http://www.spacebirdz.com]
I could be off endlessly perfecting my 3d engine, but instead I am
cursed with the task of actually finishing something, it sucks.
(L) [2002/01/28] [LeeMazurek] [mazurek.4@osu.edu]
Here is a charged particle simulator I wrote for physics class. The teacher
was using some electron hockey game one day, and he made a comment about how
expensive it was. I then set out to program it myself, and sell my own
particle simulator cheaply. Hopefully schools will buy it.
The program uses SDL in combination with OpenGL. There is not really
anything special about the graphics, and the physics are brute force
unoptimized. One of the ways I cheat on the physics however is to allow the
graphics card to do the interpolation of the potential field rather than
doing it all myself.
It is nice to get a complete program done, as I have been programming for
quite some time and have not made anything that was finished (I have a huge
code base of highly optimized 3/4 finished game libraries). My project to
end all projects is still pending.
The simulator also include a game mode of course where the goal is to get
the particle into the goal. Try it out, it was rather amusing to see my
roomates be engrossed by such a simple game.
Editor's Note: The demo is available for download [LINK ftp://ftp.flipcode.com/demos/iotd-01-28-2002_chargedptl.zip here] (162k)
(L) [2002/01/30] [CEmirzian1@aol] [CEmirzian1@aol.com]
These are some screenshots from my game XOP. I've been working on this project
for the past year. It uses Allegro 4.0 for most of the dirty work.
The 2nd little blue number in the right-hand corner of the screenshots is the
number of on-screen objects.
Some numbers:
- 16,000 lines of C code
572 sprite images (enemies, bullets, explosions, etc)
141 tiles
52 sound effects
24 MOD music files
The engine supports up to 800 on-screen objects, 1800 shrapnel particles and 16
backgrounds. It's flexible enough to do just about anything you could need in a
2d shooter game :p
You can download a demo of it at [LINK http://rydia.net/udder/xop/]
Please try it out and tell me if it runs on your system :)
(L) [2002/01/31] [JackGreasley] [Jack@Greasley.com]
This IOTD is just to show you guys (and gals?) what IÂve been working on for a
while. ItÂs a system called Point (bloody marketing people) which is used by TV
companies to do ÂTelestration  (Horrid word, not mine),
or in other words, drawing over live TV images.
ItÂs currently in use by Sky TV in the UK for their Monday night football
program, and by a couple of people
In the United Arab Emirates. It will hopefully be used in the summer for the
coverage of the world cup.
Enough of that sort of thing, onto the techie bit.
Feature List
- OpenGL UI and rendering ~ 50fps.
DirectShow live video capture @ 24fps.
~10 Different Animated tools including
Line
Arrows
Curved Arrows
Bitmaps
Spotlights,
Perspective corrected bitmaps
True-type Text
Freehand draw
Floating, customizable toolbar.
Skin-able UI.
Shadows (of a sort)
Undo  Redo.
Full serialization.
Fantastic programmer-art themed skin supplied as standard
It was implemented mainly in VC++ with OpenGL, DirectX and DirectShow thrown in
for good measure.
It captures (DirectShow) and displays (OpenGL) full broadcast resolution video
(use of texture rectangle and BGRA extensions helped a lot)
Although there is a static scene in the background of the sample pics, the
system does display live video at ~24fps (honest).
Various little tools are provided for drawing and illustration (various types of
lines, spotlights, circles, bitmaps). It uses OpenGL to do
all of the rendering, including the UI. The whole thing is controlled from a
touch screen plasma or LCD monitor. One nice thing it does, is to
scale bitmaps with correct perspective (thereÂs a quick example lower left).
Curved line drawing is done with Catmull-Rom splines.
There was some talk early on about porting it across to Irix, so I decided (as
you do) to implement my own OpenGL based windowing system.
The windowing system turned out, to my shame, to be a lot like MFC under the
hood, although using Action objects for message calls
Instead of the not-very OOD MFC method of direct function calls. It does however
support nice things like complete application serialization, plugins and factory
based object creation.
The actual coding of the system took about three months, but the final system
(after much Âcan you just change this?Â) was
ready for use after about five months. One thing that really helped was the use
of test rigs from day one. The test I found most useful was a simple ÂRandom
Monkey that just sat there and hit random points on the screen for hours, its
surprising how many bugs that can turn up.
Output is done using a professional video compositing board. At around $4000
each, theyÂre the reason I canÂt post a demo.
It runs quite nicely on a 2Ghz P4 with 1Gb ram.
But the thing is finish and in use. It hasnÂt crash yet. Which is lucky Âcos if
it does crash 7Million people will know about it :o)
I will hopefully be releasing some of the source code (Core classes, Windowing
System, Video capture and Display subsystems) when
a) I can clean it up a bit. (Documentation is a little, erm thin as well)
b) IÂve sold a couple more systems and can put some time into the project.
The system would have been written quicker but for the hours spent reading
flip-code + forums  cheers.
Jack Greasley
Note: to those in the UK Â Monday Night Football on Sky Sports One. You know you
want to!
(L) [2002/02/01] [JonasEschenburg] [indyjo@gmx.de]
These are screenshots of a project I've been working on for over two
years now. I wanted to learn 3D programming and so I wrote a little 3D
engine which I used to create a simple terrain renderer.
The landscape renderer evolved over time and I stuffed it with more and
more features. Only recently I began adding game elements like enemies,
weapons and sound. These features are still experimental and relatively
quick hacks.
The upper picture has a bit of game action in front of a nice panorama
view. You can see an enemy flying towards us that has just been hit by a
missile.
The lower picture displays the CLOD triangle mesh and the texture tiling.
Terrain renderer features include:
- Continuous Level of Detail (CLOD) using a binary triangle tree
(based on the technique discussed at
[LINK http://www.longbowdigitalarts.com/seumas/progbintri.html])
complete texturing using a combination of unique texturing (one big
texture for a terrain patch) and a tile-based approach.
recently added: ground fog (used for enhanced visual quality and
also speed improvement)
Other features include:
- a skybox for the clouds
a Wavefront .obj loader for the models
an enemy AI that makes the enemies look almost intelligent ...
against rocks
a font renderer using font textures made with [LINK http://students.cs.byu.edu/~bfish/glfont.php glfont] by Brad Fish
The program was developed in C++ under Linux. So far this is the only
platform it works on, but porting should be relatively easy since I used
only portable libraries:
- [LINK http://www.libsdl.org SDL] for basic system access and input
OpenGL for hardware-accelerated 3D graphics (Direct3D support should
also be possible once I have made a Windows port, since I use my own
3D engine)
[LINK http://www.openal.org OpenAL] for hardware-accelerated 3D sound
[LINK http://libsigc.sourceforge.net/ SigC++] for advanced inter-object
communication
My ultimate goal is to create a modern version of the 80's classics
[LINK http://www.theunderdogs.org/game.php?name=Carrier+Command Carrier Command] and
[LINK http://www.theunderdogs.org/game.php?name=Midwinter+1 Midwinter],
featuring enhanced graphics and gameplay. Multiplayer maybe.
The only problem is that I will never be able to do that alone so I will
eventually release the game as Open Source.
As I haven't made a Windows port until now, only Linux users will be
able to try the demo at:
[LINK http://www.student.uni-augsburg.de/~eschenjo/landscape-demo.tar.bz2]
I hope you can get it to run. It depends on OpenGL and SDL 1.2.
Check it out! And please report any bugs you find. I know there are some.
Oh yes, as you probably noticed, my project is still lacking a decent
name (I called it "landscape" but that doesn't sound very nice...)
Have fun,
Jonas Eschenburg
(L) [2002/02/03] [NickLondon] [nutzboy@yahoo.com]
Not an incredibly exiting image, but this is real-time, incredibly fast
motion blur in action. :) I assure you it looks awesome moving, although I
cant release any binaries due to the nature of the project, sorry. :P
Incredibly easy to do, all you need to do is disable clearing the Color
buffer and render the scene with a low alpha, like glColor(1.0, 1.0, 1.0,
0.2), and viola! Fast and quite cool looking. :)
Only problem is that the objects become transparent (obviously) but this can
be fixed by sorting and rendering the polygons front to back. And the
problem here is that if you use alpha in any of your textures you'll get
wierd results.
But I'd imagine for in-game cutscenes or merely incredibly fast-paced games
this effect would prove quite handy, since there's almost no performance hit
at all.
Has anyone ever tried this method before? And are there better ways to get
around the 'transparent object' problem? Let me know.
(L) [2002/02/04] [StevenBeckett] [SBeckett@flowsoftware.net]
This is my first real games project.
Initially I intended Internet capabilities and a great AI engine. Off course
this was way too much for a first time project. I guess I fell into the trap
a lot of 'first timers' make. Fortunately I released the error of my way and
concentrated on just finishing the game (which is what I present here eh -
well its about 99% finished).
I've learnt quite a few lessons whilst developing Bomberman here's a few of
them:
- Think small and progress from there. You're never going to produce a
AAA title from your first attempt. Just think of it as a learning
experience.
There is light at the end of the tunnel - just stick with it.
Comment your code!
Finish your project.
There are loads more but that would take all day ...
If you would like to view the source just give me a shout.
You may download the Bomberman clone at: [LINK http://www.stevebeckett.co.uk www.stevebeckett.co.uk]
(L) [2002/02/05] [JaniPeltonen] [jani@dreamnation.co.uk]
I am currently working on a piece of software that creates evolutionary
art. It works by creating a number of images and letting the user select
which one(s) finds most interesting and wants to mutate or mate to create a
new generation of images.
The program features a separate render mode which lets the user zoom in on
areas that look interesting and render images with higher quality settings.
You can naturally save the images or save the expressions that created the
images.
You have full control of the mutation rate, number of offspring, initial
complexity and various other parameters.
The images above are all created with the latest version of the software.
You can download an alpha version from [LINK http://www.dreamnation.co.uk/mage www.dreamnation.co.uk/mage]
Some techie stuff:
The system works be evaluating and modifying a random expression tree. At
the moment there are ~40 different diadic and monadic functions functions
that the system chooses from. The functions range from simple addition to
4D fractals.
Throughout the evaluation all values are 3vectors, although internally some
functions turn them into quaterions before passing them on to the next
function in the expression tree.
(L) [2002/02/06] [JordanTuzsuzov] [mordred@dir.bg]
Most of the IOTD postings are high-tech graphics engines using the
latest graphic hardware, OpenGL/Direct3D APIs etc. We already made a
posting like that about our PC game called FreeGen. Now this is
something special :) Maybe some of FlipCode's readers don't know (or
remember) the time when floating point calculations were a restricted
area for realtime graphics. That was the time when 286/386 ruled the
world - the time of fixed-point calcs, raycasters and direct video-RAM
access.
This is the latest project of Garga Games (division of FreeGen developer
Dimension Design): 3-D game for low-power PDAs. It's a "3-D", not "3D"
because it's a special case of 3D environment. The screenshots are from
the version for CASIO PocketViewer.
Here are some details of this computer:
- V30 processor (i80186 compatible) running at 20MHz (which means good
old 64KB segmentation);
160x160 pixels with 1-bit "color" depth ;) touch-screen;
4MB or 6MB flash memory (used as RAM sometimes) and 128KB RAM for
dinamic application loading (where actually the application runs);
Casio OS developed by Casio specially for Pocket Viewer family of PDAs;
The game is coded 100% in C (without any ASM to be more portable), and
has really optimized code to run in realtime on computer like this one.
The code dosn't contain a single float or double calculation. The engine
uses raycasting for walls (like Wolfenstein 3-D) and projection/scaling
for sprites. The game has some interesting features like pseudo-lighting
effects (in 2 colors ?!?!) using two models of every texture (dark and
light). The game also contains the Garga Ball virtual analogue
controller, designed especially for pen-based computers.
You can download and try the demo version at the Garga Games website,
[LINK http://www.gargagames.com] - if you have a PocketViewer, of course! :)
Jordan Tuzsuzov
Programmer of Garga Games
(L) [2002/02/07] [JohanHammes] [jhammes@mweb.co.za]
These are a couple of screenshots from a paper that I presented last year.
What sets this apart is that most of what you see is generated in real-time as
you roam the landscape. This includes all the plants (well there positions), as
well as all the ground cover textures. Even with the current amount of plants,
frame rate is still above 25 on a PIII 500 with a geforce 256 card.
This is done by ecotope modelling ( Ecotope : A particular habitat within a
region with relative uniform climatological and soil conditions. Typically,
specific ecotopes will be associated with specific ecosystems.)
As you move around, the ecotope simulation is done for each new area that
appears on screen, and an appropriate ground cover and set of plants is
generated. Details of this, and the paper can be found on my website.
[LINK http://mzone.mweb.co.za/residents/jhammes/main.htm]
Johan Hammes
(L) [2002/02/09] [WolfgangEngel] [wolf@shaderx.com]
The screenshots in the upper half of the IOTD are part of an article
named "Photo Realistic Faces with Vertex and Pixel Shaders", which will
be published with the source of the necessary tools (diffuse cube map
generator, a texture mapping cylindrical wrapper (MAX Plugin)) and an
example program in the book ShaderX - Vertex and Pixel Shader
Programming Tips & Tricks (Wordware Inc., May 2002). This article shows
step-by-step, how to prepare art in a way, that the result looks
photorealistic and it explains each line in the source code needed to
produce photo realistic faces with the help of vertex and pixel shaders
in real-time.
The top left picture are two photographs from a digital camera that the
technique starts with. It was taken in complete darkness with a Digital
Camera with a flash attached. The green backgound was built from some
fabric purchased at a fabric store and glued onto some poster board.
The two screenshots in the second row of the left half of the IOTD shows
the differences between no spline blending and spline blending. Spline
blending is used by the cylindrical wrapper that is provided with source
as a MAX plugin. The screenshot on the top right shows the various
layers used to make the final image for normal 3D lighting. The bottom
left shows three cube maps that are used in environmental lighting.
The last screenshot in the lower right corner shows a final image when
environmental lighting is used.
Each of these renderings can be done in one pass on a Geforce3 and two
passes on Geforce1 and above. This effect can be achieved in 2 passes
on multitexturing capable hardware by using sphere maps.
The screenshots in the lower half of the IOTD are part of an article
named ""Designing a Vertex Shader-Driven 3D Engine for the Quake III
level and Shader Format", which will be published with the source of a
Quake 3/Return to Castle Wolfenstein level viewer in the book ShaderX -
Vertex and Pixel Shader Programming Tips and Tricks (Wordware Inc. May
2002). This article shows, how to implement a shader system for a
current game engine.
The example program converts the Quake 3/RTCW shader scripts to vertex
shaders while starting up. The author Bart Sekura divided the Quake
3/RTCW shaders into three categories to facilitate the setup code as
well as provide easier and more optimized code paths for rendering:
- SHADER_SIMPLE
SHADER_DIFFUSE
SHADER_CUSTOM
The first one is the default Quake III shader that uses base texture and
lightmap texture and constant diffuse. There is no vertex or texture
coordinate deformation and diffuse color is not coming from vertex
stream data. This is by far the majority of shaders, also known as
default shaders, automatically created when there is no explicit script
code. Primarily used for basic world geometry.
The second category is very similar to the above shader type, the
difference being the diffuse color is coming from vertex stream. It also
uses base texture and lightmap. Used primarily for mesh models embedded
in world geometry.
The third category covers all non-standard shaders, which represents
arbitrarily complex shaders, with one or many passes, various vertex and
texture coordinate deformation functions, etc.
Read more on ShaderX at [LINK http://www.shaderx.com www.shaderx.com].
(L) [2002/02/11] [JasonBuchanan] [jasonb@icentris.com]
Attached is an image of the day for a java based Tetris applet I am building. It
is the first real game I've built and one of the first debate-ably useful programs
I've created. If you are interested in the source you may download it at:
[LINK http://www.visualfxi.com/tetris/tetris.zip]
Note that this will compile and
run using Java 1.3 SE SDK and the appletviewer that comes with it.
(L) [2002/02/13] [StefanoLanza] [steflanz@tin.it]
These are some screenshots from TYPHOON, a landscape engine by Stefano Lanza.
Technology:
- Quadtree area mapping
CLOD geometry reduction
Unique terrain texturing
Illumination based on horizons mapping
Bump mapped water reflections
Trees
Realistic skydome
Sky fx (lens flares and sun burnout)
D3D 8.x hardware acceleration
Top screenshots show CLOD technique in action. Typhoon uses Peter Lindstrom's
CLOD algorithm "Real-Time, Continuos Level of Detail Rendering of Height Fields"
to reduce geometry in realtime, the results being high detail and long-distance
views at interactive fps.
Next are some sky images: the skydome is smoothly coloured according to day
time. Scrolling clouds, lens flares and sun burnout are the sky effects that add
to its visual impact.
Terrain illumination is based on horizons mapping. Horizons are calculated for
each point, then used to get the sun and sky contribution to the terrain
lighting. The first image was taken in a dark valley, an other image shows a
mountain peak casting its shadow on the terrain below. Note that also water and
trees are properly lit.
The terrain is mapped with unique textures, these are generated in realtime
blending a set of base textures according to the slope and altitude of each
point of the terrain, then cached. Near terrain is rendered a second pass with
detail-mapping.
Last images show lakes reflecting the surrounding scene. Latest Typhoon version
supports bump-mapped reflections.
The terrain is pre-compiled by an utility. Huge terrain size are supported (up
to 8193x8193 grid size), catmull-rom interpolation is used to interpolate the
original heightmap.
Visit Typhoon homepage at [LINK http://gpi.infomedia.it/typhoon] (soon
[LINK http://gameprog.it/typhoon]) to download the latest demo.
(L) [2002/02/15] [PDanhiez] [p.danhiez@wanadoo.fr]
This is a shot of my first (personal) game : ZooChess.
I've writen it in my spare time (6 month), and all the code is in C++ using
OpenGL. A friend designed all the chess-pieces.
The engine (called ZooEngine) has some features like bump mapping, water effect,
etc.. I draws polygons (45.000 for ZooChess) and the GUI is totally in 3D.
Stop ; this is not the aim of a game, this is only a technical approch.
When I was looking for chess game on internet, I only found
"beautifull-commercial-games" and "horrible-free-games".
That's why I decided to write my own chess game, and I hope I've reach the
equation : "beautifull-free-game".
So, you can play on internet or lan (classic host-client management) or you can
play in solo mode (a basic AI I've writen...).
This game is totally free, and you can download it here : [LINK http://www.pacome.fr.st www.pacome.fr.st]
or directly here : [LINK http://perso.wanadoo.fr/pacome.danhiez/ZooChess.zip]
Have fun !
Pacôme.
(L) [2002/02/16] [MeanFox] [meanfox@meanfox.com]
Thought I would submit an IOTD update for my 3D screensaver "World Saver 3D",
that made [LINK http://www.flipcode.com/cgi-bin/msg.cgi?showThread=10-11-2001&forum=iotd&id=-1 IOTD] back in October.
World Saver 3D looks somewhat better now. In the latest version, I have just
added moving fractal clouds, geostationary viewpoints, "time acceleration", and
a few other enhancements.
The fractal clouds just use random midpoint displacement - very fast, but
clearly inferior to other techniques such as Perlin noise.
Look forward to receiving any feedback (yes, I know everyone wants to see the
moon too!)
Mean Fox
[LINK http://www.meanfox.com]
(L) [2002/02/18] [KresimirKis] [kresimir.kis@zg.tel.hr]
If some of you are yet to implement texture compression in your OpenGL engines,
here is something that may help you decide whether it is worth the effort. This
project was created for evaluation of different texture compression methods
exposed through OpenGL ARB & S3TC extensions. Besides displaying 5 different
compression modes it also allows blending operations for alpha channel
degradation comparison.
The app was tested on two systems:
- C333, Win95, RivaTNT,
D850, WinMe, GeForce2MX.
RivaTNT does not support any compression extensions, therefore you'll get
unsupported viewports everywhere but RAW. GeForce class card should be able to
operate with both extensions.
Feedback from Radeon and other WinOS users is appreciated.
To keep the download small, I do not provide any textures besides those needed
by the app itself. The ZIP file comes with the VC++6.0 project ready to compile,
but be aware, the code is entirely procedural-based and quite a mess.
Further information and download:
[LINK http://free-zg.hinet.hr/KishBros/]
(L) [2002/02/20] [LesBird] [fueldepot3d@bellsouth.net]
Here's a shot of a game that started out as a Direct3D learning experience. It
was written in Visual C++ using many useful functions from the D3DX utility
library. Also some of the art and sounds were taken from the DirectX SDK (most
of you will probably recognize the 3D models). Basic Direct3D features (nothing
fancy here) were used including multitexturing, spherical environment mapping, 2
pass back-to-front sorted alpha blending, specular and diffuse lighting, full
scene antialiasing and lots of polygons. I wouldn't recommend running this game
on anything less than a GeForce2 GTS. On my development system, PIII733 w/GF3,
it sustains 60fps and can have as many as 100,000+ polygons on screen at once.
Some textures can be as large as 1024x1024 so be sure your card can support it
should you decide to play the game. The game is based loosely on an old classic
vector graphic arcade game from the 80's called Rip Off. Basically you defend
10 fuel pods from waves of incoming pirate ships. The 13mb freeware game and
more screen shots can be found at [LINK http://www.fueldepot3d.com] (DSL connection).
Enjoy!
(L) [2002/02/21] [MasonMcCuskey] [mason@spin-studios.com]
A spattering of screenshots from the sample programs of my new book, [LINK http://www.spin-studios.com/products/dxfxbook Special Effects Game
Programming With DirectX 8.0], available for USD$50 wherever fine game
programming books are sold.
This 913 page book contains complete code and tutorials for 13
commercial-quality effects:
- Fire (lower-right screenshot)
2D Water
Image Feedback (lower-left screenshot)
Image Warping
Clouds
Image Manipulation (Blurring, Sharpening, Edge Detection)
Transitions (cross-fades, wipes, melts, and more)
Advanced Particle Systems (driven by a scripting language)
Explosions (upper-left screenshot)
Guns and Projectiles (middle-left screenshot)
Lens Flares (middle-right screenshot)
3D Water (upper-right screenshot)
Vertex and Pixel shader effects
Also included are chapters and sample programs covering ALL of the new DX8
features (audio scripts, shaders, DirectInput action mapping) as well as some
advanced C++ techniques.
Full-sized versions of these screens (and other sample programs!) can be found
on the book's [LINK http://www.spin-studios.com/products/dxfxbook product
page].
Editor's note: If you have comments about the image itself, please post them on this comment
thread. If you have comments about the book content, please post them under [LINK http://www.flipcode.com/cgi-bin/msg.cgi?showThread=Book-SpecialEffectGameProg&forum=rotd&id=-1 this resource summary].
(L) [2002/02/22] [Bruno] [Bruno@g-lords.com]
These are work-in-progress shots from our new tech demo, showing off realtime dynamic
shadows. Our engine, ASKYN, is able to push quite a hefty quantity of polygons at
the graphics card and is heavily optimized for the GeForce family. We will include
support for ATI hardware although not right away, as we are waiting until the actual
game programming step is over. All elements of the scene are lighted equally, both
moving and static ones, although special optimizations are done to each one. Our site
is [LINK http://www.g-lords.com www.g-lords.com]. We would like to thank in advance to any one who cares to comment this post.
(L) [2002/02/23] [RichWilson] [rwilson424242@home.com]
This is a small project I worked on for a computer graphics class at the
university I go to, as well as a seed idea for an adventure game I've been
pondering. It's basically an overhead adventure game mapped to a cube. The cube
is rotated with the mouse and the player is moved via the keyboard. There are no
gameplay elements besides movement and collision detection as of yet, but that
may be forthcoming. Some of the features include: multipass texturing ( the
water is environment mapped for pseudo reflections, and the texture undulates as
well ), alpha blended cloud layer, particle systems for the fountains, imported
3d objects ( the castle), skybox, billboarded light glow effects, and collision
detection for the character.
Any comments or suggestions are welcome.
(L) [2002/02/24] [PalsyPalooka] [texameije@belgacom.net]
OK, I know you're all busy with lots of 3D stuff and you're expecting very
impressive multi-color images of super-high quality. Well, today you'll have to
do it with my super-impressive 2 color pictures (back to the basics!). I'm
coding some games for my calculator "ti-83" in ASM and because you have only
32kb memory, you have to do your very best to get some graphics out of that
machine (yeah, machine sounds heavy...).
The first screenshot (Race) is from my racing game in which you have to shoot
eachother (2 players). But because it works with a link between 2 calcs, the
game isn't allready bugfree, I'm working on it but you can't download it.
Another thing: you might have noticed: the game is still called "race". Someone
has a suggestion for something that sounds better?
The second screenshot (The Matrix) is just a picture, not screenshot from a
game. I took it from a poster of the film and resized it with Paint Shop Pro,
then I drew it on my calculator. Because I think it's pretty cool, I put it
here...
I took the third screenshot from my second game finished in ASM: PipeMania. I
made it earlier in Basic but it worked too slow. The idea came from a fantastic
arcadegame in which you have to make a pipe before the water leaks out of it. If
there is someone who has a ti-83 (with ION (downloadable from ticalc)) and if
you want the game: it will be available on [LINK http://www.ticalc.org www.ticalc.org] soon(=next week) (be
sure to get version 2.1 and not 1.2, it's bugged ;-( ). Or you can always mail
me at [LINK mailto:texameije@belgacom.net texameije@belgacom.net]. (Off course you need a ti-83 )
The last screenshot comes from my program StarWars. It should be a very simple
game (fly forward and avoid the blocks) but because I can't get the stones big
enough (not on that calc :( ) and you haven't got the feeling you fly
forward..., but on the other hand, I think the screenshot looks nice.
For someone who is interested: ???
Technical aspect of the calculator:
- ti-83 graphical calculator
by Texas Instruments
z80 processor, 6 MHz
32kb RAM
screen 96*64 pixels
link-port
This was Palsy Palooka speeking, member of the TexAmeije programming team
(BASIC&z80ASM for ti-83 and C++)
(L) [2002/02/26] [BuddyBetts] [MBetts@ea.com]
So here's my first IOTD submission -- my "it's been done millions of times
before" ray-tracer! It contains the standard features:
- spheres
planes
polygons (well, only triangles, but easy to convert to any convex polygon)
cylinders
ambient light
point lights
spot lights
soft shadows
reflections (can set level of diffusion)
texture mapping
bump mapping
multi-texturing
It's written in C++ and uses OpenGL. Wrote it under Windows, but since it
uses OpenGL don't see why it wouldn't work under other OSes. In fact, if
you're so inclined you can pick up a copy of the code at
[LINK http://www.geocities.com/b_betts/pics/raytracer/raytracer.html]. If you've
ever wanted to write cool ray-tracer effects but are too lazy to do the
basics, now's your chance!
-Buddy Betts
(L) [2002/02/28] [CyrusRohani] [crohani@cybermail.net]
Well, here it is - another terrain engine! I know there have been many lately,
but I think mine is a little different and somewhat interesting (and I'm proud
that I acually finished it!). The terrain you see was entirely generated with
[LINK http://www.planetside.co.uk Terragen] and I found the world and heightmap files at an
online gallery. In retrospect, the simple hills and valley are a little plain
for a demo, but it took so long to create that I don't have the patience to do
it again!
The original intent of this demo was to create an engine that could display
hi-res satelite imagery and 3d terrain in realtime. I could then get data of
places I have been, and check them out from a different angle! Unfortunately,
the only high-enough-res data that I found costs thousands of dollars (anyone
know some sources?). I then fell back to using Terragen to create equivalently
high-res images. Since I wanted to use satelite imagery, there are no ecosystem
based effects. No detail textures. No artwork whatsoever. No flashy stuff.
Nothing. Its one texture for the terrain - as raw as it gets - and that's the
goal!
Actually, I lied. The entire scene is composed of two textures - the skybox and
the terrain map. The terrain map is a 16384x16384 RGB file (grand total of 268M
pixels!). In its uncompressed form, it consumes 768MB and after pre-computation,
it is over 1GB! The landscape is modelled to be 8192x8192 meters, giving the
terrain map a resolution of 4 pixels/m^2 - quite some detail! The terrain data
and texture data are stored in a quadtree-like data structure that facilitates
fast dynamic level-of-detail for both of them. In this demo, there are 128x128
bezier patches (sorry non-GeForce3+ users) that compose the terrain, and each is
associated with "relative" texture coordinates (uv's relative to the entire
terrain).
When rendering, the quadtree nodes are allocated/deallocated dynamically. For
each visible patch in a node, its actual area (in this case 8192/128=64m^2) is
divided by the projected screen space area and a resolution for the patch is
determined. Starting at the tree root, I traverse downwards until I find a
texture that covers the desired area and is at greater or equal resolution to
the patch. Patches don't contain texture coordinates in their vertex data (to
save memory) but a single vertex buffer with 16 texture coordinates (to match
the cubic patches' 4x4 vertices) in the range [0,1] are used along with a
texture matrix to compute the relative coordinates into the desired texture.
Some of you may be saying "hey, this is sort of like a super-mipmapping algo."
Yup, It is similar (although quite different in some respects) and it allows
keeping the pixel:texel ration between 1:1 and 1:2.
The bezier patches themselves also use a level-of-detail technique. Using the
screen space projected area, it is easy to determine how many segments are
needed to draw the patch at a certain resolution (pixels/segment). In my case, I
use 16 if it is relatively close and a geometrically precomputed lower-bound if
it is relatively distant. Since tesselating patches with different control
points would cause cracks in the terrain, each patch examines its neighbors
before rendering. It then tesselates its East edge according to the control
points of its East neighbor and does similarly with the South edge. Both North
and West edges are tesselated according to the patch's determined resolution,
regardless of neighboring patches.
You can see the result in the screenshots. The larger top-left and bottom-right
shots show you the landscape from 1.8 meters above ground, and the larger
bottom-left and top-right shots lift you by 100 meters or so. The 8 smaller
shots show a zoom sequence from 7 kilometers back to a closeup!
(L) [2002/03/01] [JamesMatthews] [jmatthews@generation5.org]
Something different for the IOTD. Here is a screenshot for my upcoming
program, Image Analysis Explorer Pro. It is the successor to Image Analysis
Explorer and has a lot more features such as:
- Infinitely quicker than Iae (close to 1000% sometimes!)
Convolution and rank based filtering
Floyd-steinberg dither, greyscale conversion, inversion.
Histogram, thresholding.
FFT/IFFT (hopefully, yet unimplemented).
Sobel and Canny edge detectors
Region of Interest support
Opens JPG, GIF and bitmap files (Iae was limited to bmp)
Unlimited size of file (Iae was limited to 640x480).
Existing filters implemented in Iae.
Here you have (from the top-left, clockwise):
- Original image, with a histogram displayed for a region of it.
Floyd-Steinberg dithered image, with a mean filter applied to a region.
Greyscale image with a mean filter applied on an 11x11 neighbourhood.
Sobel edge detector inverted for clarity.
You can look at the existing Iae here: [LINK http://www.generation5.org/iae.shtml].
The new version should be out within the next week or two, I still need to
implement a few features and really optimize the rank filters. As
with all Generation5 stuff, the complete source code will be released,
although you'll need the Micrsoft Vision SDK to compile it.
Comments and suggestions welcome!!
- James Matthews
Generation5: [LINK http://www.generation5.org/]
(L) [2002/03/02] [MichaelFawcett] [snuff@cfl.rr.com]
These are 2 screenshots from my final project at Full Sail. We had a team of 4
and 2 months to complete the project from scratch.
Features:
- Particle Systems for spell effects
DOF animation for all player models
SceneGraph traversing for rendering and culling
Multiplayer support (Client/Server model: We haven't stress tested to find out
the limit, but we played 5 clients with no noticeable increase in lag, i'm
guessing we could handle 10-15 clients)
Menu System
OpenAL for 3D positional sound.
The game is called Relic and is a First/Third Person Shooter. The player can
choose from a Max-Payne style view or a typical FPS view.. Instead of using
guns though there are 4 classes of wizards that the user can play, each one with
5 unique spells.
Relic is multi-player only at the moment. We used Quazal's Net-Z API for the
networking. Net-Z is being used by Microsoft for the X-Box's multiplayer
support as well.
There are 4 levels, one for each wizard class. Pictured are the Elementalist in
his Volcano level, and the Naturalist wizard in his Garden level. The
screenshots are from our observer camera so that you could get a better view of
the level, the spell, and the character.
There are particle effects for meteors, poison clouds, insect swarms, dirt
explosions, snow fall, and fire.
We used Multigen Creator to make all the character and level models. The
scenegraph in Creator worked great because we used OpenSceneGraph for the
rendering and model loading in our engine. We had to add DOF support to the
.flt loader in OpenSceneGraph so that we could do the animation for our
characters. We were planning on using sequence animation, but went with DOF to
use less memory.
OpenAL was used for the 3D positional sound. We implemented an add-on to the
.flt loader so that we could place sound in the level using Creator. We used
the sound coordinates to handle ambient sound effects, such as lava bubbling,
crickets, crows, etc.
More screenshots are available at my homepage [LINK http://home.cfl.rr.com/snuff/]
There is no download available at this time. Besides the distro is around 500
MB so i doubt anyone would download it.
(L) [2002/03/04] [DonBrien] [dbrien@freestandingentertainment.com]
This is a project I have been working on for a while now in my spare time. It is an old-school,
isometric RTS game. All artwork and programming have been done by myself so far. I know the artwork
isn't state of the art, but I am proud of it for now. I hope to improve it as the project
goes along. Anyway, here is the feature list:
- Programmed in C++, using OpenGL for graphics, DirectX for everything else.
Complete GUI system
A map editor is in a similar stage of development - uses MFC.
Relatively complex pathfinding implemented. Works well, units handle static/dynamic obstacles intelligently.
Replay function added
That is about all I can think of right now. I am going to be working on networking
for the next little while, but luckily I have prepared for that from the beginning
(replay and a peer-peer network model have a lot in common). If you would like to
follow the project you can visit my site at [LINK http://www.freestandingentertainment.com] .
Maybe I will post again when the game goes beta.
Absolution (Don Brien)
(L) [2002/03/07] [JeffKiah] [y2kiah@hotmail.com]
This is my first time posting on Flipcode but I wanted to get some
feedback on my current project. It's a pure portal engine written in VC++,
uses OpenGL for rendering and FMOD for sound support. My ultimate vision is
for this to be a GAME engine and not just a PORTAL ENGINE, meaning it will
be a simple yet effective way to build a complete and customized game. Since
I'm just one man and I'm doing this in my spare time away from my college
studies, I plan on keeping things as simple as possible without sacrificing
quality. Here is a current features list.
I call it the QuickPort engine
- Portal rendering with an OOP algorithm
3d collision detection
Fully Dynamic Lightmapping (no static lighting)
Movable Sectors (elevators and such)
Particle system
3d object support (loading of my own ".3d" format)
Texture blending over portals to simulate glass
"Sound event handler" - what I call my system of deciding which sound to
play and when
FMOD sound support
Skybox
NO DIRECTX USED!! woohoo.
Here are some things that are in progress or will be in the future...
- Sloped walls / floors / ceilings (right now the engine assumes walls
perpendicular to the floor and ceiling for simplicity of level design)
md2 file loading & animation (there are so many great md2 models out
there, and I'm not an artist, how could I NOT use this resource?)
Dynamic shadows WITHOUT using stencil buffer (this is very close to being
done)
Link to a quadtree terrain engine I developed for indoor / outdoor scenes
Weapons / Items and other gameplay related features
Network support - This I will need help with, but what good is a game if
you can't play with yer friends?
Optimization (change drawing algorithms to use triangle strips instead of
single polygons, among other things)
Level Editor (I started this today, shouldn't take too long to get
something rough but useful ready to use)
Well I have more visions for this thing but I don't want to bore you. My
plans for the engine other than providing it to others for game building, is
to build a game myself. A 3d rpg type game similar to Ultima Underworld
(probably the best game I've ever played) or something along those lines.
I'm not looking for another Quake / Unreal / Half Life clone, that's been
done and this engine is FAR from a Quake engine, so I have to use what I
think fits, but it's still capable of a shoot'm up game I suppose.
Alright well, let me know your thoughts (I know these screens aren't much
to go by). If I get enough feedback I'll definitely be posting a demo in the
future when it's ready. Hey, if you're interested in getting in on this
project I'm looking for 1 or 2 people, especially good artists and network
programmers. Email me at [LINK mailto:y2kiah@hotmail.com y2kiah@hotmail.com] cause I'm very interested in
getting this project going with a small team. Probably just for fun but
maybe we can put something out worthy of selling?! Long shot I know but
given the right circumstances, who knows. Take care everyone.
(L) [2002/03/08] [BasKuenen] [baskuenen@hotmail.com]
I graduated in computer graphics, by building an editor, on top of my
improved 3D engine, that enables us to create screensavers by a click of the
mouse.
Our first screensaver created with this new program is the Universe
Screensaver you can find at [LINK http://www.gizmozone.com www.gizmozone.com].
Some engine specifications:
- Textures (with alpha layers) loaded from JPEG. Mipmapping, wrapping and
all usual settings are supported.
Materials define colours, texture ptr, rendering layer, fog, blending,
depth functions etc...
Mesh models imported from 3D Studio Max. Possible LoD settings.
Objects in tree make up the world
With camera objects and paths (animated by B-splines,
Catmull-rom-splines), scenes and a timeline control we can virtually create
movies.
Sphere-frustum culling and Level of Detail at the core of the engine,
speeds up rendering of all the objects.
Some other objects: geosphere, quad, cylinder, quadtree, particle sphere
(stars), particle cylinder (smoke), flame (shuttle exhaust), font, light,
viewport...
With the solid OO structure it's easy to add new objects (like the landscape
for our next saver). These new objects already take advantage of the basic
object properties (frustum culling, material use, matrix orientation, ...).
It speaks for itself that in the next project we can concentrate on these
new objects, and already have the existing objects at our disposal.
Lensflares, paths and camera animations are a few that are always useful!
The result can be viewed and edited in real-time in the editor by using the
mouse. Now it's fast and easy for the graphic designer and managers to tweak
the world for the desired result. A world can be saved and loaded via the
engine. Because the saver is also based on the same engine, I can save a 3D
world to file, and load that same world in the screensaver.
There's too much to name in this small description, so feel free to ask any
questions.
You can find and download the Universe Screensaver at [LINK http://www.gizmozone.com www.gizmozone.com].
Please try it and let us hear what you think if it,
- Bas.
(L) [2002/03/09] [Louis-CharlesDumais] [lcdumais@hotmail.com]
I feeled artistic... its 2:00 am in Quebec and the sky is
dark.
[LINK http://www.gel.ulaval.ca/~dumais01/genu]
and the direct link to the file is
[LINK http://www.gel.ulaval.ca/~dumais01/genu/artisticNeo.cpp]
Have I say there is more to come?
louis
[LINK http://www.gel.ulaval.ca/~dumais01]
(L) [2002/03/12] [JoaquinGray] [jgray@rain.org]
This is a shot of my third-of-the-way-done (mm-hmm) Windoze app which
I have been working on for the last couple of weeks. As are many of
you, I have been working my way towards a nice 3d game, but my main
stumbling block came when I realized there wasn't any (imho) decent
way to create level geometry; Radiant makes me feel icky, and my
system as well. So here's the deal:
- Loads quake3 style *.shader files and images directly from
zip file (or pk3, whatever)
Loads 3DS and MD3 models (perhaps more later) for static
geometry (can be exported as such, or just as bbox data)
Saves in proprietary format as well as user-definable text
format (i.e. you could export easily right into q3map)
Simple CSG with brushes
Patch curves, with a variety of primitive basics (tubes,
cones, etc)
Editable entities with user-definable text-entry fields
Object/face selecting
The general difference between this project and radiant is similar to
the difference between Nendo and 3DStudio. My goal is to have a very
easy interface as well as a heavily modifyable output for future use
with any project as well as Quake3 level editing.
If you have any suggestions or flame, feel free to email me. This
project is geared towards anyone who wants such a tool.
(L) [2002/03/13] [DavidPaull] [david@tanzanite.to]
I would like to announce a new book called, "Programming Dynamic Character Animation" published by Charles River Media, which is available now. The book contains, and explains a new animation rendering engine that can effortlessly render skinned skeletal animation using Direct3D, or OpenGL. A wrapper is written for each API that you want to support, and the main animation engine loads the correct dll. Unreal Tournament has similar functionality in that they let you choose the "back end" renderer. This screen shot shows the benifit of this type of architecture. I wrote a new rendering dll that is abstract like "cartoon render", or in this case, ASCII render. The code for the main app remains the same. At runtime, the user selects the appropriate rendering dll.
Yes, this image is a cheat for the following 2 reasons :
- 1) the bright areas of the source image are actually visible ~20%. Source image can be 3d realtime rendered, or 2d image.
2) I have the saturation high so many of the characters are the @.
The 2d source for this particular ASCII image is from the cover to Stephen Kings Novel, "Desperation"
Text character selection is shape, and intensity based.
I havn't decided yet whether or not to release the ASCII dll. It was really to show how easy it is to modify the rendering. The book includes the Direct3D, and OpenGL dlls.
The book includes source code for a Modeler, and an Animator, and the dll based rendering engine. It is designed to be a closed system, in that all model creation, editing, and animating code uses the game engine for "what you see is what you get" creation. Of course it can load models from MilkShape, and 3D Studio MAX as well. But the goal is for you to add modeling features yourself that 3DSMAX may, or may not have, like, for example, 3D painting multitextures on objects.
I have been professionally employed as a software engineer in the entertainment industry for 10 years. I am currently employed as a software engineer at [LINK http://www.vr-atlantis.com/ Atlantis Cyberspace]. I am paid to "reverse engineer" games like Quake3, and UnrealTournament so they can be modified to run on custom stereovision hardware. Many of the things I learned during the reverse engineering process have ended up in this dll based Direct3D/OpenGL engine. I am going to provide updates of this engine to owners of the book for about a year. I plan on adding many features to the engine, including ANTI reverse engineering code, mainly to prevent cheating in any game that uses this engine.
Sorry this post is all about the engine, but thats all im in it for... animating is for artists.
Additional pictures can be found at the [LINK http://www.tanzanite.to/ Tanzanite Software Homepage]
Thanks
David Paull
(L) [2002/03/14] [HardyWinter] [hwinter@hamatu.de]
these screenshots are taken from our MMORPG "World of Pirates". The
idea behind this project is to create an online world with a real
historical scenario like in a earlier well known game title. Settled in
the Caribbean in the 17th. century you can be an adventurer, merchant,
head hunter and of course a pirate.
And if you are good enough, you can become a governor. We added some
more features like found own nations or build new cities.
The client uses Windows and DirectX 8. A transparent interface is
already implemented and actually we are working on special effects like
rain, fog and day/night-cycle.
The game server is running on a linux system.
A preview video will be available at our [LINK http://www.worldofpirates.com website] within the next few days.
yours sincerely
Hardy Winter
(L) [2002/03/15] [NielWaldren] [nwaldren@yahoo.com]
As you can see from the image, this IOTD has to do
with particle effects. One big problem with images of
particle effects is that particle effects generally
only look good when they're moving. But seeing as the
main reason for this post is not to show off the
particle effects themselves, but to present a means of
creating them, it's perhaps not such a problem.
The tool has been designed to allow the user to create
particle effects which can be exported from the app
straight into the game engine. A particle effect is
composed of a number of particle systems, and each
system may be influenced by any number of so-called
affectors (gravity, faders...). This structure is
represented in a tree view which you can make out on
the right hand side of the images. The particle effect
runs the whole time in the display window, with any
changes and additions to the effect taking place on
the fly.
The thing that makes the tool interesting is that the
affectors have a generic interface to both the tool
and the game engine, which allows the particle engine
to be extended by new affectors without having to make
any changes to either the engine or the particle tool
(at the moment it's all statically linked, so I do
have to recompile).
A small demo is available at
[LINK http://nwaldren.bei.t-online.de/other_stuff.htm]. It
includes a few affectors, a couple of (meaningless)
samples and supports saving and loading in an ascii
text format.
(L) [2002/03/16] [MarkW] [mwillist@ns.sympatico.ca]
This is my humble IOTD. It is my 2D (DirectX) game I have been working on
for about 6 months in my spare time. Without Flipcode, it would not be here
at all. The vast database of information and people online willing to help
are to be commended! I am a weekend hobbiest programmer using straight C.
( I am currently at 221 days studying 'Learn C++ in 21 days) :)
Lucky Sevens DX is one of two, 9 card slot machines, I have been working on.
Nothing special here at all. Just an un-original idea, reinvented and placed
into the DirectX enviroment. It may not be a leading edge 3D shooter, but I
had quite a few people lined up to play it at my last house party.
Improvements coming are:
- PAY button works. (Not implemented yet)
Network play. I plan on having a central server controling the payouts
like the real Casino world does.
Programming this in DirectX 3D or OpenGL. Would be nice to see the wheels
in 3D!
The install program for this IOTD can be download from:
[LINK http://ringingbells.dns2go.com/LuckySevens.exe]
(L) [2002/03/17] [AlexanderLuddy] [aluddy@ozemail.com.au]
The images above are from Volume War, a GPL'd game that I have been working
on in my spare time. Volume War is best described as Worms in 3D. It is
practically finished, at least as far as I am concerned. There is still
some content to be added and some tweaking/polishing to be done before 1.0
though (the explosion particles for example).
With regards to the FPS, my machine is a P3 600, TNT 2.
At this point I am extremely keen to get some feedback so as I can maximise
the all important fun factor. The levels I have created have all been put
together without much play testing, I am hoping that in time the factors
that make a fun level become clear (if there is a demand I shall release a
level editing guide). I have also not done much play testing with regards
to weapon balance, some of the weapons need quite a bit of
tweaking/polishing. At the moment the AI is probably a bit too mechanical.
I found that while aiming in 2D with 1D wind is one thing (Worms), aiming
in 3D with 2D wind is quite another. I have attempted to address this issue
using a "Helper" (explained in tutorial), however the feedback so far is
that it does not help a lot.
Describing my art as "programmer art" is probably a bit too flattering and
most likely insulting to fellow programmers, the stuff that looks
reasonable has been taken from the Internet.
Here is a feature list.
- dynamic terrain and corresponding vertex lighting
bounding box frustum culling
some nice physics
3D sound using FMOD
1 and 2 player modes
tutorial and campaign (story coming soon)
I am satisfied with the way the game has turned out. Having started it
about 10 months ago my skills have developed quite a bit. In any case it is
a finished game (practically), and we all know the value of that. Thanks
heaps to those who download it and provide me with feedback.
[LINK http://yellowsoftware.sourceforge.net/volumewar]
[LINK http://sourceforge.net/projects/yellowsoftware]
(L) [2002/03/18] [matthew] [mstephens@labyrinth.net.au]
A few pics generated by the "Quantahawk" engine I've put together. It is meant to be a versatile tool to rapidly generate real time environments.
You can browse for models and scripts at run time. So far it can set up the following by script:
- Load X file mesh models
Initial alteration of world space scale and location.
Hierachical position and orientation of mesh objects.
Real time dynamic shadows.
Point sprite particle systems.
Vertex tweening mesh.
Alpha sorted axis and full billboarded Quads.
Pre and Post render states for individual geometry.
ray-mesh collision detection.
Script driven programmable dynamic orientation
Simple "Perlin Noise" terrain generation
Spherical environment mapping for quasi-reflective surfaces
Electricity effects.
Set center of gravity
Replace xfile textures with others
Fog
Gravity, collsion detection, Keyboard& mouse navigation modes can be toggled at run time. Lighting can be altered at run time. There is the beginnings of a user interface that uses quads in camera space with ray-mesh collision detection for buttons. Although there is not many sound effects at the moment you can apply FX like echo, distortion and reverb to wavs.
You can get an .exe and some media from my web site [LINK http://www.labyrinth.net.au/~mstephens www.labyrinth.net.au/~mstephens]
I would be happy to discuss any ideas with like minded individuals.
(L) [2002/03/20] [DanielTrstenjak] [dan.t@freenet.de]
this is the first version of DCollide, a framework for the collision
detection in VRML.
DCollide uses sphere-hierarchies for the collision detection. The spheres
you
can in the picture represent the object in the 5th level of the
hierarchy.
The whole collision detection algorithm is implemented in java. So the
framework theoretical could be used with any browser which supports
java and vrml.
Unfortunately there are some problems, so the usability is restricted
to the combination of Internet Explorer 5.x and the vrml-plugin
cortona.
For other combinations I can't guarantee that it will
work.
[LINK http://beam.to/dan.t beam.to/dan.t]
cu Daniel Trstenjak
(L) [2002/03/22] [KalevTait] [kalev@soma-studios.com]
I wrote this program quite recently. I was procrastinating while writing my resume (for GDC 2002), and was reading an [LINK http://www.genarts.com/karl/papers/siggraph91.html article by Karl Sims], when Ash leaned over my shoulder and told me that I should do somthing like that. I denied that I could do it, but after a bit of convincing on his part I decided to give it a try. Suprisingly enough, I succeded. Its not quite as cool as what Karl Sims did, but its getting there.
Editor's Note: You can download this IOTD's demo here: [LINK ftp://ftp.flipcode.com/demos/iotd-03-22-2002_colorspace.zip iotd-03-22-2002_colorspace.zip] (136k)
When you start it up you will see six images (each of which is proceduraly generated). Click on one and that is used as the 'parent' for the new generation and will appear in the top left corner. Each of its 'children' (the other images now displayed) will be some random mutation off of the 'parent'.
The picture included is what I got after about 50 generations of selecting for complexity and asthetics.
I'm not including source code because I wrote this thing overnight, and the code is fugly. But I'll try to quickly explain the process that I'm using here.
Each picture is procedurally generated. For any x and y passed in it returns back a color. The color is generated from 3 floats (rounded off and confined to between 0 and 255), each of which is generated seperatly (this is why the colors tend to be fairly primary in nature, I'm going to change this in the next version I do). The generation process is done by a serries of nodes. Each node has pointers to a fixed number of other nodes (depending on the type of node it is). It gets floats from these 'child' nodes and generates a new float based on that to its parent node. I've been carefull with my deleting and copying of nodes, such that there are no memory leaks or multiple pointers to the same node. The most important node types are the end nodes (ones that have no 'child' nodes, including ones that return the x or y coordinate passed into them) and root nodes which are at the top of the set of nodes, and just return the number their child gives them (they're important because they never mutate).
The mutation happens as follows. First, there is a chance that a root node (and thus all of its children) will be cloned and stuck in one of the other color chanels. Then the mutator works its way down one of the node paths, stoping at random location, and replacing the node it finds with a new node. The new child nodes may be clones of the previous nodes children, or may just be new end nodes. Repeat this process several times.
If you have any questions or comments feel free to e-mail me at [LINK mailto:kalev@soma-studios.com kalev@soma-studios.com]. Also, please vist my demopage at [LINK http://soma-studios.com/kalev_demos.html soma-studios.com/kalev_demos.html]
(L) [2002/03/23] [JordanIsaak] [jordanisaak@hotmail.com]
These two pictures are from a cloth simulation that I wrote a couple weeks ago. Gravity, air resistance, wind, and cloth-sphere collisions are simulated.
The cloth is represented as a grid of particles, which is updated via Verlet integration. After the grid of particles is updated, the simulation tries to satisfy a set of constraints between particles, which is what keeps the whole system from falling apart. This method is described by Thomas Jakobsen in his GDC 2001 paper, "Advanced Character Physics."
Wind is simulated by finding the dot product between each particle's normal and using that value to scale the amount of force that the wind applies to that particle. The wind force is applied along the particle's normal. Air resistance is calculated in a similar way.
Cloth-sphere collision is handled by checking to see if a point falls within the sphere, and projecting it out to the sphere's surface if it does.
A demo can be found at [LINK http://members.shaw.ca/jdisaak/graphics.htm]
In the demo, the cloth has a resolution of 16x16 points, and the simulation is updated every hundredth of a second. It should run fine on a PII 300 or anything better.
Jordan Isaak
(L) [2002/03/24] [JensTinz] [jens@gamemakers.de]
Here are some graphics of a game I've been working on for a while.
StarCab
deluxe is the first title I've developed for the DirectX platform.
Features
include:
- 12 levels with unique graphics (14 total)
music composed individually for each level
a storyline carried by cartoon characters
graphics up to 1024x768x32
multipane scrolling
There isn't anything spectacular on the tech side, because I mostly
concentrated
on the artwork (yes, it's coders art). After having a brief look at
libSDL
and DirectX7, I decided to implement the game in DX8/Direct3D.
I'm fully content with this choice. Using the 3D API, I didn't have to
mess with update regions, and I can easily use things like alphablending,
rotations and scaling. Since I wanted the game to perform ok on older
hardware
(like my own K6/2-333, RageXL 8MB), I had to keep an eye on texture size
and fillrate. Apart from that, working with the 3D API was a breeze.
I'm currently putting the finishing touches on the game, and am still
looking for testers. Here's a 4 level [LINK http://www.gamemakers.de/download/scdemo/ demo] you can
download.
If you're interested in testing the full version, please drop me a
note.
A thank you goes out to all those who helped me in the forum, and to
Rick Lynch for providing the music.
PS: I plan to sell the game online. Might it be worth to look for a
distributor?
(L) [2002/03/25] [zed] [sexybastard@xtra.co.nz]
inspired by various screens here on the IOTD i decided to take the plunge + write a shootemup game something ive being wanting to do
for years, anyways here are 3 screens from it btw its called 'kill em all' featuring lotsa weapons + explosions, it is actually more
complete than the screenshots suggest eg AI/collision detection/model/phyics/particle system + a lot of the other stuff are 100%
completed.
it utilises a subset of the bollux engine ie little bollux (TM) hence the quick development time.
whens a demo coming out i hear u ask, no idea (working 45-50hour weeks in the winery dont help matters :) ill try to get a week off
just before havest (in about 4 weeks) when i should hopefully knock it off.
also included are a few shots of stuff ive also been working on (pretty dated).
- quite complex physics - (at least 1000 workhours dating back to about 1998 have gone into this).
displacement mapping - (sussing out mipmaps is a pain but apart from that a nobrainer, the technique though is a bit overrated ie
nowhere near as large of jump as going from detail->bumpmaping).
realtime radiosity - (10fps on celeron433 with gf2mx) its sweetas dragging a box around + watching the shading change.
underwater - how did that get in its like um so nineties.
btw for those curious as to whats become of gotterdammerung, im taking a short break, ive just gotten my first hardware t+l card :)
+ are exploring the possiblities.
[LINK http://uk.geocities.com/sloppyturds/gotterdammerung.html]
(L) [2002/03/27] [Nich] [leerj@tcd.ie]
Nothing original but it's probably more interesting than my landscape
engine...
All I did was take the code Jos Stam kindly released:
[LINK http://www.acm.org/jgt/papers/Stam01/solver.html]
...implemented his advecting textures idea:
[LINK http://www.dgp.toronto.edu/people/stam/reality/Research/pdf/ns.pdf]
...and added vorticity confinement:
[LINK http://graphics.stanford.edu/papers/smoke/smoke.pdf]
...to get this:
[LINK http://matrix.netsoc.tcd.ie/~the_one/iotd.exe]
It's tweaked for my PIII-700 where I get 50 FPS. It could probably be made
many times faster however by optimizing specifically for power-of-2 grid sizes
(especially the FFT computation). Right mouse click pops up a menu.
The particular screen-shot above shows a swirling texture with vorticity
visualization enabled, where vorticity is simply the curl of the velocity
field. Clockwise circulation is represented by red and counterclockwise by
blue. This was made on a 100x100 grid with a 512x512 texture, although the
demo uses a hard-coded 64x64 grid with very low resolution textures. A couple
of even higher quality screen-shots can be found here:
[LINK http://matrix.netsoc.tcd.ie/~the_one/wallpaper_scifi.jpg]
and here:
[LINK http://matrix.netsoc.tcd.ie/~the_one/wallpaper_paint.jpg]
If anyone has any questions to post, I'll be happy to answer them...
(L) [2002/03/28] [WaelZeenni] [thegecko@biosphereent.com]
This IOTD shows my terrain/level editor which took me about 5 days to make.It still needs some more work but all the basic functions are there.I hope to release it out to the public pretty soon along with the source code but it won't be easy to read since its programmed in MFC + OpenGL :p
Basically, the main purpose of this application is to allow people to import RAW or BMP greyscale heightmaps and see what their terrain will look like when you modify parameters like scaling,fog,lighting,texturing etc. It sure as hell beats recompiling your code again and again everytime you try to change any settings :) The non public version will allow me to also import my own 3D meshes into the editor and start placing them all over the landscape.
I still have the terrain lighting to work on as well as some polishing to do but do stop by my projects website every now and then.Screenshots,source code,tutorials and the full application should be up pretty soon for anyone who is interested. If you have any questions,then email me at thegecko@biosphereent.com
Cheers :)
(L) [2002/03/30] [CharlieVanNoland] [gixelz@hotmail.com]
These are some shots of two ROAM tech-demos I have been working on. I am
doing a full-blown investigation on drawing terrain as fast as possible with
a high enough level of detail to bring it up to par with current
terrain-based games out there.
The top two screenshots are of my more advanced ROAM implementation. It
features partial geomorphing where the addition of detail is a gradual
change in the shape of the terrain, as opposed to a sudden pop. The reason
it is 'partial' geomorphing is because it only morphs when detail is added,
not when detail is removed.
I have to keep track of which triangles were force-split by their neighbors
so I can unmorph them before unsplitting the culprit triangle.
That implementation also textures the mesh with a 512x512 'colormap' and a
512x512 detail texture. The colormap is basically a huge texture being
stretched over the entire mesh. This yields blurry coloring onto the
terrain. You can distinguish rock, dirt, grass, etc from eachother but it is
extremely blurry. So I tile the detail texture over the entire terrain. I am
not using multitexturing at the moment, so I am doing two passes. If I were
using multitexturing the polycount would be cut in half and FPS would go up.
The bottom two screenshots are my second implementation of ROAM. Actually, I
just took the first one, before I added geomorphing to it, and changed how
the texturing worked..
Instead of stretching a texture over the entire terrain, I created rock,
grass, and dirt textures. Using a bitmap consisting of red, white and green
I drew out where rock grass and dirt are on the terrain.
This yields a higher texture detail, but less variety in the terrain. I am
again not using multitexturing so the polycount could easily be a third of
what it is on these screenshots.
I am thinking about sticking with the color map and detail texture because
almost all cards support up to two textures per pass with multitexturing.
My other option is to make a huge texture (2048x2048) and chop it into
512x512 textures that are put together like a puzzle onto the mesh.
As you can see, I stuck a lens flare in my second tech demo. This isn't a
finalized flare or anything. I just was toying with gluProject. I tried to
do a sort of complex-corona on the sun. The corona is blended with a texture
of a white spot and the center is at 0 alpha. The corona is a triangle fan,
with ten 'slices'. Each slice is 36 degrees. Then I use glReadPixels to
check and see if the z-buffer has anything at the tip of each slice on the
edge of the actual sun. If there is something there, that slice is given an
alpha of 0, so that part of the corona is blocked...
This was used in the xbox hit HALO, I just copied it.
For some reason the lens flare is really slow. I think gluProject has some
performance issues, or maybe it's just my video card.
These demos actually have a purpose. I am investigating ROAM for a project I
am working on with some friends. It's an online FPS similar to Tribes,
except we are going to take out the 'cardboard' feel (as I like to call it)
and try to make it more realistic feeling. Tribes just had a weird
washed-out feeling to me. Maybe it was their fog or simple structural
architecture. Whatever it was, we are avoiding it.
Both demos light the terrain using 'slope-lighting', which I wrote an
article about and you can find it on [LINK http://gamedev.net gamedev.net].
I posted a full-size version of this IOTD at
[LINK http://members.gotnet.net/chaz/iotd_full.jpg]. I apologize for the bad
quality. I was trying to keep the 2048x1536 at a reasonable size..
If you have any questions/suggestions just drop me a mail,
[LINK mailto:gixelz@hotmail.com gixelz@hotmail.com]. Or leave some comments. Thx! :D
(L) [2002/04/01] [VanderNunes] [virtware@virtware.net]
These are some shots from my last little project, called WorldMap 3D.
This started just as a simple test of my game system, but I got excited
and decided to finish something more usable.
The main features are:
- Correct Earth orbit around the Sun;
Based on some orbit predictions, "correct" Moon orbit around the
Earth;
Real clouds (yes, REAL), updated automatically from satellites;
Shows any of 1300+ pre-included locations around the world;
Built-in locations manager that can add/modify/remove locations;
Shows the approximated time of any location;
6 pre-defined, configurable cameras plus 1 draggable user camera;
Sun causes overbrights, glowing and lens flares;
Many items are configurable both inside the application itself and an
external configurator;
Can run as a normal application (windowed or fullscreen) and/or as a
screensaver;
Runs theoretically under Win98/Me/2K/XP, DirectX 6.1, 3D card
required.
Direct download from [LINK http://www.virtware.net/downs/setup_worldmap.exe]
Please visit my site at [LINK http://www.virtware.net] and send me your
comments, suggestions and flames! =)
I want to thank DooMWiz here because this guy alpha-tested the WorldMap
after some insistence from my part in the IRC, heh. =) Hey, Doom, thank
you after all!
Peace,
Vander Nunes
(L) [2002/04/03] [TMDCorganization] [tmdc@tAAt.fi]
You're looking at couple of screenshots from the TMDC4 invitation intro.
TMDC is the pseudoannual international text mode demo competition which is
now arranged for the fourth time. More information of the contest can be
found
from the official TMDC web site: [LINK http://tAAt.fi/tmdc/]
Everybody interested in demos is invited to take part in the contest!
The intro is actually just a text mode version of tAAt-demogroup's
Assembly'01
intro called "Ekoteko 42KB". Some of the effects featured in the intro:
- sierpinski, burning ship and koch curve fractals
voxel cylinder
simple physics simulator with a wireframe cube and spheres
software synth to build samples for the 2.7MB .XM module music
Download URLs and other links:
- the invitation intro is: [LINK http://tAAt.fi/tmdc/tmdc4inv.zip]
the original version of the intro: [LINK http://tAAt.fi/taat/files/ekoteko.zip]
the TMDC4 web site: [LINK http://tAAt.fi/tmdc/]
Alternate Mirror:
- [LINK ftp://ftp.flipcode.com/demos/tmdc/ekoteko.zip]
[LINK ftp://ftp.flipcode.com/demos/tmdc/tmdc4inv.zip]
--
Jetro Lauha - part of TMDC4 organization
(L) [2002/04/05] [FrancisWoodhouse] [deathwish@valve-erc.com]
The two images show some screenshots from the early stages of my terrain engine (yes, another one!) that I've been working on since Christmas Eve of 2001. I've rewritten the LOD system 3 times, first using a 9x9 vertex tile system, then an adaptive quadtree algorithm, then back to the tile system but with each tile having 17x17 vertices. The tiles can be rendered at 8 different levels of detail, using the vertex error as the factor to decide which LOD to use for that particular tile. Frustum culling is done on each tile's bounding sphere, but a quadtree is yet to be implemeneted. It gets around 130 FPS at the moment, and goes down to 100 FPS with a particle system being used (not shown in these screenshots - that's what I'm working on at the moment).
There are lots of things that are still to do - finishing the particle engine, quadtrees, level editor, models, moving sky, lighting, and more. However, I am designing the engine with dynamically alterable terrain in mind, so you'll be able to have rockets dig holes in the ground.
Cheers, and I look forward to your feedback!
(L) [2002/04/06] [Brian Washburn] [n/a]
[LINK mailto:n/a Brian Washburn]
This IOTD demonstrates my 2d metaball engine I wrote in a couple days, rendered in OpenGL.
Rendering and calculating metaballs are very cpu extensive, 2d or 3d. My goal was to have many metaballs on the screen at once without slowdown, so I opted for 2d. To reduce the computing load and increase fps, the
window itself is rendered in 320x240, and then is broken into 160x120 chunks. Even then, rendering a mere 10 metaballs would mean 192000 illiterations! (120x160x10). With certain optimizations I managed to reduce that
number to around 15000.
Drawing the metaballs involves density/electrical fields. Density fields are usually used to display things such as air pressure or temperature but they can be used to display blobs also. Every point on my 160x120 graph is
tested to see how far away it is from all the metaball's centers. If that value passes a certain threshhold the pixel passes, and is rendered. Surprisingly, the color of each pixel is determined almost the same way.
Enjoy!
The 'A' key adds a metaball. The 'S' key subtracts a metaball. 'Enter' singles out a a certain threshhold value, and only draws it. (torus)
The demo is available for download here: [LINK ftp://ftp.flipcode.com/demos/iotd-04-06-2002_metaballs.zip iotd-04-06-2002_metaballs.zip] (41k)
Brian Washburn, 2002
(L) [2002/04/08] [OuthouseSoftware] [outhousesoftware@hotmail.com]
This screenshot is taken from Super Roco Bros 3D version 2.0. This game is
powered by Reality Factory and Genesis 3D game engine. This version includes
4 new levels, as well as new badguys and music.
You can download this version from our website :
[LINK http://www.outhousesoftware.co.uk/roco3d.htm]
(L) [2002/04/09] [LuisSempé] [visual@spheregames.com]
This is the first demo of the game engine I've been working on for the past four months, part time, mostly. At the moment, I am the only person working on it, doing both the artwork and the coding. The engine is intended to be used to develop an action/adventure game that I'm currently designing.This demo can be thought of as an early prototype of the game, based on the current design treatment.
The engine was programmed in C++ using MSVC 6. It uses Direct3D 8 at the moment, although, Im working as API-independent as possible so that in the near future I can throw in OpenGL support easily. Visibility culling is done using octrees, as well as some line of sight tests and collision detection. Scenes are exported from 3D Studio Max to the ZCB file format, which is then imported by the engine. The engine also supports lightmapping, but a bug somewhere in the code is making the lightmap calculation time quite large, so I decided not to use it in the demo until all bugs in it are worked out, even if it did improve the visual quality by a lot :(
Some of the features included in the demo are:
- Sky Dome
MD3 character support
3D Positional Sound (using DirectSound)
First / Third person camera
Animated Textures (caustics, as seen on the fountain's water)
Data driven particle system
I'm currently in the process of designing a better architecture for the engine that makes use of a scene hierarchy, most likely, a scene graph, but Im experimenting with different options to find the one that suits the game's needs best. The complete engine will feature lightmaps (without the time consuming bugs!), animated characters that use bones and skin, dynamic lighting effects, dynamic shadows, and I'm sure more features will find their way into the engine along the way.
Although, I am enjoying coding the graphics engine, I am looking forward to working on the game specific areas, but I am aiming to have a basic feature set before I work on the actual game. That is why the game is being designed concurrently with the engine's development, by the time the engine is ready I should also have a solid design to work with.
There are some known bugs, but I won't spoil it for you, if you want to find them, you'll have to download the demo at:
[LINK http://www.spheregames.com/sgedemo.htm]
I must apologize for the rather large download size (20megs), It is mostly due to the use of a rather large sound file. I am working on resolving this issue soon.
Finally, I just wanted to gratefully acknowledge the help of the folks at GameInstitute who have been an invaluable source of knowledge, help, ideas and at times even motivation. Thanks guys!
(L) [2002/04/10] [KatascopeVisuals] [katascope@yahoo.com]
This is from my latest visuals software - KataFX 3
The full picture can be seen here:
[LINK http://www.katascope.com/KataFX3_800x600.jpg]
The Winamp visualization plugin is here:
[LINK http://www.katascope.com/KataFX3/Install_KataFX3.exe]
KataFX 3 is a 3d editing and display environment for
projection visuals (for concerts/shows) using OpenGL.
It uses a scrim based gui for interaction.
Notable features:
- Skinned, resizable scrim gui and windowed/fullscreen
OpenGL rendering
Three levels of user expertise.
Visuals autopilot/ai.
Milkshape model support.
Can be run as Winamp visualization plugin.
Unique licensing.
GUI:
Visuals software for shows have one important
difference from traditional software/games - Multiple
viewers. For shows, this means no one but the user
should see the interface.
The only solutions(AFAIK) are:
- No visual interface at all - Just keyboard and
mouse, this just doesn't cut it for creating complex
scenes.
Dual monitors - Nice, but fewer people can use it,
and a lessened sense of immersion.
A Scrim interface - It can be clipped by the
projector and not displayed. This is what KataFX 3
does.
The scrim interface has one important rule: the interface should not,
for any reason, drop below its rectangle, or be visible to the audience. i.e. no
drop down menus, no popup dialogs.
The KataFX 3 scrim has four parts:
- Play - The mode it starts in, will work without any
human interaction. (easiest)
Groove - The mixer mode, allows tweaking of the
autopilot. (medium)
Edit - The editor, allows the user to create
background or foreground worlds. (hardest)
System - Configuration & file/skin loading & saving.
Graphics:
The interface & display are both rendered in OpenGL.
By sacrificing some rendering power to the interface,
I gained some nice freebies - The interface looks good
up close (and impresses the promoter, which is wise).
Another nice benefit is resolution independence. Since
it is rendered with OpenGL, it can run at virtually
any resolution and still look right. OpenGL handles
resampling, so the gui resizes without pixelation
-something traditional windows can't do!
AutoPilot/AI:
Shows/raves can easily last 10 hours, an autopilot
keeps the user from getting exhausted too easily.
KataFX 3 uses an implicit autopilot - Emotion based,
with a large database of scenes. The autopilot knows
the difference between background & foreground worlds.
The background scenes are autofaded in/out. The
foreground scenes connect end to end, creating a
continous journey. Either can be enabled/disabled in
the Groove scrim.
Legal Issues:
The license/eula states the software is free for
personal use, but cannot be publicly displayed(i.e.
used to make money). This is because I provide
projections for shows, and it would be unfair for the
competition to use my work. It's the best balance I
could find between providing something to everyone
without shooting myself.
Software used:
- Visual C++ 6.0 - For development
CVS/WinCVS - For source control/bug finding.
Doxygen - To keep the source from collapsing under
it's own complexity.
NSIS - Used to create install executable.
Paint Shop Pro - Image editing.
StyleSkin - A universal skinning tool, used to create
the skin.
ImageMap - Used to map regions in the skin to
functions used in the program.
I hope this provides some useful info to someone.
Scrim interfaces solve a niche problem, but it's the
best solution I've found so far. Sorry, no source
available, but the plugin is very customizable.
Thank you
Katascope Visuals - [LINK http://www.katascope.com www.katascope.com]
(L) [2002/04/12] [JohnvanderBurg] [john@mysticgd.com]
Mystique is a powerful rendering system, which has been designed with modularity and network support in mind.
Mystique allows you to easily develop your own custom plugins, render using many computers over the internet and ships with a hybrid Monte Carlo global illumination render plugin. Developers can write render plugins, ray acceleration plugins, and more, all of which will cooperate seamlessly. For example if you write a ray acceleration plugin which is 50% faster than other existing plugins, all other render plugins in Mysique will automatically be around 50% faster. You won't need to worry about ray intersection tests and acceleration schemes, since this is all done by the other plugins. Network rendering is supported, via LAN and the Internet as well. Your computer could go into render slave mode, which would allow people on your network or on the Internet to use your computer power to render. This would allow you (for example) to render one image using 1000 computers connected via the Internet.
Mystique and its SDK will be free. It will be released with plugins for hybrid Monte Carlo global illumination, 3DSMax and Maya exporters, Octree and Uniform-Grid ray acceleration and a GUI for Windows.
You can find some current in-development renders at [LINK http://www.mysticgd.com] in the Mystique section. Mystic Game Development is also searching for artists who can provide some cool models to use to test the system. If you are interested in seeing your work rendered using the new system please contact us via our website.
(L) [2002/04/14] [ArnaudCarré] [arnaud.carre@freesurf.fr]
As all programer, I like to write unusefull things... Some time ago I decide to write a DirectX8 library called "TinyD3D8". Tiny because the challenge was to produce EXE as small as possible.
I hear some of you saying : "Today computers have so many disk space, so many memory that's stupid to spent effort writing little programs !". And I totally agree : that's stupid for a commercial product. But, many of us in the industry are about to forget an important programming rule: the fun ! Yes, that's just fun to try to push the software limit ! On the other hand, you have to learn many techniques to build little DX programs: we learn about the compiler, the linker, the FPU and so on.
To test my library I write some various funny programs. All these programs runs under windows platform, directX8 (or better :-)). Here is a brief description of the "image of the day" picture, left to right, up to down...
Knot: EXE size: 5.5Kb
Knot is a nice program computing and displaying random knot. Every 3 seconds appair a new generated knot with random geometry and random colors.
Physics: EXE size: 6Kb
A true real-time rigid body physic program. You can rotate the cube or invert the gravity field in order to see the pink tetrahedron moving and bouncing around :-) I write it after reading a really nice article by "Thomas Jakobsen". Use Verlet integration for stability.
Mandelbrot: EXE size: 5.5Kb
Real time "deep" mandelbrot zoomer. Zoom with a factor of 2^55, ( ~1e16, so that's the range between you and the universe !). Use recursive optimized mandelbrot computing routine (Avoid to compute large flat area). Do you ever imagine a simple formula "z' = z^2 + c" can generate such colored lands ? :-)
OldSkool: EXE size: 24Kb
Whaoo 24Kb ?? that's too big !! :-) This is the first eavy use of my TinyLib. There is some graphical resource packed in the EXE (textures and music). This is an "oldskool" animation as you can see on AMIGA or ATARI 12 years ago :-) Please note the music use a YM2149 sound chip emulator. Pump up the volume all of you nostalgic freaks ! :-)
You can download all that unusefull stuff here:
[LINK http://leonard.oxg.free.fr/demos/demos.html]
Please don't ask me for the TinyLib source code for the moment, maybe I'll post it a day. (have to make it clean :-)).
Have a nice day !
Arnaud Carré
(L) [2002/04/16] [SiBrown] [si_br0wn@hotmail.com]
These screenshots are taken from a small project I undertook
about a month ago to integrate ODE, DirectX and stencil shadowing
into a single demo.
ODE is the Open Dynamics Engine - an open source rigid-body
physics simulator, written by Russ Smith. This demo uses version
0.03. The stencil shadowing is performed using the standard
"Carmack's reverse" method on convex bodies. The basic algorithm
for each light is:
- Project the body onto the plane normal to the light direction
Compute the convex hull on the plane
Extrude this hull into a shadow volume, being careful to cap
before the far clip plane
Using the shadow volumes, additively render the scene into the
frame buffer
This works fine for the directional lights used in the demo, and
could easily be extended to more useful point and spotlights.
The end result is what I hope is a fun demo. The player controls
a buggy in a simple world containing plenty of dynamic objects to
smash into and ramps to drive off. Many thanks to the population of
#flipcode on ETG for their invaluable comments, suggestions and
artwork. :) The demo uses vertex shaders for geometry processing,
so unless you own a card with hardware shaders (e.g. GeForce3) you
will need at least a 800MHz CPU to get a decent framerate. The
demo requires Windows 2000/XP with DirectX 8.1 installed.
The demo binaries (which
include the textures) and the full project source code are avaiable here:
- [LINK ftp://ftp.flipcode.com/demos/iotd-04-16-2002-buggydemo-binary.zip iotd-04-16-2002-buggydemo-binary.zip] (389k)
[LINK ftp://ftp.flipcode.com/demos/iotd-04-16-2002-buggydemo-source.zip iotd-04-16-2002-buggydemo-source.zip] (50k)
The source
is all C++ (with a bit of vertex shader assembler) in a Visual
Studio .NET project.
Si Brown
(L) [2002/04/17] [CharlesBloom] [cbloom@oddworld.com]
These images show a little particles system running on an XBox.
The particles are time-evolved by the GPU in a vertex shader; that
is, the CPU creates particles and then never touches them again.
The particles live in memory only once (in the vertex buffer), there
is no system memory copy. Particles can be added to this circular
buffer by the CPU without stalling the GPU on the XBox.
I get about 30 million particles per second when their size is set
to zero, but in practice particle systems are fill-rate limited.
As usual, it looks much better in motion, but I'm afraid you need
an XBox dev kit to run the demo ;^)
(L) [2002/04/18] [MaximStepin] [maxim@hiend3d.com]
One day I realized that implementing texture magnification by using
simple bilinear filter is just not good enough. Very often, a texture
contains several color-uniform areas with apparent borders between them
and these borders get blurred as the rest of the texture. Just start
any modern FPS game, move a character very close to a wall with some
sign on it, and if the texture resolution is not high enough, you_ll
experience a "bad eyes" effect - everything looks too blurry, you don't
see any sharp borders anymore.
In order to solve this problem, I developed my own "smart" texture
filter. It keeps borders between color-uniform areas look sharp
regardless of texture magnification level and, at the same time, keeps
interiors of those areas as smooth as bilinear filter does.
The idea is to use independent interpolation function for each group of
four adjacent texels. I developed a set of such functions - most of
them describe how border(s) intersect the interval between these
texels_ centers. To determine, which function to use for each group of
four texels, some additional information needs to be stored along with
a texture. In my demo, I used 8 additional bits per texel for that
purpose. Because these interpolation functions describe pretty much a
sub-texel level of the texture, on preprocessing (analyzing) stage I
had to use a much bigger version of the same texture. For example, for
this demo I analyzed 2048x1024 image to get the final 512x128 texture
with correct interpolation function information.
You can find the demo and full source code at
[LINK http://www.HiEnd3D.com/demos.html www.HiEnd3D.com/demos.html]. I used software rendering for obvious
reasons, so please don_t expect very high speed. Artwork is inspired by
M.C. Esher drawings.
Fell free to ask any questions. Comments and suggestions are very
welcomed.
Maxim Stepin.
(L) [2002/04/19] [MikeHommel] [jamul@hamumu.com]
The web site [LINK http://www.ludumdare.com Ludum Dare] - a website for indie
game developers to meet and discuss junk - held its first contest this
weekend. It was the 24 Hour Game Programming Competition. The theme was
Indirect Interaction, which worked out beautifully, because every entry was
totally different, instead of seeing the same thing executed 20 different
ways. You actually were required to do *everything* in the 24 hours - art,
sound, code, everything. And there were rules on what libraries you could
use, to limit you to starting with just the absolute basics (no rotating
alpha-blended sprite functions or anything - just straight blitting). That
was intended to get you working only on the core issue: gameplay. This shot
is of my entry, Castle Smash. You can download it and all the other entries
at the Ludum Dare site.
My entry is kinda like an RTS. You start with 5 peasants, who do
nothing but wander, and you build Schools, Barracks, and Guilds, to train
your peasants to become Workers (which harvest wheat to make more peasants,
and gold to buy more buildings/walls/bridges), Warriors (which attack the
enemy castle and people), and Wizards (which defend your castle). I'm
actually really proud of how it turned out. I forgot it was possible to
make games so quickly, and this contest has really helped me get back into
the "true spirit of game development"... it's like a Game Dev Carol!
There's not a lot of special features to discuss - this was made in 17
hours, you know... but in the shot, you can see workers harvesting stuff,
and my mighty yellow warriors well on their way to absolutely wiping out the
red castle (it's a 2 player game, I was playing yellow). There are also
some wizards milling about in my castle area. Your own troops can walk
through your walls - consider it symbolic of there being gates in them,
okay? You can also see a little red dot where a yellow warrior and a red
warrior are duking it out across the water (there's also one right on the
red warrior's face!) - warriors fight by shooting little dots at each other.
I didn't want to write any aiming code, so they actually shoot in random
directions, but it's okay - it adds to the tension of combat! Because the
theme of the contest is Indirect Interaction, you can't make your people do
anything. Each type of person just automatically acts in a certain way.
All you can do is build buildings (and blow up buildings you don't want
anymore). The number of the different types of buildings you make influence
how many peasants choose which jobs (if you have more Barracks, you'll get
more of them to become Warriors, and stuff like that).
There are about 20 other entries at the website to check out, so you
should go see what your fellow developers can do in 24 hours! And they all
include source code, so you can rip off our hard work. Please don't do
that. Here's a link to the list of entries:
[LINK http://ludumdare.com/competition/index.php?viewcomp=1]
Mike Hommel
Hamumu Software
[LINK http://www.hamumu.com]
(L) [2002/04/22] [VanderNunes] [vander.nunes@ig.com.br]
This is a screenshot of the Flares Generator I wrote for the WorldMap 3D
project. Nothing really special, just an utility to make flares creation
easier.
The generator is scripted, and the final image is a result of glows and rays
layers blending. Each layer has its own parameters, like color ranges and
alpha transparency. It is possible to add any number of layers to compose
the final flare. Preview and Production resolutions are configurable, so it
can render the preview flares in realtime while they are being created, and
then render in high resolution for the final image.
Although the screenshot shows only a few variations, in my testings I was
able to create very different compositions, so I think it is actually a
valuable tool, at least for me. =) It is quite easy to expand with new layer
types, although for WorldMap just glows and rays were sufficient.
I need to finish some details here and there, before releasing it for
downloading. As it is every time a great experience to post an IOTD at
Flipcode, here it is.
Peace,
Vander Nunes
(L) [2002/04/23] [puzzy] [puzzy@hardcore3d.net]
Here are some pics about H3D game system.Graphic system is mixed by a Bsp/Pvs/Portal in-door engine and a LOD-Quadtree.Well...It uses polygon soup from 3dsmax to construct solid space, but not from the solid brush editor like Quake and Unreal. The artist can add visibility portal by hand in 3dsmax if he can't understand how to build a good PVS environment. There is a massive multi-player net server behind it.
H3D is written by C++/C . Opengl based.
The Graphic System of Hardcore3D include:
H3D CULL (Hardcore3D Advanced Visibility Technology)
Elements :
- dP(Dynamic Portal )
uB(Unlimited Bsp )
eP(Extact PVS )
hQ(Huge Quadtree)
iT(Indoor/Terrain Visibility tech)
eC(Efficiently Culling )
-aW(Arbitrary World Construction )
H3D HPR (Hardcore3D High Performance Rendering Technology)
Elements :
- hR(High Performance Rendering Core)
hM(Highly Flexible Material Control)
hS(Highly Configurable Shader System)
H3D MAX WSWG (Hardcore3D MAX What You See What You Got)
The H3D WSWG provides with a real-time rendered version of 3DSMAX scenes, models, textures and lights. The what-you-see-is-what-you-get elements includes models, shaders, diffuse map, opacity map, reflect map and bump map.
H3D FIGHTING (Hardcore3D Advanced Skeleton Animation & Fighting System)
The H3D fighting system implements all kinds of real-time fighting. With the implementation of skeletonal animation and hierarchical bounding volume collection detection, a precise judgment of injury can be made.
[LINK http://www.hardcore3d.net]
(L) [2002/04/25] [ChrisMiller] [chris@cosmicbee.com]
This is a screen grab of my latest coding demo, WebGL. Not your typical
OpenGL demo, it combines OpenGL with Dynamic HTML, ASP, and CGI to show
interactive 3d modeling in a browser window. You draw in the edit window,
then click "Render Changes" to update the 3d display. The scene is
rendered by OpenGL into an offscreen buffer. Then it is sent to stdout for
display by the browser. I'm not sure if it works on every version of every
browser, but i've tested it with IE 5.5 and Navigator 4.04.
Have a look at: [LINK http://www.cosmicbee.com/webgl.asp]
I would love to see some critique, and hopefully squash a few bugs. Please
excuse the rest of the site, as it is in development.
Here are some details...
- Hand coded Dynamic HTML user interface. I used Dreamweaver to create
page templates from my menu system.
C++ CGI application to render the scene with OpenGL. I'm using
glReadPixels to grab the color buffer. This was interesting to write,
because there is no user interface. The program simply outputs a JPG
stream to stdout.
Uses the Intel JPG library to create the in-memory JPG stream.
Bilinear filtereing of the 3d image.
Parameter passing with POST to retain page state. The grid is
encoded as hexdecimal strings which are passed to the CGI program via GET.
Possible enhancements...
- Stack 15 of these 15 x 15 grids together to create a "cube" which is
editable slice by slice.
Camera positioning
Custom positionable lights
Load and save of the grid using the browser.
Enlarged image rendering
And some bugs...
- Floating palette doesn't drag on Netscape (working on it).
Chris Miller
(L) [2002/04/26] [JariKomppa] [jari.komppa@kolumbus.fi]
What you're seeing in the picture is the UI of my little project called
HORS. HORS is a musicdisk interface.
The HORS project started in 1994. !Cube, a friend of mine, was in
something like four groups at the time, and wanted a short group name to
release his MOD music under, and decided to form DEE. Nitro joined DEE as
well as the second musician and they recruited me, Sol, to write a musicdisk
interface.
Musicdisks at the time were mostly one to two disks (1.4 megs per disk) of
size, and a 'proper' music disk was considered to be one with a graphical
interface. Most musicdisk interfaces out there were obviously weekend hacks,
just showing a picture and changing tune when a key was pressed. We felt
that this was no fun, and planned something slightly bigger. HORS 1.0 was
coded in 1994 by me, and it was the largest, and last, pascal project I
wrote. Running in 640x480 (most if not all of the mainstream graphics
applications were 320x200 at the time), it included lots of assembler hacks
to get around turbo pascals' limitations.
After the success of DEE ONE we sat down and planned a monster. (Ever read
the jargon file? Look up 'second-system effect'). The moster was to be
called HORS 2.0, and it was to include interesting things like the mouse
followers (nice idea that was stolen from the original 'discworld' game),
scroller at the bottom, scrollable information panel (versus the
fadeout/fadein in original HORS), among other things. Six months to the
project I realized that I spent more time fighting with turbo pascal's and
real mode's limitations than with the actual building.
So I checked watcom C out, and never looked back. My transition to C
happened completely in one weekend; originally I thought I'd still go and
write some smaller tools with pascal, but I couldn't see any reason after
working with C for a while.
So HORS 2.0 ended up being my first C project. At about 12000 lines and 12
months of work (while finishing up with highschool and other stuff) it is
the largest personal 'solo' project I've done.
So finally at the end of '96 HORS 2.0 was about to be finished and we
started building DEE TWO, and it was released in january 1997, and it was
very well received by the audience. As an example, DemoNews, newsletter by
the then-active hornet archive, said the following:
"_____The Good...
Dee Musicdisk Two by Dee. Excellent. Download now!
[cut]
'****+' Slam! This is how a music disk should be done. Absolutely
the best interface I've seen for a music disk since Epidemic. Not
only that, but the interface is configurable... you can actually
use it for your own productions. The music kicks ass. If you
only download a couple music disks this year, be sure that one of
them is Dee Musicdisk Two!"
-- DemoNews # 141 - 02 February 1997
We got tons of fan mail about it; best bits can be found in praise_dee.txt
included in the distribution.
While waiting for my military service to begin (which is mandatory in
finland) I made 'koivis', a hypercardish presentation of my highschool,
partially to show that it's possible using HORS with no code changes
whatsoever. While I was in the army we released DEE 2:42, DEE 3 and DEE PI,
along with a Trauma demo at assembly, and couple of invitation intros to
different parties. All in all, I personally released more scene stuff during
my military year than most scene people do in all their lives. =) Later on
we released all dubius sound tracks as one HORS disk.
After that years passed. I've had this idea of porting HORS to windows for
some time now - it wouldn't run under emulation due to the VESA mode used
and also because the music player by Tremor isn't exactly
emulation-friendly. However, after getting some fan mail after a long time,
and also being on vacation, I started going through the HORS sources and
figured they wouldn't be too hard to port.
After 6 hours of hacking I had sound, graphics, controls and mouse
running. Some 10-12 hours of finishing touches later here it is.
When you listen to the DEE disks and read all the stuff contained within,
do remember that most of the information is very old. There are some things
I would have wanted to change, as did Nitro and others, but I thought that
it might be better to just let it be this way. Running the DEE disks on
current hardware is a nostalgia trip for us; let it be like that for the
rest of you as well.
The music player used is FMOD, which I only had to misuse very slightly in
order to get it to work the way I wanted it (I checked with Firelight to
make sure my hack was ok). For graphics I used SDL, which in my opinion is
the sanest way to do 2d graphics on current hardware. Due to some hacks I
had to do HORS now requires a bit more CPU power than it used to (it used to
run just fine on pentium 100MHz; now I'd recommend 300+MHz).
As for the final 'key feature' list:
- 640x480x256 graphics mode with minimal display memory changes and no
blinking mousecursors (everything else ran in 320x200 back then)
Mouse cursor with clock and mouse followers
Greeting scroller on bottom
Tune selector
Tune info box (with real bpm counter)
Fancy channel-based volumebars (with panning and note display)
Information viewer (with hyperlinks, images, background image, different
fonts, links in images, text wrapping around the images or centered images,
font rendering styles and colors, all through HTMLish renderer)
Compressed file library system
Note dots (showing pan, volume, note instead of channel-based view)
Mandelbrot explorer
Julia explorer
3d IFS fractal renderer
Nibbles (worms) game with 25 levels
Own, specific, paleted image format
Runtime palette reorganization and quantization
Musicdisk change on the fly
Plus probably others that I just can't remember right now.
Yes, I used to have far too much free time on my hands =)
Special thanks go to Joachim Fenkes for the superlative beta testing he
did.
HORS can be downloaded from my site at [LINK http://iki.fi/sol iki.fi/sol] as either separate engine package
(if you have the old musicdisks) or as a whopping 22 megabyte package that
contains all the data ever released with this interface.
ps. Remember the [LINK http://taat.fi/taatry/tmdc/index.html text mode
demo competition!]
(L) [2002/04/29] [Noisecrime] [noise@noisecrime.com]
I thought I'd share a tech demo I've been working on for a couple of days to dynamically create a 2D aura or Halo around an arbitrary model in real-time. So as the model rotates or if the camera viewpoint changes, the profile of the model is updated and the aura maintains the correct outline. It's a simple effect, and although I'm sure I can't be the first to come up with it, I haven't actually seen it used in other demos or games.
The demo was created with Director, and can be viewed online via Shockwave here
[LINK http://www.noisecrime.com/develop/techdemo/d85/aura/ncp_aura.htm]
It needs SW8.5, a plugin freely available for browsers, and there are plenty [LINK http://www.noisecrime.com/develop/index.html more demos] to justify downloading it ;)
I came up with the idea whilst reading through NeHe's tutorial 28 on shadow mapping for obtaining the visible edges of a model. This is a quick overview of the method.
Pre-processing: Loop through every triangle/face in the model to have the Aura applied to and build an array of its neighbours.
For each frame use the array to check each face against its neighbours. A face is checked if it faces the camera, and an edge is stored for each neighbour that is not visible to the camera. An edge is defined by two vertices taken from the original face.
The completed edge list defines the 2D profile of the model (from camera POV) and is considered the inner outline.
A copy of the edge list vertices is made and then scaled via the Aura_strength value (around 1.2 is good). This second edgelist is the outer outline.
Simply connect the dots, or in this case the edge vertices from inner to outer, first forming quads and then splitting them into triangles.
Finally build the new Aura mesh and apply an alpha channel texture to achieve the glow.
Draw the Aura without writing to the zbuffer, so the model can be drawn afterwards and always over the top of it. This allows for more complex geometry and non-convex models, without the aura cutting into it.
The method is not perfect; there are a couple of issues with graphical glitches. The first is unavoidable, although it could be minimised and that is Aura popping, which happens when an edge suddenly appears or disappears from the profile as the model rotates. Secondly if two alpha textured polygons of the aura overlap they cause a heightened intensity of glow within that area. Perhaps this issue could be solved through use of a stencil buffer? (Not that we have access to one from within Director). Ultimately the method works best for low values of aura_strength, at higher values overlap becomes much more visible.
Talking about stencil buffers, I have wondered if there was an easier way to produce a similar effect. I have seen Halo's done with a stencil buffer, but the halo is just a flat colour, with no graduation, failing to give the nice glow of my method. I guess with 8 bit stencils it should be possible in multiple passes to produce a graduated effect, but presumably this would be to costly in terms of performance to implement currently.
(L) [2002/04/30] [Thomas] [grt10019@mail.tallence.de]
These screenshots are taken from our project called 'Alnair'. It is a 100%
pure Java 3D-engine and it is not using Sun's Java3D API. We planned to use
it as the graphical heart of a MMORPG game which we are no longer
developing, unfortunately. The basic version of the game was planned to be
playable via a standard browser without any further plugins. Therefore the
design goals were to get as many polygons out of Java as possible and to
reduce the download size of 3D data to a minimum.
The upper two pictures just show some basic features of our engine such as:
- z-buffer rendering
texture mapping
gouraud shading
specular mapping
alpha channel
faked texel filtering (ala Unreal)
FSAA
Some technical details about the images:
Upper image
- 1934 polygons
three textures each 256x256x24
mesh size: 13939 bytes
texture size: 21120 bytes
rendering speed about 35fps at 512x384 pixels on my Athlon 900
Lower image
- 25676 polygons
mesh size: 135627 bytes
rendering speed about 15fps at 512x384 pixels on my Athlon 900
The textures are standard Jpeg encoded. The models were compressed without
any loss of precision using our own mesh packer. Basically they are stored
as triangle strips. Currently the size of the Java-applet is 13359 bytes.
As this is a commercial project I can not release the source code. But you
can take a look at a working demo at [LINK http://www.alnair.de]
Cheers,
Thomas
(L) [2002/05/02] [DarrylLong] [pythianproject@shaw.ca]
These are screenshots from the Pythian Project's first technical demo (Don't
take the frame rates too seriously; my video card is 4 years old). We
finished the demo a few months ago after 3 years of development.
The Pythian Project is a team of Delphi coders working together to create a
CRPG. At the start, no one had any real graphics experience and we didn't
have a clue how to write a game. When we decided to write a 3D engine, most
people figured it was impossible with Delphi and they quit. It's a language
most people associate with databases, not with real-time 3D games. We've
worked hard to prove them wrong. Although nothing in this demo hasn't been
done before, most of it has never been done with Delphi, so we try to help
the Delphi community by keeping our code Open Source.
This demo shows the third iteration of our engine. The first pass was
something like Wolfenstein, and the second pass slightly resembled Doom.
This third attempt is more ambitious as we learned a lot from the first two.
It's a Portal Engine, although pretty slow because it doesn't use triangle
strips or any algorithmic optimizations for the world geometry.
For the first two years of the project we didn't have any artists, and no
one knew how to use (or afford) 3D Studio, so we wrote our own Level Editor.
It's nowhere close to being a real modelling app, but it was good enough. I
modelled all the world geometry for the demo, and I don't know the first
thing about modelling. We "borrowed" all our character models from Quake II
fan sites. Our skydome texture is generated from a filtered Perlin noise
function so we can have different degrees of cloudiness and dynamically
light the clouds based on the sun position. Sounds great to a coder, but the
artists keep telling me it looks bad. They just don't understand! ;)
It took us such a long time to finish the demo because for the last year or
so we were concentrating on adding gameplay elements, including the ability
to talk to people and move things around with real physical simulation. We
added a bunch of simple AI and integrated Python as a run-time scripting
language for triggering events and driving the AI. We spent a lot of time
working on our VGL, an OpenGL user-interface with all the bells and whistles
you'd expect from a windowing system, including running like molasses.
I could go on for a really long time about all the little things that added
up to making this tech demo actually playable instead of just some art and
an engine, but I'll resist. I should mention the modules that didn't make
it into the demo. The ROAM terrain engine seemed like a good idea 2 years
ago but these days I think the CPU time is more valuable than the GPU time,
so I removed it. The multi-player network implemention was ripped out and
is being rewritten for the next demo. (Yeah, it's fun to play Quake 3
against your friends but nothing beats fragging them in YOUR game :) We
learned really quickly that TCP/IP is way too slow for gaming over the
internet, so we're changing it to use UDP for most data and TCP/IP for
essential data.
You can download the demo from our web site at [LINK http://www.pythianproject.org]
Here's the list of buzzwords:
- a.. Portal Engine
b.. Keyframed models from Quake II
c.. Uses OpenGL (windowed or full screen)
d.. Custom-built, re-usable GUI
e.. Python for run-time scripting
f.. Conversation Engine
g.. Real-time physics simulation
h.. Multi-layer Skydome (for many cloud layers)
i.. Pre-calculated lightmaps using multi-texturing and JPEG compression
j.. Easy-to-extend scriptable AI system
k.. Particle Systems (can even use physics on the particles)
l.. Camera Animations
m.. Level Editor modelling tool
Now that the first demo is complete, we've started on the next phase of our
project. This includes using optimizations such as space partitioning,
triangle strips and shaders. I've already got the triangle strip generation
and rendering code working, and I was rewarded with a 10-15 FPS boost. We
have a few really talented artists now, so all our geometry is imported from
3D Studio or Maya and we will only use the Level Editor for placing objects
and writing scripts. The Phase 2 demo will include multi-player support and
skeletal animation (using Cal3D) so we'll have some actual combat gameplay.
Our team is really excited about the next phase, and we think our little
Delphi engine will go a long way.
Darryl Long
Project Manager
(L) [2002/05/03] [FernandoRodríguez] [frodrig99@yahoo.com]
First, sorry if my english isn't very good.
The images above shows my carrer final proyect. It's an engine called Crisol (CrisolEngine) and is for make Computer Role Play Games (CRPGs) of Fallout style.
Some of the features of CrisolEngine are:
- 2D Engine (sprites) but using Direct3D (DirectX 7) to make basic lighting and alpha blending effects.
Isometric perspective.
Possibility of adjust the rules of the engine for the designer wants in his universe of game.
The engine support a "hour system" for the game universe (different hour, different light)
Use a scripting language, CrisolScript, for make the game logic (based in game events)
Use a sentencial language, CrisolBuilder, to define the content of a game (level design, entities, ...) and interface desing.
Managing one criature as player.
Combat system in turn mode.
Conversation system.
Presentation system based in slides concept. Posibility of make "cut -scenes".
Use of packed files.
WAV and MIDI support.
I hope that CrisolEngine will be finished this summer (September). I will released all the source code of the engine. I have a beta demo in spanish and english version (see the "English Info" section on the web to get the english version).
Some graphics are of the free isometric tileset that ZeroSum Software published long time ago, I put that in the credits option of the beta, the rest of the graphics are made for the engine by Manuel Moreno "Dracke" and Marcelo Galán "Sbe-Caos").
You can visit the web at: [LINK http://usuarios.lycos.es/crisolengine/]
Fernando Rodríguez
(L) [2002/05/04] [AlbertReed] [al@demiurgestudios.com]
This is a screenshot of our first released in-house game, FlipTrip. It's
a simple puzzle game which involves rotating tiles to make same-color
matches. There are three different gameplay modes which are completely
different from one another and gobs of settings to further customize
things. There's an internet-based high-score table integrated into the
game so everyone can see what your high-score is.
...Now the dork stuff that y'all really want to hear about...
- Developed by two programmers in 3 weeks.
Uses SDL for graphics, sound, music and windowing.
We used .tga files for all the images which compress quite well making
the download size smallish.
Alpha-blending is used on all things not animating currently to make
them purdy.
~9,000 lines of code
"SoftwareKey" was used for the copy-protection. (Yes, you can probably
crack it...please don't. :-)
Plays all types of mod-music files. (just drop them into the
/Sounds/Music folder to add your own.
Nullsoft's installer was used to pack it up
You can grab a free demo of the game at our [LINK http://www.elmerinteractive.com/buyfliptrip.html publisher's website]. Give it a download and
let me know what you think.
If you're curious about us, our website is
[LINK http://www.demiurgestudios.com]. And before you ask, no I can't give out
any screenshots of our Unreal-Engine powered game just yet. :-)
Later,
Al
(L) [2002/05/07] [malc] [malc@pulsesoft.com]
This is Motazaar - hierarchical character animation player for Outcast the
game. The core code is really old, but "flashy" UI, lighting and some
other stuff was added recently while i was trying to understand Gtk+.
But main reason to present it as IOTD is the fact that Motazaar wasnt
written in Algol/Simula derived language. Motazaar as it's predecessor
Okaar is written in [LINK http://caml.inria.fr OCaml]. Regarding animation, im
still not sure i got it correctly, or rather, im still as hell sure thats
not how Appeal did it in the game, but my method works fairly well most of
the time. Also there exist really small and much less glamorous C++
version of the player, it can be found [LINK http://algol.prosalg.no/~malc/okaar here].
Motazaar's page is [LINK http://algol.prosalg.no/~malc/motazaar]
(L) [2002/05/08] [DominicMorris] [dominic.morris@eidosnet.co.uk]
Here's a screenshot from a project which I've been working on in my
spare time for a few months now. I'm releasing the source code to this,
so that hopefully it may be of some use to others. This represents quite
a bit of coding time on my part, but I'm at a turning point in this
project; I would appreciate any advice you guys may have - basically, do
I polish this project, and try to package it into a playable game, or do
I start from scratch on another project (I'm thinking of a driving-type
large terrain game for my next project).
It's a D3D8.1a, Win32-only app. I'm afraid -- there's a fair bit of
stuff in this app, so in no particular order;
- Simple bot AI, (zombie-tracking) with abstracted 'flight controls';
this is just a struct. in CUserInput.h - I like it, because I can use it
to represent true user-input aswell as playback-type stuff and
computer-generated input.
Particle system - used in a true dynamic way and also in an
optimized-type way for the projectile 'lasers'.
Patch-based fixed-LOD terrain algo; this is definitely suboptimal --
inefficient use of vertex buffers causes excessive state switching and
poor performance, but it's interesting to note that even a suboptimal
design can be sufficient in certain cases. Quadtree frustrum culling is
applied here, nothing too fancy. It's possibly slightly unusual in that
I supply colour data in addition to dynamic D3D lighting.
Oh yeah, variable # of D3D lights are supported, and are dynamically
turned on/off in response to gameitem proximity. Leads to some pretty
shading under certain circumstances, but also to a strange blinking
effect!
A 'screen-overlay' system; an attempt at a better way of drawing
stuff like HUDs -- all these vertices come from the same vertex buffer.
Useful class: CCmdLineParser -- I'll definitely be reusing this one!
Groovy (read: quite fast) terrain-ship collision detection, see
CTerrain::LERPdY().
Billboards, scene output to BMP, mouse smoothing, basic
flight-physics modelling (actually a complete hack, to call it a model
would be silly) with a strange 'never-done-before' flight-sim meets
Quake-type strafe function :@
Menu handling code, and re-entrant game code, to support level
movement and game over type scenarios (not to be underestimated, proved
quite tricky).
Basically, a lot of the main elements of a game are there, but they all
need a hell of a lot of work before it could be packaged up and sensibly
called a GAME. I guess my question to you guys is, should I do so, or
should I restart afresh taking with me what I've learned?!
[LINK http://xlr8a.net/x7/flipcode_alpha0.zip]
[LINK http://xlr8a.net/x7/source.zip]
Cheers,
Dom
BTW: the bots are set to 'insanely tough' mode in the EXE -- this was
one of the last things I added! =)
(L) [2002/05/10] [DavidMassey] [genesis@cs.unm.edu]
This image shows a version of a little fun novelty project I've been messing
with for the last couple days that was inspired by seeing the movie
"Hackers" again (if you have not seen it and need a laugh it is highly
recommended). This is your very own "Gibson" packet analyzer.
It uses [LINK http://winpcap.polito.it/ Winpcap] for the packet
capture.
When you launch it you choose your network adapter and then it will go to
the main screen. You can then use w, s, a, d, to "fly" around and then use
e to lock the camera at the current orientation (so you can start up other
packet intensive apps or whatever).
New buildings will launch when a new IP or ARP packet come in (max 16
hosts). The source IP address will then be displayed on the top of the
building. Then each time a packet is received a portion of the raw packet
info is displayed on the tower and a particle is emitted from the building
in a random direction. The buildings time out and die after 10 seconds of no
communication from the source.
You can download it here.
[LINK http://www.perilith.com/~io/hackerpacket.zip]
Have fun and if you have any suggestions (maybe a localhost ziggurat :))
feel free to email me.
David Massey
(L) [2002/05/13] [SimonVeithReinholt] [haze@ostenfeld.dtu.dk]
I like making gametools. (And demo tools), and they are apparently a
little rare here on IOTD, so I'll post my most recent one.
It's a spline editor with support for 3 types of splines.
- Regular linear splines (extremely boring :)
Polynomial splines
Cubic splines.
In the top image you can see the control panel and the editor window
with a cubic spline. The bottomleft is a polynomial spline, and the
bottomright is a linear spline. In the cubic spline image, you can see
the handles attached to each node, and you can see some broken handles.
(i.e. 2 handles connected to the same node, but which can be moved
independently).
Cubic splines are the most interesting, as they provide the best control
of the exact shape of the generated curve. Those of you who uses 3D
animation systems probably knows their use in the form of camerapathing
and object movevement as well as a lot of other nifty applications.
Polynomial splines uses an N-degree polynomial to interpolate the
points. That is, if there are 5 points, the interpolating spline will be
a 5-degree polynomial. This has some (dis)advantages, depending on the
use, namely that the constructed spline depend on all data points, and
that we get some nasty looking splines with high degree polynomials.
However, the first derivative at each point isn't needed as it is in
cubic splines. This implementation uses the Newton divided differences form
The cubic spline solves the problem that high degree polynomial splines
has. By explecitly specifying the first derivative at each point, we get
an interpolating spline which in any given subinterval is dependent
solely on it's two closest points. As such, cubic splines provide a
continuous interpolant which is indifferent wrt. the rest of the data
points. I.e. You can modify/specify all other datapoints without
altering the rest of the curve. I used the Hermite form in the
implementation.
In the editor you can of course move, add and remove nodes, and you can
move and break handles. The calculated spline itself is drawn by
dividing each subspline into a number of interpolation steps (on the
IOTD it is 50) and connecting them with straight lines.
/Simon Reinholt
You can download the editor here: [LINK ftp://ftp.flipcode.com/demos/iotd-05-13-2002_splinegenerator.zip iotd-05-13-2002_splinegenerator.zip]
NOTE: If you download the editor, you'll notice a lot of flickering.
This is a Quick-N-Dirty(TM) program coded solely out of interest for
spline interpolation. Hopefully there aren't too many bugs in it. :)
(L) [2002/05/14] [ErnestSzoka] [eszoka@chat.carleton.ca]
These are pictures from my Terrain engine (yes yet another one!). What makes this one special is the frustum culling technique (no quad tree, just a frustum projection onto two min/max height planes followed by a polygon fill approach to culling the perimeter) and a Triangle Strip Preserving LOD (level of detail) based with geo-morphing (vertex interpolation between levels of detail). You can look at the paper on this project and download the demo at [LINK http://chat.carleton.ca/~eszoka/tstriplod/tstrip.htm] (note: demo takes 30 seconds to generate the terrain texture, but this is only done once).
Other features include fast collision detection on the mesh, quake style wavy-water, terrain height relief texturing, terrain lighting/shadows, lens flare and sprites that only draw if the LOD of the terrain beneath them is appropriate.
(L) [2002/05/16] [HenrikMunther] [psycho@loonies.dk]
The images above shows our recently released Amiga 64k intro. It is available
for download, incl. a divx video version, here:
[LINK http://loonies.dk/demos/demos.asp?id=thecastle]
The target system is a MC68060/50mhz cpu, AGA (the 2nd generation Amiga graphics
chipset) and 18 mb ram. The whole thing including music takes up 64 kb on disk.
Think about the performance of recent PDAs...
The whole intro is running clean 25 fps, synchronized to the video beam, ie. a new image for
every 2nd time the video beam sweeps the screen. This gives a quite smooth performance
compared to ordinary "free running" 25 fps.
The 3D Engine
Portal like approach. Portals are placed manually and most of the time only in
the doorways, connecting the individual rooms in a graph.
Each room is then sorted by its own BSP tree. These local BSP trees ensures
minimum splitting of polygons.
Scanline based C-buffer (coverage buffer) to avoid any overdraw.
The walls etc. are rendered as convex polygons with perspective correct texturemapping.
The division involved in the perspective correct mapping is done in floating point
while mapping the next 16 pixels affine. During the remainder of the perspective mapping
calculations themselves, the memory bus is utilized copying parts the last rendered
frame to the slow graphics memory.
Dynamic objects are placed as single points in the BSP, and rendered completely at that
point in the render process (the choice of point for an object is ofcourse quite important
then). The dynamic objects includes some small particle systems, torches (as blended animated
billboards) and ordinary affine texture mapped objects.
Interrupt driven queue-like n-buffer (instead of double or triple buffer)
system to make the framerate more stable by allowing the render to render ahead
of time to save up frames for the slower parts of the scenes. This effectivily
turns our 25 fps requirement from a worst case to an average case requirement. This
is ofcourse only possible because the system is not interactive.
The 64 kb consists of the following (after compression):
- 30 kb code
8 kb music, including player and softsynth for samples
10 kb textures (see below)
15 kb highly compressed 3d objects
1 kb motion paths
All textures are built from the same 256 different 8x8 pixel tiles. This
makes pretty dull and repetetive textures, so noise at different frequencies
are added afterwards. Lightmaps are then calculated by interpolated
raytracing incl. manually placed shadow objects (mainly to improve
precalculation speed compared to shadows from everything). The
lightmaps and the textures are finally combined so just a single texture
has to be mapped to each polygon in the realtime part. This is ofcourse a
bit expensive memory wise, but not as bad as usual, as the textures at this point
are 8 bit only too.
The intro ended up 2nd in the amiga intro competition at Mekka-Symposium, the
most important demoscene party worldwide. However, the competition rules allowed
both 3D hardware (which also cuts away a good deal on the code size) and a PowerPC cpu
5 times faster than our 68060, and the winning intro used both.
(L) [2002/05/17] [GordonWilliams] [r2@rabidhamster.org]
This is a screenshot from the upcoming release (v1.5) of the R2Extreme
Winamp visualization plugin. Rendering to texture is performed in OpenGL
to first create a Milkdrop/Geiss style effect, which is then drawn in
the background and used as an environment map for a 2-skinned,
49-metaball morphing shape. Up until recently, R2Extreme contained 20
seperate scenes, but it is now capable of mixing any number of them
together in realtime, as well as feeding one scene into a texture that
others may use.
for more info and screenshots, see: [LINK http://r2.rabidhamster.org]
(L) [2002/05/19] [CharlesBerube] [cberube@plugingo.com]
These are a couple of images from my (finally) completed project: Orbus.
I've been fiddling with game programming projects for years, but this is
the first one I've been able to call "finished", even if it isn't
perfectly "polished".
The official description from all the other websites is:
Orbus is a classic arcade-shooter style game with 90 waves of gameplay
both in space and over 9 different planets. Features include stunning 3D
accelerated eyecandy from huge explosions to weather effects,
customizable playlists, 7 original music tracks and all the tools needed
to create and play custom campaigns with new levels, graphics, sounds
and music.
Here's a short list of some of the
APIs/features/techniques/tools/knick-knacks that were used:
- DirectX 8
Custom archive file format (*.CLS) to keep the assets neat, with
an editor put together with MFC
The CLS file system supports (a slightly hackish) patching
system, similar to PWADs
User-editable playlists in *.M3U format (you can even edit them
with WimAmp, etc)
Seriously over-powered particle engine (Orbus doesn't exploit
even a third of its features)
"Pluggable" campaign files, which allow new sets of levels and
data to be used
Simple scripting language and compiler for the levels
Rain/Clouds/Water effects (which can be simplified for
less-then-ideal hardware)
Support for virtually any resolution (640x480x16bit is the
practical minimum), and FSAA if the hardware supports it
Automatic screen shot system - when active it takes a screen
shot roughly every 2 seconds. This made getting mid-explosion shots much
easier then trying to time it by hand. (It also meant I piled up nearly
5 GB of screen shots before I was done, but.)
NSIS from NullSoft for the installation program
You can see more screenshots and download the shareware demo from
[LINK http://www.orderlychaos.com/software/games/orbus.html]
Orbus will run on a system as old as a 350Mhz Celeron with a TNT2, but
the framerate is really not acceptable.
Anything from the 700Mhz range and up with a GeForce (and the newest
drivers) shouldn't have any trouble.
A version of the debugging display is still included in the release
version and it displays the framerate, press 'D' while your playing to
see it.
The target framerate is 70 FPS.
Feel free to email with any comments or bugs.
(L) [2002/05/20] [MichaelRostocki] [rostok@3-e.pl]
What you can see are screenshots of our m3D system. It is used to show flats and houses on
Internet. m3D is IE plugin written using ActiveX technology. It is quite small (200kb) and typical
house is packed to 500kb.
Some technical info:
- We are using Valve Hammer 3.4 as modeller, and Zoner Half-Life Tools to compile maps.
Some popular phrases that should be mentioned (BSP, PVS, RADIOSITY).
Graphics is rendered using OpenGL. Software renderering is also supported but since
it is PVS and brute Z-Buffer method it works fine on machines with 500MHz or greater
CPU clock.
Interface allows user to walk and interact with environment. Doors, windows can be
opened.
Each map has paths for lazy users or those unfamiliar with Quake.
Right now m3D is in developing state. We are going to add following
features:
- Dynamic lightning
Mirrors
Sound system that will increase realism
Versions for Netscape, Opera and Linux
Finally the link you are dying to see [LINK http://m3d.3-e.pl/index_eng.html]
(L) [2002/05/21] [Sylvain"Sly"Vignaud] [tfpsly@planet-d.net]
The three top pictures show the result of a project I have worked on
during my education. It is a 3D face model construction tool. It takes
two images of the user, some feature points are placed (manually right
now) and you have a 3D model of your face as a result.
[Special thanks to the sitter, a classmate]
It can be compared to the [LINK http://www.flipcode.com/cgi-bin/msg.cgi?showThread=02-09-2002&forum=iotd&id=-1 IOTD] by Wolfgang Engel. His program gave me this project idea. But it
does not work in the same way. I am using the 2 pictures as two
different textures, whereas Wolfgang was blending them together in order
to use environment mapping. The two textures are mapped with 2 planar
projection (front and side), and I use an Alpha blending function that
fakes the curve of the face to blend them together.
The four bottom pictures show results from my 3D engine: it can load
Quake I, Quake III levels (ok, who hasn't done that =) and 3DS files. I
also load the 3DS hierarchy and animation, as you can see in the two
bottom-left pictures. In order to write this loader, I used some "old"
docs (from 1996 or 97) to be able to read the 3DS chunk file, and the
sources of [LINK http://www.geocities.com/SiliconValley/Bay/6525/ Clax] to
understand the behavior of rotation and pivot point in 3DS.
Link to the 3D face reconstruction page:
[LINK http://tfpsly.planet-d.net/english/Face3d.html]
Link to my homepage:
[LINK http://tfpsly.planet-d.net]
(L) [2002/05/22] [StéphaneRedon] [Stephane.Redon@inria.fr]
This image is a snapshot of the interactive rigid body simulator I've developped during my PhD.
The collision detection algorithms used in the simulator are continuous : as opposed to most discrete collision detection methods, which detect objects interpenetrations, the present method uses an arbitrary in-between rigid motion to interpolate the initial and final object's positions and compute the time of first contact. Consequently, no interpenetration ever occurs, and no collision can be missed.
Regarding the dynamics algorithms, the traditional LCP (linear complementarity problem) approach has been replaced by the use of Gauss' least constraints principle, which is mathematically equivalent to the LCP approach, but presents some computational advantages.
In the example above, the car door (16000 triangles) is precisely (ie without any interpenetration) and interactively positioned in the car skeleton (29000 triangles).
Related papers and movies can be found at [LINK http://www-rocq.inria.fr/~redon]
(L) [2002/05/25] [Coda] [n/a]
[LINK mailto:n/a Coda]
This image is of a unfinished game that I made when I was in college. I submitted this because I'm trying to motivate myself to tackle it
again. Agreed that it is of an entirely overdone subject, but I'm writting this game to motivate myself to start coding again. I lost the
orginal code to this game due to a hdd failure, but I thought the graphic I made for it was worth posting. osdg.com is currently broken due
to the same hdd failure but I hope to have that at least semi-functional by the end of May. You can download the full unfinished sirtet
game at [LINK http://www.osdg.com/sirtet.zip www.osdg.com/sirtet.zip]. Some stats...
- DirectX 7.0 (can you tell how long ago I was in college?)
Just Sprite manipulation Direct2D even.
Tested on Win98 with standard 3d vid card
No sound
No startup screen.
Not really a game. More of a demo if even that
Escape key will get you out of it. The other keys are pretty standard
Graphics done in Photoshop and Paint Shop Pro
I'm rewritting it so I don't care if this one doesn't work on your machine. The next version will hopefully. Plus it's an unfinished
Tetris clone... is it really worth playing? Just look at the graphics and smile. It will make you feel better. Feel free to use them if
you desire to do so.
(L) [2002/05/26] [JulienMEYER] [jade@jadeware.org]
Halloween is Jadeware's newest game: a 3D shooter designed with the spirit of this unique holiday in mind! A
mix between fun, craziness, action, laughs and evil that will keep you playing again and again. The game
features a full 3D environment complete with an impressive set of weapons and monsters.
The game sets itself in a medieval context where the player is trapped inside an insane castle and has to fight
his way through to survive. Many ridiculous creatures including bats, giant spiders and mummies are there to
ensure that the player will not make it through.
The gameplay is based on time and speed will be your most reliable ally as you struggle to complete the
required objectives to advance to the next level. The full game comes complete with music, cinematics,
outrageous sound effects, over 10 diverse 3D real world environments, many different weapons to chose from and
a very unique gameplay that will have you screaming for more!
Download the Halloween demo (two complete levels, a 12 Mb download) :
[LINK http://www.jadeware.org/file/hsetup.exe]
--
Hello to all you coders at flipcode. I am the programmer at Jadeware and
have been working on the Halloween project since june of year 2k.
1) First of all some info on jadeware: We are independent students so this
is not yet a full-time occupation. Our average age is around 20 and this is
our first full 3D game. Currently about 5 people have been working on the
actual game conception so it is obviously not a major gaming production.
2) The game was entirely built from scratch. This is NOT the quake 1 engine
and this means that all the programming involved was done from scratch. The
same goes for all of the maps/gfx/modeling.
3) Hey, we are not expecting this game to be anywhere near the big gaming
productions that are coming out today. The game obviously has some flaws
that we are aware of, but in order to complete a game and be constructive
you have to set yourself certain objectives that are attainable. On the
other hand, I feel this is a fun game that has many innovative aspects to
it, and I am proud to be associated with it. I'll be happy to review this
whole situation in a couple years when we have a few more games under our
belt.
4) Regarding the time it took us to complete the project: two years ago when
all this started there was only 1 person involved and most of the work was
based on research. Most of the actual game content has been created since
september.
5) Finally thanks to all who are taking the time to test this out and bring
CONSTRUCTIVE feedback. Thanks to flipcode for the added exposure.
(L) [2002/05/27] [TimoKSuoranta] [tksuoran@cc.helsinki.fi]
This is a screenshot from the 3D graphics library Teddy which
I have been working on slowly during last few years. It provides
scene graph and windowing system, built on top of OpenGL using
the Simple Directmedia Layer and C++.
Teddy has web pages at [LINK http://teddy.sourceforge.net]. Full source
code and Win32 demo executables can be downloaded from there.
This image shows the scene graph in action. Teddy contains
constructors for some primitive shapes like box, sphere, cone,
capsule, torus etc. It can also load LightWave object and
scene files.
The main focus is to make an easy to use scene graph.
There is nothing special about the rendering features. It is
plain OpenGL rendering with only separate specular component
extension used at the moment, using display lists and no
vertex arrays yet. Normal OpenGL vertex lighting and texture
mapping is supported. What I myself like in the scene graph is
the ability to set camera windows spesific rendering settings
while you can have the same scene and camera in multiple camera
windows. For examples of this you can look at some more
screenshots at Teddy homepage.
(L) [2002/05/28] [CharlesBloom] [cbloom@cbloom.com]
This image shows the "fandisk" model, with normal-mapped lighting,
and VIPM LOD. On the left, you see the model at 1016 triangles,
lit on top, in wire-frame on the bottom. On the right, you see the
original full detail version of the model, with about 12,800 triangles.
The two lit images (on top) really are different, but it's mighty hard
to tell them apart!
This is really old technology, but it's finally making its way into
games. I'm first generating a unique full surface uv-mapping for arbitrary
models; actually my uv-mapper is terrible at the moment, making lots
of seams, but it does the trick. Next, I draw an object-space normal
map for the model. Finally I generate a VIPM collapse sequence for
the model. I can then render the model at any LOD, and use the
normal map generated from the full LOD version. The lighting is just
a simple DP3 operation, which can even be done with the fixed function
pipeline on a GeForce1.
This will all be available for download sometime soon in the "Galaxy 3"
package. In the mean time you can check out Galaxy 1 and 2 at
[LINK http://www.cbloom.com/3d/]
You can see the "fandisk" model at these web sites :
[LINK http://www.trianglesoftware.com/gueziec/progifs/fandisk.html]
[LINK http://ftp.research.microsoft.com/Users/hhoppe/data/thesis/phase1_meshes/]
(L) [2002/05/29] [inkyblue2] [inkyblue2@hotmail.com]
This image shows three views from an OpenGL refraction engine that I put
together two years ago. Do not think for an instant that it's being drawn
real time! Last I checked, getting over one frame per second is blazing
fast for the diamond model. The number of distinct images visible in your
average top or side view of a brilliant cut diamond is mind-boggling. (Note
that grey areas in the topmost image are places exceeding 31 refractions.)
Of course there is a whole host of optimizations that can be done to speed
things up, but don't expect to see this on your Xbox any time soon.
This algorithm really puts the stencil buffer through its paces. The basic
process, illustrated in the lower right image, is this:
- Draw a "primary" face of the model (outlined in red) into the stencil
buffer, incrementing the previous stencil value by one.
Calculate the angle of refraction - or internal reflection - and apply
what amounts to a shear matrix to the current modelview transform based on
this angle and the orientation of the face being drawn.
Turn on the stencil test so that drawing only occurs where stencil ==
(recursionLevel - 1). This effectively clips the scene to the visible area
of the previously drawn face.
Draw the scene again, into refracted space. Recurse if necessary (as
shown by the green outline). If "normal" scene data is drawn, set the
stencil to zero to indicate that this area is done.
The hard part is optimizing the algorithm so that only the faces visible in
the previous face are calculated. The number of faces tested and drawn
grows exponentially at each level of recursion, so tiny improvements in this
culling yield huge speedups. This is where the work is stalled currently;
I'm using stencil testing, scissor testing, custom clipping planes, and a
handmade polygon clipping thingy, and I'm still not happy. There is even
potential to make this viable in a real-time engine if you're willing to
cheat a little and render a simplified scene in the refractions.
I don't have source code because it is not exactly stable for public release
yet, but there is a 75% finished HTML tutorial sitting on my hard drive
staring at me. I still plan on publishing it along with a streamlined
version of the code one of these days. If you really want to see it, drop
me a line and tell me to get working on it. The main reason this has been
collecting dust is that I have no intention of using it in the future, but
if someone wants to use it in a game or something, that will be inspiration
enough!
Jon (inkyblue2)
(L) [2002/05/31] [MarkusIlmola] [markus.ilmola@pp.inet.fi]
Screenshots from my latest game JAWC beta 5.0. JAWC is a Worms clone. Actually Just Another Worms Clone, but with 3D graphics.
JAWC was my first OpenGL game ever and the first version (beta 1.0) was released over a year ago.
All 3D models are made with Milk Shape 3D. Most textures are made with Paint Shop Pro 6 and others are collected from the internet.
Features:
- Skeletal animation
Cel-shading
Multitexturing
10 weapons: bazooka, grenade, cluster bomb, dynamite, missile, airstike, sheep, banana bomb, teleport and suicide.
Terrain generator
Frame rate independent trajectories are calculated using real physic
equations.
JAWC can be downloaded from my homepage: [LINK http://markus_ilmola.tripod.com]
(L) [2002/06/02] [Elkdanger] [mrhobbs@intelynx.net]
Hi there - I'd like to sub this image from a project I am working on - some kind of 3D shoot 'em up not too dissimilar from Starfox/Starfighter - that kind of thing.
The main image is from a test version showing the terrain and a test model ship, while the inset image shows the method I plan to use for terrain reflection in the water.
Techie stuff:
- a.. Terrain generated from greyscale heightmap, and spilt into a desired number of terrain "blocks"
b.. Terrain texture generated from 4 landscape textures (grass, rock, and so on...) and detail texturing (not shown here)
c.. Quadtree culling on objects registered as static
d.. Rendered using DX 8.1
e.. Real time bump-mapped reflections using texture rendering and projection (inset)
f.. Stencil shadows on objects
There are two people so far working on the project (programmer and
artist), but the gfx and models shown above was done by myself for
testing purposes. I should have more images and demos for download
from my website, which is also to follow soon! ([LINK http://www.mrprogrammer.co.uk/elkdanger])
The project is still at an early stage, so go easy!
Elkdanger.
(L) [2002/06/03] [ErikPojar] [erik@pojar.net]
The image shows my ProgressiveMesh plugin for Maya.
For my master thesis that I'm currently working on at the Technical
University of Vienna, I'm researching methods for user controlled creation
of Progressive Meshes.
To demonstrate my results I've implemented a plugin for Maya that lets you
create a Progressive Mesh from a Maya polymesh. Once a polymesh has been
turned into a Progressive Mesh you can change the model's "resolution"
(number of vertices or faces) in realtime. Furthermore you can control the
reduction of the model by marking areas of the model as more important or
less important. The reduction algorithm will take this information into
account and reduce the less important regions most agressivly, while the
important regions will be reduced less.
Basically, I build upon the work of Michael Garland (he's the inventor of
the original quadric error metric) and Hugues Hoppe (I've implemented his
quadric metric for attribute simplification).
Most research on polygon reduction has focused on completely automatic
reduction.
But there are situations in which it is desirable to have more detailed
control over the reduction process. This is especially true for interactive
applications (such as games or simulations) where one might want to use
Progressive Meshes for dynamic LOD and load balancing. For these
applications, usually one wants all intermediate representations to look as
good as possible. And often, some parts of the geometry might just be more
important to you than others.
E.g. in a game, for your model of the main character, you might want to have
a way to tell the reduction algorithm to reduce the face less than the rest
of the body.
Another common example is skeletal animation: You might want to reduce the
deformable regions around the joints less than the rigid regions.
To address these needs, I've developed a new error metric that let's one
specify the importance of regions interactively and intutively.
The user simply paints the importance onto the original model, similar to
weight painting.
It's a bit difficult to see in the image, but you might notice, that the
reduced fighter model has higher detail in the knee and head areas. This was
achieved using importance painting.
To learn more about the plugin or to download it (comes with full source
code), please visit: [LINK http://www.pojar.net/ProgressiveMesh]
(L) [2002/06/05] [SeanSmith] [vostorus@mchsi.com]
These are a few images from a game I've been working on for quite a while,
called Project - Raptor. If the name sounds a little familiar, it's because
it was designed to be a 3d version of the typical top down arcade shooter
(like Apogee's Raptor). I started working on this game because I wanted to
create a demo to show game companies in hopes of getting a job in the
industry (job offers are of course, more than welcome).
Some development info:
- Uses OpenGL for rendering and DirectX for input and sound
A whopping 3 different weapons (Cannon, Laser, and Plasma)
Pickups including: weapons, multiplier (up to 6 shots at a time), health,
shield, and extra points
Only one level since it is a demo
Semi AI (enemies can put a lead on the player based on their current
weapon and the players speed)
Simple heightmap terrain that is loaded from a polygonal mesh
Standard particle effects for explosions, smoke, and plasma weapon
"Developer" settings available to turn on/off: wireframe (shown in bottom
right screenshot), normals, bounding boxes, lighting, fog...
Custom plugins developed for 3dsMax to export the meshes and designing the
levels (placing enemies, pickups...)
All programmers art (which is probably noticeable) except for the
background space image
Development history (including screenshots along the way) available at my
website: [LINK http://vostorus.home.mchsi.com]
Direct download link to demo (2mb): [LINK http://vostorus.home.mchsi.com/game.zip]
Note: I would recommend that you look at the Help screen and at the controls
under the Settings screen before starting!
I would appreciate any feedback and would also welcome any questions!
Thanks,
Sean Smith
(L) [2002/06/07] [NateMiller] [nathanm@uci.edu]
Here is a screenshot of Lunar Lander 3D, the game that I have been working
on for the past two to three months as an escape from the drudgery of
school. Lunar Lander 3D is a remake of the classic Lunar Lander game, but
done in 3D, as you can already see. The goal of the game is pretty much the
same as the original, fly around without crashing or running out of fuel,
but I have added a few extra things to make it interesting. I use OpenGL for
the graphics portion of the game, SDL for the window creation and input
handling and DevIL for image loading. Aside from those libraries, the rest
of the game uses my brain.
In terms of graphics, I have no buzzwords to toss around. The most complex
graphics feature that I use in the game is multitexturing, but you don't
even need that to run the game. My goal was to keep everything simple, which
meant avoiding hardware specific OpenGL extensions. Also, the fact that I
don't have access to fancy pants hardware makes it difficult to use exciting
hardware features.
That is about all I have to say. After I am finished with finals, I hope to
polish everything up and release the game. When the game is finished, I plan
on releasing the source code to it since there is no point in letting it rot
on my hard drive. If you would like to see some more screenshots and an old
movie of my game, head over to [LINK http://nate.scuzzy.net/lunarlander3d]. Any
comments, suggestions or exotic animals can be sent to [LINK mailto:nathanm@uci.edu nathanm@uci.edu].
(L) [2002/06/09] [JaccoBikker] [Jacco.Bikker@overloaded.com]
Here are some screenshots from games developed with the Overloaded Game
Foundation:
This is a set of libraries that we developed here at Overloaded for creating
games at hi-speed.
Overloaded creates content for GPRS connected consumer devices. At the
moment we
focus at PocketPC's and soon Javaphones and smartphones.
Some notes about the tech involved:
- The Foundation consists of a set of 'common classes' and a 'game frame'.
The common classes reside in a DLL, so that multiple games use the same
code. This
reduces the download and install size of the individual applications.
The 'game frame' is a state machine that implements standard things like a
splash screen,
the login screen and credit dialogs, but also a menu and gameover screen.
The idea is that
individual applications overload some or all state implementations. The
main loop in the
game frame executes these methods, and takes care of things like screen
updates, audio
handling and other generic activities that need to be done each frame.
The game frame ensures that all applications have the same splash screen
and login
dialogs, unless a coder deliberately bypasses these.
The DLL uses a COM-like interface (by Jaap Suter) that allows us to update
the DLL
without breaking older applications developed with an older version of the
DLL.
The Overloaded Game Foundation can be downloaded (including source code)
from [LINK http://overloaded.pocketmatrix.com].
Releasing the sources may seem very odd, but let me explain why we did
this:
- In the first place, Overloaded currently does not have enough coders. But
we need a
large portfolio. So we came up with the Overloaded / PocketMatrix Game
Coding Program:
Write a game using our tools, and we pay you $1000. Right now, 9 teams are
working
on 9 games based on our designs, using our tools.
The library and it's source code are not our primary assets. The library
is quickly getting
pretty advanced (with the state machine, the new c-buffer code and all
that), but I believe
you could find all of this on the web if you look well.
Sharing knowledge is the only way to get more of it. :)
About the shots:
The topleft shot shows our logo. :) Right under it, the login screen that
you get with each
Overloaded game. The full implementation is in the DLL, so it can be
updated. Next, three
games: Asterox (top centre), Fraxxon (P2000 classic, top right) and
PocketQuiz. The bottom-
right image is a shot from the parallax scrolling demo (6 layers @ 60fps).
So go check out the website, and the Overloaded forum at
[LINK http://www.pocketmatrix.com]. :)
If you're interested in PocketPC coding, but don't own a PPC, don't worry,
it's perfectly
possible to write games using our library on a desktop machine (using VC),
and you
could still earn that $1000 cheque. :)
(L) [2002/06/11] [BrunoCesteiro] [brunomtc@hotmail.com]
This are some shots of Project FY, a game in development for quite some
time.
The core of the engine is basically finished ( the Torque engine is not
being used ), and we are now starting with the making of the real game.
The engine provides an indoor/outdoor environments with no loading times
between both of them. The landscape culling is made with a Quadtree, and
each node of the quadtree can be linked with an indoor bsp structure.
The game will be happening in several planets and in several environments
that go from forest,desert to icy planets.
On the test demo you can play agaisnt some real basic bots ( they just
patrol some areas and shoot at you when you are close), or if you want to
test the multiplayer capabilities you can also do that, however only
mano-a-mano type games are included(8 players max).
You can also choose 3 weapons, Plasma rifle, Sniper rifle and a Machinegun.
If you wish to play around with the environment options, check out the
readme that cames with the demo.
And just to finish.., we need help :)
If you wanna join the team, we reallly need artists ( 3d modellers /
skinners / 2d artists ), sound guys, etc etc.., anyone that thinks it can
help us, let me know.
You can see more screenshots/demo here :
[LINK http://www.cfxweb.net/~projectfy www.cfxweb.net/~projectfy]
(L) [2002/06/13] [DierkOhlerich] [chaos@vcc.de]
i just finished the final version of my 64k-intro "fr-019 .poemtoahorse". we
won the mekka and symposium intro competition, but the party version had
many bugs.
the screenshot shows "extrude and subdivide". a powerfull combination to
create abstract blobby stuff. this is just one of many 3d-scenes, all
stuffed into 64kbyte including code, sound and graphics.
most important about the product is a tool that allows you to create
everything in realtime. this includes changing every aspect of a texture
while seeing it mapped as an environment map in the lighted 3d scene. that's
a real big win if you try to set the envi map up in a way that makes it
shine in exactly the right moment of the camera movement.
you can download the intro at [LINK http://www.theproduct.de/fr-019-final.zip]
more information about how it is done can be found at
[LINK http://www.theproduct.de] . this page refers to fr-08 the product, but both
projects are similar.
Dierk "Chaos" Ohlerich
(L) [2002/06/15] [EricB.] [eric_hcr80@email.msn.com]
Asteroid Arena is a another simple Asteroids clone that uses OpenGL and the ClanLib programming library. It's reached a point short of being done but fun and solid enough to release, so I thought I would put it out there and get some feedback before finally polishing it up.
The game is nothing radical: shoot the asteroids while gathering powerups and avoiding UFOs, but it is the first 'real time' action game I've programmed. It features frame-rate independent object movement, a fairly robust particle system, and high-FPS rates (45+ even on my old voodoo3 test machine). There are also a good number of little details like engine glow, shield fading, and twinkling stars that add to the overall appeal of the game but really don't use anything more complicated than alpha transparency. I'm currently working on a two-player network version for dogfighting, as well as a menu system that's currently absent.
Just as a side note, I'm really impressed at the length of time people work on some of the projects that appear here. It's not unusual to see projects that take months or years.. I've been working on this project for two weeks and I'm definitely ready to move on. :)
You can download the game and source code at the project page here:
[LINK http://www.gla55pak.com/lameduckie/02june/asteroidarena]
Eric B.
(L) [2002/06/18] [LesBird] [lesbird@bellsouth.net]
This screenshot is from my 2nd freeware game called X's & O's Football. The game was written using Visual C++ 6 and the DirectX 8.1 SDK. Even though the game looks 2D it does use Direct3D to render all the graphical elements as flat polygons. Some polys are textured, such as the yard-line numbers, and the rest are simply unlit flat shaded quads. The game also uses full-scene anti-aliasing if supported by your video card and requires a 6-button gamepad or joystick to play. It supports 2 players but only on one machine using either the same usb controller (offensive player only) or 2 usb controllers (offense and defense). AI in the game is pretty basic with the defensive players doing whatever it takes to get to the ball (ie. a straight line approach) and the offensive players trying to form an arc in front of the ball carrier to block the defense. Collision detection is done using bounding spheres around the players and the ball. You can pick one of 5 plays for offense (and defense if multiple controllers are used) which include passing plays, punts and field goal attempts. Games are timed at 15 minutes and a 20 second play clock keeps the game flowing.
Download the 1.5mb game at [LINK http://www.lesbird.com/default.htm]
Enjoy!
(L) [2002/06/19] [BrendanReville] [brendan@brendanland.com]
BrendanLand is, as far as I know, the world's first peer2peer network where
each participant actually serves their own piece of geography in the overall
world. It's not a game but a chat environment that you can walk around in.
Each person serves their own self-designed piece of land.
Once you log in, you can walk around and chat to other people in the
environment. As you walk off the edge of one "land" you roam onto the next
piece of "land", and hence you roam from node to node in the big peer2peer
network.
There is a master server which handles the arrangement of the geography.
All traffic is UDP, and each person on the network acts as both a server (of
a piece of land) and a client (for the fun chatting and walking part).
If you follow the links from the main page at
[LINK http://www.brendanland.com] you
can read fairly detailed technical descriptions about how it works, and
notes that I wrote as I created it.
- Brendan Reville
(L) [2002/06/24] [ElikEizenberg] [elikez@gmx.net]
The image above shows some pictures of my high-school robotics project.
A team of three, we were given complete freedom in designing and
building our final project.
Although most of the students in our class had decided to stick to the
popular concept of a robot, we chose to design a rather unconventional
robot: Instead of having one robot-unit, consisting of a censor,
processing unit and vehicle - we decided to disunite our system to
several independent modules and components.
The first component is the processing unit. We used a standard personal
computer for this, while our only alternative was a simple processing
unit, based on a semi-assembly language. Using the simple processing
unit meant no means of debugging, no high-level programming language
and, most importantly, a tight limit on RAM memory. Obviously, using a
personal computer was a wise decision - We used C++ as the programming
language and MSVC as our IDE and debugging environment.
We had two hardware modules in our project. The first is a toy car
(Figure 2) with a remote control (Figure 1), which served as our
vehicle-component. Since our main project goal was developing the
algorithm itself, we decided to avoid mechanical work as much as
possible. Accordingly, we didn't construct the car ourselves, but
purchased a toy car. We disassembled the electronic part of the remote
control, and connected it through electrical relays to a parallel-port
cable. We then used the WinIO driver to access the parallel port, and
control the car's actions. After a lot of work on this component, we had
a fully extendable and usable library, which controlled the car's
movement and rotation.
The second hardware module is our censer-component, which is actually a
cheap webcam (Intel EasyPC Camera, Figure 4). Again, we had to write
some code in order to get access to the streaming picture from the
camera. We attempted using libraries such as MS WIA and Twain, but ended
up using Intel's free OpenCV library.
We now had input data (the pictures taken by the camera) and output
methods (the car controller). The processing itself consisted of two
algorithms: one is an object recognition algorithm, which detected
objects in the input picture and returned their coordinates. Note that
the coordinates were 2D coordinates, affected by the camera's
perspective. Therefore, we transformed the coordinated into top-view
coordinates. The second algorithm is an object navigation algorithm that
decided how to move the car according to the object-coordinates
calculated by the other algorithm.
The final result:
A ball and the car are initially placed in random locations on a flat
surface. Then, the camera is set so that the car and the ball are inside
the camera's picture. Our program, a Win32 application (Figure 3), is
started and the robot begins. The car automatically finds the ball,
approaches it, rotates with it until it points at one of the corners and
pushes the ball to the corner.
If you are interested in more information concerning the implementation
of the robot, please contact me by mail at: [LINK mailto:elikez@gmx.net elikez@gmx.net].
The team: Elik Eizenberg, Michael Seldin, Sasha Kravtsov
(L) [2002/06/25] [RichardLee] [leerj@tcd.ie]
Lots of novel things happening here...
First of all, you can use the mouse to rotate the window on top of your
desktop. The simulator responds to this by simply rotating the gravity vector.
These forces have been used to form a breaking wave in the image above.
Secondly, the literature on which the simulation is based distributes marker
particles throughout the liquid area, but I developed a way to track the
liquid/air interface requiring particles only near the surface. These
particles are reseeded every frame based on dynamic rules which also help
converse mass better. (Although, since the computational mesh is anisotropic,
screwing with gravity adversely affects this.)
I also came up with a novel technique to render the liquid. I'll describe it
here since the idea is applicable to any 2D or 3D particle system. (The demo
only distributes particles around the liquid surface but assume here that the
liquid is entirely a 2D particle system.) The approach is a hardware
implementation of the classic 2D metaballs effect, which basically amounts to
thresholding a summation of 2D density functions...
First I procedurally generate a Gaussian density function in a 16x16 alpha
texture-map and set up a texture which can be rendered to, which I'll refer to
as the p-buffer. Now, for each frame, I first clear the p-buffer to the colour
(0,0,0,0), set the vertex colour to (0,0,0,1) and enable blending with ONE/ONE
as the src/dest functions. Then I render each particle into the p-buffer as a
16x16 pixel quad, texture-mapped with the density function. After this, I set
the vertex colour to (1,1,1,0) and render another quad which covers the entire
p-buffer. This can be mapped with a texture of your choice. We've just
completed the summation of the density functions for each metaball. To perform
the thresholding all we need do is enable alpha-testing, set the function to
'greater than whatever threshold you choose' and render a quad to your
frame-buffer, texture-mapped with the p-buffer.
You'll notice in the demo that the liquid surface is also outlined. To achieve
this, we start by filling the alpha channel of the p-buffer exactly as above.
From here we render a quad mapped with an "ink" texture to the p-buffer, and
render a quad mapped with the p-buffer to the frame-buffer, same as above. To
create the effect of an outline we now render a second pass (using our
original map) opaquely on top of the ink pass, but using a slightly smaller
threshold so that a "band of ink" from the first pass remains visible. This
means we need to write a new texture-map into the RGB channels of the
p-buffer, making sure not to modify the alpha channel. To do this, we could
just mask off writes to the alpha channel but this was incredibly slow on my
GeForce. A better solution is to first zero the RGB channels of the p-buffer
by setting the src/dest blend functions to ZERO/SRC_COLOUR, the vertex colour
to (0,0,0,1) and rendering a non-texture-mapped quad which covers the
p-buffer. Now we can set the blend functions back to ONE/ONE and the vertex
colour back to (1,1,1,0) and proceed to render the second pass exactly as
before but remembering to use a smaller threshold.
This same method can also be used to render level set representations of 2D
liquid or fire by simply copying the distance grid to an alpha texture of
equal dimensions each frame and letting bilinear filtering interpolate the
distances. In the case of fire, multiple passes, each with a different
alpha-testing threshold, can be used to render different parts of the flame
with different texture-maps. Alternatively, a spectrum could be defined in a
1D texture-map which is looked-up using the interpolated distance values.
The "looking through liquid" effect is nothing more than a preprocessed
512x512 capture of the desktop. The procedure I came up with involves applying
two wave deformations, blending in a a bluish tint with Gaussian noise and
applying two Gaussian filters. Of course, in the real world refraction doesn't
occur when looking through a tank of water like this but I thought the
waviness looked nice.
You can download the demo here:
[LINK http://matrix.netsoc.tcd.ie/~the_one/iotd2.exe]
It has been tweaked and tested only on my PIII-700 running Windows 2000 with a
GeForce 1 and I'm using OpenGL extensions which I think require at least 28.32
drivers. There will be a small delay when you run the program to generate the
textures. Performance is fill-rate bound on my configuration so by default the
demo takes three Euler steps (the time-step is fixed for stability reasons)
per frame giving me 35 FPS. You can specify this ratio yourself with the
number keys however and I suggest you try this. You can also toggle the ink
pass by pressing 'i'. To quit either press escape or change focus from the
window. Finally, you may notice that sometimes little "explosions" occur when
the water velocity gets too high and the simulator becomes unstable, so be
gentle. Also note that I took out the anti-aliased window edges and reflective
glass pane feature (shown above) to accomodate the unconventional window
styles of WinXP.
If for some reason you can't run the demo, you can download a 512x512 DivX
movie of the above executable running on my computer here:
[LINK http://matrix.netsoc.tcd.ie/~the_one/iotd2.zip]
(L) [2002/06/26] [MarcMcCall] [eniac@xynth.net]
This image is a collage of screenshots from a realtime performance visual
synthesizer I've been working on in my spare time. I've been using XYNth
since last October to perform 'visual mixing'/VJing at various clubs in LA
and OC, California, where the response has been amazing!
XYNth (ok, N looks like a Z on it's side, get it? XYZ :) is written in C++
and openGL and uses it's own OS independent GUI. (i.e. future OS X & Linux
versions probable )
There are 7 divx clips of actual live on-the-fly performances using XYNth.
There will be PC demo released in July.... !
No GUI screenshots yet - until it's done - It's my secret-weapon, so to
speak ;P
[LINK http://xynth.net]
Marc A. McCall
(L) [2002/06/27] [MattZucker] [mazucker@vassar.edu]
"Last stickman standing" is my entry for the 2002 5k Contest at
[LINK http://www.the5k.org/] -- the 5k is an annual contest to pack a cool
webpage into 5 kilobytes. This is a java applet game that I submitted for
the "anything goes" category of the competition.
The idea is, there are these stickmen running around a little 3D room
beating each other up. You place bets on which stickman will be the sole
victor at the end of each round. From a technical standpoint, the game is
pretty neat -- it contains the following features, all in only 4889 bytes:
- parameterized skeletal stickman animation
smooth depth scaling for stickmen
custom-made user inerface written without java AWT
cheat mode! (peek at the java console for a betting tip)
How do you cram a functional java game into under 5 KB? The answer: dirty,
dirty coding practices.
For instance, instead of coding java methods for small snippets of
repeated code, I used the C preprocessor, CPP, to create macros. It's
easier to maintain the code than actually duplicating the code all across
your source file, and it results in smaller code size than finalized methods.
Another big size gain which is sort of dirty java practice is to put all
of the code into one mammoth class. I started developing with 3 or 4
classes, but putting all the code into 1 source file halved the code size.
Also, coding in loops is key (my code size barely changes when I add more
stickmen because it processes them all in a loop).
Conveniently, java classes may be stored in compressed archives, and your
browser knows how to recognize them just fine. The compression also means
that repeating elements of code or data is good, because it increases
redundancy and is hence more compressible.
Finally, I used [LINK http://jarg.sourceforge.net jarg], the freeware java obfuscator/optimizer, in order to crunch down the archive size
from 6585 bytes down to 4889.
Please see the entry at [LINK http://www.the5k.org/description.asp/entry_id=717]
-- and don't forget to check out some of the other brilliant entries.
(L) [2002/07/01] [LievenvanderHeide] [lieven@quasar3d.nl]
This is a screenshot of the leveleditor I am making for my engine the interface is based on the interface of lightwave. I started half a year ago with a 3d engine, and after programming a bit I needed a way to create my worlds, with it's objects and portals, so I started with a level editor only for my own use. Now I've finaly finished the things I had in mind when I started it (placing objects and portals), but it isn't finished at all, because now I've got many more ideas, like a radiosity lightmaps, an assambler compiler for scripts and special fx like particles, lens flares, volumetric lights and waves.
I think I will make it public when my game is finished, but it may take a long time until I've finished all my ideas.
I model my objects in lightwave, and import them in my world editor. the portals are polygons with a surface name that start with Portal_.
You can connect the portals from two different objects to each other. btw the Kamers en Portals tab (which means Cells and Portals) is ancient. I moved the portal stuff to the object editor, because it doesn't use a view at all.
I think I will now continue programming my engine, so that I can walk through the worlds, and after that I will continue with the editor.
features:
- Lightwave object (.LWO) importer
placing the objects
portal editor
a direct3d view window class
A pretty advanced interface
not finished yet:
- Lightmaps. It already maps the UVs for the lightmaps correctly, but it does only directional lighting. I'm going to make a radiosity renderer for this.
particles
assambler script
Test view
Radiosity
updating my website.
not started yet:
- Lens flare
volumetric light
waves
enemies
translating it to english
(L) [2002/07/02] [UthmanApatira] [wiz3d@wiz3domain.com]
What's up all!
First, I'd just like to say that man- the IOTD's are really looking nice
and you all should keep it up. There's nothing better than working hard
and getting nice feedback for your work. Anyways- for this shot's
description.
This is a procedural aquarium that I've been developing for two weeks in
my spare time for a chapter of a friend's book. I say 'procedural'
because a lot of the things in it are controlled using a procedural
texture primitive- noise. The first thing I did was develop a bunch of
interpolation functions- linear, cosine and cubic. Then, using noise I
somewhat uniformly dispersed the fish around the aquarium. Each fish has
its own tic count timer. When it elapses, a new position is chosen
randomly (via noise) and the fish is moved via one of the three
interpolation functions. Also, if you look at the back of the tank
you'll notice a bunch of bubbles. The bubbles use a very similar
algorithm that the fish do; I create a Bubble/Fish bounding field (in my
case, just a box, but it is adaptable and can be any shape the
programmer wants) and move the bubbles at a constant rate up the Y-Axis
adding noise each tic to make them jiggle unpredictably like real
bubbles. Last but not least, the light under the case's intensity
flickers- once again, also by means of noise.
As you can tell, this really is one noisy demo! But just sitting back
and watching it really is peaceful. I'm also thinking of making a screen
savor version. Ah, yes- I forgot to mention; the ground is also a
heightmap that is generated by- you guessed it: noise. Anyhow, the
purpose of this demo was to show programmers just how easy it is to add
details to their games using noise instead of paying animators (no
offense animators- I consider myself an animator too, so I know how it
feels =P). My goal by doing this is to be able to save this project into
a nice little adaptable .dll and call it up in my 3D engine whenever I
want. If I can add enough 'small programs' like this to the .dll, I can
essentially develop a library of cool specifial effects that I can
easily just 'drop' into any game I make.
The demo has already been completed- it has nice sin/cosine auto
rotation, and if u press the 'R' key, you can use the arrow keys to
navigate manually. Also, in the program directory, there is a file
called numFish.txt which allows people to adjust the fish count. All of
the fish Sleep, Swim and Interact with each other. The demo is not
available online yet because it's going to be going into my friend's
book. But once the book is out, the executable will be made available
online. The source and a beautiful 30page chapter explanation will be
found in the book only! For now, check out more pictures at my
website:
[LINK http://www.wiz3domain.com/aq/]
Till next time,
-Uthman "Papacharino" Apatira
(L) [2002/07/05] [WymsicalW.Wyvern] [wallaba@sympatico.ca]
I've always wanted to post an IOTD, and today is my time. Just as how I
like to hear myself speak, I like to read myself write so this
description is gunna be long :P. The image you see are various
screenshots from my OAC (grade 13) computer science ISU. The project was
a wide open project and me and my friend chose to do a simple AI engine.
We called it sdAI, and it goes with my sadism library i'm working on. (
[LINK http://mars.spaceports.com/~sedition] -- you may _soon_ find info on
sadism there)
I had no experience with before starting on this project, and I didn't
do too much reading before I started to design sdAI, so its architecture
prolly isn't the best. There are two parts to the AI engine, low-level
components : generic finite state machine class with messaging and
message interception, an MLP, and a 2D influence map (the influence map
supports searching functions! and the ability to add different types of
influences on the influence map, like conical, doughnut shape etc.). The
other part is the highlevel, meant for a real-time strategy game, or
even any game with a top down, run-a-base/empire game like civilization,
command and conquer yadda yadda. It uses 4 main objects: goal, subgoal,
underling and priority rule. Priority rules are used to reprioritize
major goals. These goals are like: base production, offensive,
defensive, resource collection etc. These major goals create and manage
subgoals. These are like harvest x number of resources, or protect unit
"x" or destroy unit "x" etc. Subgoals are assigned to underlings. Its
all nice and beutiful right? Well I'm pretty sure my teacher woldn't be
very impressed with just the sdAI .lib file, so I made a test game:
StarKraft.
In starkraft you are the NDI (national defense initiative) and you are
fighting an enemy who are green, barbaric people (very orc-like) called
the orgs. You collect tEberium, to fundyou war efforts. There are only
the basic units/structures in the game: mine, engineer,attacker,
defender, defensive tower and factor. So it can simulate a real game
fairly acurately. I implemented the most simple goals and subgoals for
the game, yet it works quite beautifully. I _would_ put the game up for
download but its a whopping 20mb compressed.
I would like to direct your attention to exhibition "A". Here you see
the beautful use of ASCII art. Undoubtedly the best part of the game. In
exhibition "B" you see the beautfifully rendered main menu screen (at
least part of it, i had to cram alot of shots in the allowed space). At
C you see the lightning towers (not to be confused with tesla towers)
shooting the engineers. Over at D you see the AI engine's dump of the
underling states and the sub-goal states, attributing much eye-candy to
the iotd. At E You see another tower shooting, but also the "power"
influence map rendered in the radar. And I had to put at least one
development shot in, thats the attacker object being textured.
For the stuff you can't see, the game has music and sound effects, i
used SDL_mixer, and the music is ogg vorbis. I used my sadism library
for terrain a quad-tree CLOD terrain engine, cytisus for the xml,
errorhandling, GUI, texture management. I also used SDL, Freetype, and
it uses OpenGL for the 3D graphics.
Wallaba
P.s. If there are any similarities in the names in StarKraft, are
_purely_ coincidental.
(L) [2002/07/08] [ClintBrewer] [clint@haptek.com]
Hi Flipcoders!
I've been looking at the IOTD's for well over a year now, and they are
all inspiring, thanks for all the submissions in the past.
Here's some stuff I've been working on for [LINK http://www.haptek.com Haptek Inc.]
lately. Haptek makes a real-time 3D Avatar / character animation
system. We've got an activex control, or a dll you can use to add a
character to any program fairly easily. It only works on Win32 right now
though. So like, if you are making a database program and you are bored
to tears, you could add a haptek character window to it and have it
speak to the database users ;)
The top two windows are KATE (Kick Ass Talking Emoticon) It's a plugin
for the [LINK http://www.sonork.com Sonork Instant Messenger]. It uses the
Haptek player to render who you are talking to, and a SAPI TTS engine to
say what they type. If someone types an emoticon like :) or :( then
it will change the emotion of the character to be happy or sad. It's
using a DirectX 6 renderer so it'll work on default installs of more
recent os's.
The bottom 3 windows are probably more interesting you folks here. They
are a proof of concept of using the haptek api to animate a character in
a completely different renderer. I'm just using a simple Glut window
here, using only opengl. I used DevIL to load the texture maps, which
is a wonderful program, I'm definitely going to use it in my own
projects. I also recently upgraded my old TNT2 card to a GeForce4 ti
card so I just had to play around with some of the fancy things it can
do in one pass :)
The middle old guy with the lip gloss on is my first attempt at bump
mapping. It does both diffuse and specular using a gloss map to define
how much of the specular comes through. Our artist made the normal map.
notice the bone structure on the skull, that's all the normal map. it
really does look good when you are moving it around.
The bottom left guy is doing some toon rendering. I wasn't very
convinced about the coolness of toon rendering for a while, but it
really is neat to see it running in real time, I like it better than the
bump mapping. It's using the anisotropic rendering algorithm with just
a simple 1d texture for shading. then using another 1D texture to do the
black outlines using E dot N to determine texture coordinates.
And Last but not leas is the bottom right girl. She is rendered using
the fresnel term to blend an environment map over her. I'm working on
this mainly to get realistic looking eyes, but she looks cool encased in
plastic!!
One final note, in the opengl windows at the bottom I'm using the new
cg stuff from nvidia, it was fairly easy to get going, and while it
still needs a lot of work, it's pretty easy to work with. I set up a
system very similar to the D3DX Effects file format so that I could
quickly prototype different things in the opengl app. It paid off
really quickly, and I highly recommend adding some sort of more
"programmability" to your own engines, where you can specify alpha
blending, and multi pass rendering stuff in a text file.
Feel free to e-mail if you have any questions,
Best,
Clint Brewer
(L) [2002/07/10] [VilleKoskela] [villekoskela@yahoo.com]
Hello everybody! I decided to post a screenshot of the
game I've been developing lately. There should be
something simple in IOTD once in a while not to
discourage the beginners like myself too much..
Animated bounce is an Arcade volleyball clone. The
biggest difference between these two games is that now
all is 3d. Improvements to the old version include
(but are not limited to=) pretty good physics
simulations, accurate collision detections and
reactions and AI. You can give the ball a
spin and in that way trick your friend or the computer
opponent.
To get a bit technical I could say that the AI
basically calculates the landing point of the ball and
tries to move accordingly. The computer opponent
serves are recorded and stored in the serves.bri file.
I did the coding and Arttu Autio did the graphics and
the 3d models.
Animated bounce is freeware and you can download it at
[LINK http://www.kotinet.com/liisa.koskela www.kotinet.com/liisa.koskela]
(L) [2002/07/11] [LucasWalter] [lucasw@u.washington.edu]
In conventional movies, a planet or large space object just blows up in a
lame explosion with a ring that defies physical explanation racing away:
the explosions are so powerful that the planet/ large object is instantly
consumed. I'd much rather see oceans boiling off, shockwaves circling the
planet and continents buckling in their path, etc. It would be as if the
planet was ripping itself apart in an extremely detailed (and 'realistic')
way. This project is a step towards realizing exactly that sort of
carnage.
Having just ploughed through Alastair Reynold's Revelation Space the other
weekend, the important issue of realistic destruction was in mind, and
coincidentally the 'SpringSphere' project I was working on would under
some conditions look like a planet getting laid to waste with some kind of
horribly destructive weapon (relativistic projectiles? focused gravity
waves?).
Most of the work (spanning a couple of days in itself) stemmed from the
work I did with spring systems. The brown planet is comprised of two
layers of interconnected springs and masses, and each spring on the
visiblie surface is also a triangle edge, and likewise the springs are
connected in pyramid-like structures.
Here's a simplified picture, the lighter sphere is the invisible interior
label, dark purple lines are vertical springs connecting the two layers:
The explosion looks good at first glance, but across all these pictures it
doesn't change. It's just a white sphere inside of a transparent shell
that I placed on top of the initial disturbance. It would look cooler
expanding, drowning out the screen in a flash of brilliance and then
disappearing.
The starry background should probably be rendered invisible by the
brightness of the blast, but regardless the sky was generated from around
10,000 GL_POINTS in a volume surrounding the scene, randomized color, and
fog effects to make more distant objects dimmer. Instead of redrawing the
points every update, the stars are rendered to a skybox upon
initialization.
The extreme disturbance chronicled in these pictures is the result of an
impulse force imparted on a few the masses near the pole (where the
'explosion' white sphere is), causing oscillations that travel to adjacent
masses and eventually envelop the whole planet. It's more of a thin
rubbery egg-shell than a crust-and-mantle, so future improvements could
put additional layers of spring masses deeper into the core, and gravity
could be implemented. What would really complete the effect is if
overextended springs would snap and send chunks of rock off into space. As
it is, eventually the whole thing starts to collapse (and look less like a
destroyed planet) like a crumpled sphere of paper.
If you look closely at some of the pictures, you can see that the normals
are per-triangle rather than per-vertex, but there are so many triangles
it doesn't look too bad. Since every triangle has vertices that move
around semi-independently, the normals have to be constantly recomputed
(there's probably a less expensive way to do this), and averaging triangle
normals together would be much more time-consuming.
Every update recomputes the velocities of every mass, the forces on which
are determined by the length and orientation of the springs. There are
about 2*350*350 triangles, not a inconsiderable amount, but on my 1.5 Ghz
Geforce 2 system the bulk of time is spent updating the spring and masses,
of which there are about ten times the number of triangles. I could
probably gain a lot from using a more approximate square root method.
Updates take about 5 seconds, and the picture with the most extensive
damage took about a half hour to arrive at.
Lucas Walter
[LINK http://students.washington.edu/lucasw/]
(L) [2002/07/12] [MidnightSynergy] [mail@midnightsynergy.com]
Hello all,
this is a very silly IOTD, but some of you (we hope) will get a kick out of
it.
'When Clones Attack!' is the result of an attempt to, just for kicks, design
and write an entire game in just one day. The result is actually a fun
little diversion. Use the mouse and keyboard to control your ship, and
defend yourself against waves and waves of clones. How far can you get?
The game is free, only 400kb, and can be downloaded here:
[LINK http://www.midnightsynergy.com/clones/clones10.exe]
Some notes on the development:
- Programmed in Visual C / Direct X.
Given our experience with Intensity XS, the basic sprite and sound engine
was put together very quickly. No fancy functions were required.
Graphics were done using ArtGem (I guess we did cheat a little here, as we
re-used a few of the images from Intensity XS)
Sound FX and Music were taken from Sound Ideas CDs, then bent and
distorted as required.
To see how many people actually check it out, we also put in a link to our
website at program exit.
Have fun!
Midnight Synergy
(L) [2002/07/13] [GlynHumphreys] [GlynHump@aol.com]
Ethos combines a user friendly and powerful BASIC language with a breadth of
graphical and sound systems. Through its online user group ethos provides the
user with extensive data library to make a multitude of programs ranging from
games, educational to standard programs and tools.
Using an integrated windows editor, developing and debugging your programs is
made easier by using a project approach. Each ethos program contains all the
routines and data arranged in simple banks.
The advanced data manager allows visual management of program, sound, sprites
and image data banks. These use standard windows editing techniques giving
ethos an intuitive and user friendly interface. ethos supports most standard
graphic formats including animating GIF files
Integrated data viewers and editors for all data bank types and the ability
to dynamically extend the abilities of ethos as such as new data types supply
the user with an unlimited functionality in the development of their programs
and games.
With the direct mode, commands can be entered directly whilst editing or
debugging the program. This can be used to quickly see the effect or
positioning of an image, or to reset or report on programming variables. You
can even grab data to store in the databanks whilst your program is running.
An easy to use Windows style editor gives a familiar and functional text
editor. Using project based approach the program can be separated into
distinct routines. The projects allow you to export and import routines
developed by other users.
With a comprehensive support site ethos users are provided with a central
location for contacting other ethos users and accessing a breadth of
resources through the library. Users can even upload their programs and
graphics to share with other users.
Create fast paced arcade games using pixel perfect collision sprites,
multiple playfields, scrolling and digital sound effects.
Utilising DirectX the games you develop run seamlessly.
Ethos has been developed over a number of years and features some exciting
upgrading features. All the commands in ethos are specified in configuration
script files, this allows you to access functions within DLL's effortlessly.
All the tools and viewers are actually written in Ethos Basic, this makes
modify, improving and altering them very easy.
As the editor / program startup and shut down procedures are also Ethos Basic
.INI files, these can be upgraded to include any system that may be
developed, simply initialising the DLL's via the command interfaces.
Ethos shows what you can do in your home, the project has taken 3 years to
complete and has been completely funded off my own limited budget and has a
complete user support site and purchase license.
[LINK http://www.ethosbasic.com]
(L) [2002/07/16] [JamesMatthews] [jmatthews@generation5.org]
Thought I'd submit another IOTD, since this is actually fairly game related.
Here is a screenshot of the new version of A* Explorer. For those of your
that check Generation5, you'll know that A* Explorer allowed you to create
maps and step through them using the A*, among other things.
The new version of A* Explorer has a huge range of new features. Most
importantly though, it supports extensions through the use of DLLs. All the
A* heuristics are stored in a DLL and loaded in at runtime. In addition, A*
Explorer supports its own map extensions! You can create your own additions
to the maps to make the maps more interesting, or to emulate your game for
testing purposes.
The screenshot shows the following: a bitmap imported and converted into an
A* Explorer map, then a custom plug-in is used to add water to the map (it's
toolbar is the one on the right). The plugin then dictates how the A* should
treat the water. In this case, if its too deep it doesn't allow a path
through it, otherwise the depth affects the cost of the node.
Check out A* Explorer at [LINK http://www.generation5.org/ase.shtml]
Regards,
James.
(L) [2002/07/18] [DavidToyou] [david.toyou@libertysurf.fr]
This is a little program wrote for the Coding Party( or scene Event )
called VIP4 ([LINK http://www.PoPsyTeAm.org/vip4]) held in in France at the beginning of July. His goal was to annonce each compo and to make a default Screener when we ( organizers ) were too tired to pass demos.
It's a simple real time cube with blinn bump, blur and pseudo procedural water caustics.
If you want to download the Bin version go to [LINK http://popsyteam.planet-d.net/vip4/Launcher.zip]. I only test this version on a Geforce4 and GeForce3 so it's possible that you have trouble with other cards.
I forget i used Pixel and Vertex Shader intensively ( yes yes tes ) and that' why you must be equiped at least of a GeForce3... sorry.
That's all, see ya next year for VIP5 and have fun with this little program. If you want more explain about how i did it
you can email me some querstions YO !
PS : Yes it's a shame i rip the Microsoft cubemap, but i don't have the capacity to make cubemaps such this quality by myself i'm only an humble coder...
Middle pictures show the party place.
And yes i definitly have a bad english.
(L) [2002/07/20] [IronHelix] [ironhelix001@yahoo.com]
My pride and joy. After 7 days I've got it looking
this good and rendering at 40fps on a GeForce2 at
800x600x32. This coming from not knowing much about
large-scale rendering (I had previously only done lots
of small-scale stuff). Soon, it'll be going about
2-3.5x with optimizations, and have unlimited terrain
size. Stop by [LINK http://ironhelix.freeservers.com my website]
for .plan updates. I plan to be posting articles I
write about the design of the engine, general 3d
optimization, and more, for programmers out there who
want to achieve similar results in as short a time.
After learning what I did from this, by now I could
have had it optimized to the point I'm going to over
the next 4 days of work. I hope to impart some of that
knoweldge on you guys too.
Thanks,
-Iron Helix
(L) [2002/07/22] [LodeVandevenne] [lode@planetunreal.com]
TrixelLife is a lifegame in 3D, so it plays on a grid of cubes and each cube
can have up to 26 neighbours.
Game of life is a cellular automaton invented by John Conway in 1970, for
more info on this game go here:
[LINK http://www.math.com/students/wonders/life/life.html]. This page also
contains links to an extremely cool java applet of the 2D version of game of
life.
Trixel 3D is a raycaster I made few months ago, it uses a 3DDDA algorithm to
display a 64x64x64 voxel world on screen. It works fast on anything faster
than 1GHz but too bad most of the slowdown goes to the pixeldrawing, not the
raycasting, I still need to work on that. Sorry for the very small
resolution, by the way! Trixel is actually a contraction of Tri + Pixel, or
3-dimensional pixel. It sounded cool enough for a name for the "engine".
This suggest that the world is a 3D array, which is true. Each voxel can
have it's own RGB color and it's own shape (empty, filled, lifegame-cell,
random-noise cell, other graphical effect, blahblah).
It uses SDL for the screen and input. The camera supports 6 degrees of
freedom. Unlike regular 3D engines or even regular raytracers, this one
works faster if there are more cubes, no matter how complex the geometry is.
All that counts is that if there are more cubes, the rays will hit them
faster.
Because Trixel uses such a voxel world it was just begging me to make a 3D
life game of it, so here it is.
You can set the rules in an ini file, this means you can set how many
neighbours a living voxel needs to survive or die and how many neighbours an
empty voxel needs for a birth. A voxel can have up to 26 living neighbours
(that's simply because of the geometry of a cube grid), so there are a total
of 2*26 = 52 rules (instead of 2*8 = 16 for the 2D life game).
In the program you can place living cells manually and whenever you want
press the spacebar to run the rules once, or hold the spacebar down to run
them all the time. The rule calculation goes really fast, faster, for
example, than MSN Messenger needs to display one smiley!
By default the game uses the same rules as the 2D version (2 or 3 neighbours
for survival, 3 neighbours for a birth), but because it all plays in 3D now,
the result is completely different, in fact the living cells "explode" quite
easily, this created large 3-dimensional shapes. I didn't find a stable set
of rules yet... does anyone know some?
This is of course not the first 3D game of life out there, but in
combination with a raycaster I thought it was cool enough to post on
flipcode :-)
You can download the thing here:
[LINK http://www.perilith.com/~lode/trixel/Files/TrixelLife.zip]. Just unzip it
and run it. Please read the included readme first for an explanation on the
ini file and the controls. I may upgrade this game of life and Trixel
itself when I feel for it, maybe I'll even try to make other cellular
automata in 3D because next week I should receive Wolfram's book A New Kind
Of Science from Amazon.
Have fun,
Lode Vandevenne.
(L) [2002/07/23] [JariKomppa] [jari.komppa@kolumbus.fi]
What you're looking at is a collage of clips of screenshots from my entry to
the Ludum Dare's 48 hour game contest. My game is called 'orbital sniper'
and it can be downloaded from:
[LINK http://ludumdare.com/user/196/OrbitalSniper120.zip]
The package contains both binaries and full source. The game was written
using only SDL as an external library.
While I've received positive comments about the game I do not know, as of
this writing, how I fared in the competition, as the voting progress hasn't
even started yet.
In any case, when building that IOTD I noticed that for once, it was
difficult to build a screenshot that would explain anything about the game,
so I took several and chopped pieces out of them. The game runs at 640x480,
not 320x240 of those small shots; I just took the middle piece..
The game works by letting you zoom in and out of a 2d city map. VIPs (blue)
must be protected from threats (red). The different zoom levels give
different information, so the gameplay has a lot of zooming in it.
- Top left is the maximum out zoom; the blue box on top is one VIP, and the
red lines connect to couple threats that are heading his way.
Top right is mid-zoom, which now also shows all the innocent bystanders as
gray blocks, but no longer shows the connections.
Bottom left zooms in further, and the blocks change into targetting
brackets and teeny sprites of the pedestrians.
Bottom right is the maximum zoom where the player has some chance of
actually hitting someone.
The game has an interesting feel to it, especially on a big monitor.
The contest itself was lots of fun. I'm rather tired at the moment, after
crunching the game through the weekend and going to work right next
morning..
The competition page is here:
[LINK http://ludumdare.com/competition/index.php?viewcomp=2]
[LINK mailto:jari.komppa@kolumbus.fi Comments] on the game are very
welcome. If I make new versions they will appear [LINK http://iki.fi/sol on my homepage].
(L) [2002/07/24] [PyroArkham] [pyro_akm@hotmail.com]
Northern Breeze:
This is a game prototype finished in september 1999, and released since one
week.
It represent one year of 'week ends' work with two computer artists, one
programmer and one musician.
This demo would present the first (unfinished) level of the game.
Recommended configuration:
- x86 200 Mhz CPU or better.
32 Mb of RAM.
Direct Draw 5, 16 bits 8 Mb or more compatible graphics card.
3dfx Voodoo 1,2 or better 3 based graphic card with Glide3.x driver.
DirectX 5.0 or higher.
8x CD-ROM device or higher.
Direct Sound 5 compatible soundcard.
Mouse device.
Work on Windows 95/98/ME/NT/2K/XP.
Technical information of the 3d engine:
- Portable software render in 16 bits (65536 colors) using a scanline or a
zbuffer systems.
Hardware render using Direct 3d and 3dfx Glide 3.x:
Multiple materials rendering: flat,RGB gouraud shading, texture mapping,
additive transparency, color check transparency.
Management of 3d scenes with hierachised 3d objects.
Static lighting with projection of shades by ray tracing in a scene.
Rapid real time lighting.
Multiple graphics resolutions.
Animation of camera and objects in quaternions and morphing.
Skins in deformable faces or morphing system.
Very fast collision for actors / scene detection.
Hardware 16,24 or 32 bits rendering.
Displaying convex ngones polygons.
Bilinear filtering.
Portal visibility system.
Particules system.
You can find more information or download the game prototype here:
[LINK http://pyro.akm.free.fr]
(L) [2002/07/26] [MattCoombe] [info@3dna.net]
We're creating a freeware software package that seamlessly integrates personal desktop functions, web browsing, and entertainment into an intuitive and interactive 3D GUI that runs as regular windowed application.
3DNA software selectively scans the user's hard drive for content and applications which it places into a dynamic real-time 3D environment that can operate as a fully functional desktop. Folders, shortcuts, media files, web pages and documents are automatically grouped and positioned in a fully themed and customizable workspace. Everything from the skies to the textures on the walls can be changed on the fly, from presets included with the application or from assets created by the user. In essence it's a fully customizable and skinable environment which can change it's appearance to suit the user's style.
We're using the Shockwave 3D engine as our platform along with a serious amount of additional C code for all of the interfacing to Windows. We're also utilizing the Havok physics engine which we're currently using for player collision detection and to power our collection of toys and games that are featured in the various environments.
Shown here is our Sci-Fi environment called the BaseStation. It's
oriented more towards gamers and tech lovers as you may notice :)
We've also got another completed environment called the Villa
(Mediterranean style, sunlit environment) which can be viewed at our
web site along with more images of the BaseStation ( [LINK http://www.3dna.net/products/gallery.htm] ). There are many more environments in the pipeline too which we'll release as fast as we can make them!
We should be releasing a beta version perhaps as soon as next week.
Please come visit our newly completed web site to check out higher res images and other fun stuff :)
Matt Coombe
(L) [2002/07/27] [PhilippSpöth] [Philipp@Philipp-Spoeth.de]
This image demonstrates the post depth of field (Bukeh) filter I have been working on for a long time. It can be applied to normal
images by means of a depth map for distance information. A depth map can be generated by each raytracer easily. One of the
biggest Problems developing such an algorithm is how to deal with missing information. To calculate a correct depth of field effect
some information not present in a normal 2d image would be needed. Imagine the extreme case when a fence is in front of the
camera but that fence is so much out of focus it's hardly noticable in the resulting image. Now a perfect post filter would have
to completly make up what's behind that fence. Now of course my filter can't handle such extreme situations but it's doing pretty
good on the average. The great advantage is that it saves alot of time. A DOF blur generated by a raytracer can easily take a
couple of hours extra render time per frame. So having the possebilty to do this work in post production saves alot of time and
offers more flexibility.
The product is named Lenscare and more example images and animations
can be found here [LINK http://www.frischluft.com].
The Masarati was modelled, textured, rendered and copyrighted Elvis
Blazencic aka Lewis ( [LINK http://www.lewis.tomsoft.hr] ).
(L) [2002/07/28] [NickJohnson] [nick9402@hotmail.com]
This is just a simple graphing calculator I wrote to put the compiler I've
been working on to use. It will graph functions with one and two
parameters. Functions with two parameters are graphed in 3d with either
lines or points and can be manipulated with a pretty primitive virtual
trackball. Functions can be specified with C syntax or very simple math
notation ( f(x,...) = expression ). All the rendering is done in software,
so the quality of the lines is a bit poor.
I can't get opengl working on my computer, so right now it uses GDI with
device dependent bitmaps. It will try to switch to 32bit color if you're
not in it already.
The compiler is still pretty buggy, so if the program bombs, please send me
the code that made it crash and I will try to work out what went wrong.
More info and the executable can be found at
[LINK http://www.geocities.com/chsnick/Graph_Calc.html www.geocities.com/chsnick/Graph_Calc.html]. A couple other programs using
the compiler can be found at my homepage ([LINK http://www.geocities.com/chsnick/ www.geocities.com/chsnick/]).
Nick
(L) [2002/07/30] [LeonDroog] [info@leondroog.com]
The image of the day is a collage of some graphics of the have been working on.
It's a remake of an old megadrive game. It's a very unique game in the sense that it combines realtime strategy with shoot 'm up gamestyle.
Instead of using a mouse cursor to control the troops you use a transporter plane to place and reprogram units, the plane can also transform into a robot to join the fight.
"Rapid Aerial deployment" is programmed in C++ and uses the CDX library to display the sprites and background. Fmod is used to play the sound and music. The sprites and backgrounds are pre-rendered in 3d-Blender.
I'm currently working on some new levels and trying to get the multiplayer version working at a decent speed.
Sprite graphics are not state of the art, but they turned out fine eventually. The background in the demo is still a bit crappy, but i'm still working on good looking tilesets.
Since latency on the multiplayer is unacceptable, the demo is only playable in singleplayer and CPU vs CPU mode.
You can Download the game at [LINK http://www.leondroog.com]
(L) [2002/08/01] [Eric] [eric650@pipeline.com]
This screenshot is from a game I am making currently. It is a heightmap
landscape with a stretched texture and detail texture to make it look
nice. Dynamic lights at the camera location (which is why the closest tree
is lighter than the others) as well as inside the house in the
background. Despite the blue sky(skybox) it is a raining and you will
notice a few raindrops on screen :) The trees are just simple static
models. You can run around the landscape with full sliding collisions.
The engine I am using is TrueVision3D from [LINK http://www.truevision3d.com www.truevision3d.com]- it's a
very powerful engine with tons of features. Its free for noncommercial use
and otherwise inexpensive.
-Eric650
(L) [2002/08/03] [AndreasMüller] [andi@code-guru.de]
we released the final version of our small game DrHorst. It's a simple DrMario clone and runs under Windows. We were 2 programmers and an artist. We've been working on this in our spare time (about 10 hours a week) for a few month. You can download the binary and the source on my page
[LINK http://www.code-guru.de www.code-guru.de] (watch out,
site is in german :)
DrHorst shows that games not having fancy 3d graphics still can be a lot of fun.... :)
The game itself is written in C++ using Visual Studio .NET but we're currently thinking about porting it to linux
so, have fun with this
andi
(L) [2002/08/06] [MartinHoffesommer] [mh@soft-enterprises.com]
This is a screenshot from the upcoming game Highland Warriors. Yes, it is
a 3D RTS game and this is a real game shot - although most people probably
would play it from a different perspective. The engine used is called
ATLAS and has been developed in-house. A lot more information can be found
at [LINK http://www.highlandwarriors.com www.highlandwarriors.com].
(L) [2002/08/09] [RonFrazier] [ron@ronfrazier.net]
It's been 18 months in the making, but my IOTD is finally here. Kronos
Software proudly presents Miko & Molly.
First, lets get an overview of the game. Miko & Molly is a fun, challenging,
original, and completely non-violent level-based logic-puzzle game. Miko &
Molly takes puzzle games to A Whole New Dimension by taking this classic
game style to 3D. Now you can solve puzzles in the third dimension. Can't
get around an obstacle? Try to find a way over it. You get powerups such as
boots and bridges, which you must use to make your way through worlds filled
with teleporters, ice fields, water, stone blocks, and so much more.
Miko & Molly is fun for one player but is the first of its kind to offer a
unique 2-player mode. In 2-player mode, players work together to solve
puzzles as fast as possible. Competition will only slow you down.
Cooperation is the name of the game. Miko & Molly also saves your fastest
time for each level. Replay the levels over and over, trying to find the
fastest solution. Then upload your scores to the Miko & Molly All Stars web
site. The All Stars web site records the 3 fastest times for each level.
Now for the more technical info. It was developed in Visual C++. The game
isn't the most graphically complex: Single textured, flat shaded, rather
simple tile based board. A far cry from some of my per-pixel lighting
tutorials, but the game is meant to be very hardware compatible (runs on
almost any 3D card). A lot of work went into developing a pluggable
architecture. The graphics, audio, input, and math libraries are all
replacable. The game queries each plugin at startup and selects the most
appropriate one. The plugins indicate their relative level of performance to
the application (so a DirectX8 plug would say "pick me", and the DirectX1
plugin would say "pick anyone but me"). Initially I developed DirectX 8
audio and input libraries, but because of the pluggable architecture, I was
able to swap them out with DirectX 1 compatible libraries (for old
computers) without touching a line of code in the main application. It
currently uses OpenGL for graphics, and I haven't yet developed a Direct3D
plugin (though its on my list, possibly with a software rendering plugin). I
also haven't bothered with an SSE math library yet (and probably wont, since
the computers that support SSE are already plenty fast for this graphically
simple game). In order to implement these pluggable libraries, I of course
has to write an abstract wrapper API to which every plugin interfaced.
Graphics in the game are all TGA textures and Milkshape 3D models. Music is
done with midi files, and sound effects are done with wav files. The in
house level editor was a good 6 or 8 months or so of the development time,
but is nothing terribly complex. It is a GUI interface written in Delphi
which loads a C++ DLL that handles all the editing logic, and itself uses
the graphics plugin for rendering to a TPanel. A lot of the time was
actually spent handling all of the tile picking and texturing interfaces.
Miko & Molly is available for purchase from the Kronos Software as is a free
demo. Just go to:
[LINK http://www.kronos-software.com]
(L) [2002/08/10] [ThatcherUlrich] [tu@tulrich.com]
Here's a pair of screenshots from my Chunked LOD terrain demo. My
goal was to create a hardware-friendly LOD method without too many
compromises. It turned out pretty well. The system has high triangle
throughput at high framerates, low CPU overhead, works within a
guaranteed max pixel error, and has full geomorphing (no pops). The
number of triangles rendered is higher than with a primitive-level LOD
scheme like Lindstrom-Koller or ROAM, by 1.5-2x or so, but the CPU
overhead is much lower. The view above is scaled down from a pair of
1024x768 screenshots. The window contains ~300K tris, and renders at
around 27 fps (8.6M tris/sec) on my machine (1GHz P3, GeForce2Go).
The max pixel error is set at 2.5. Better video cards provide higher
framerate.
Other features:
- Texture quadtree tiling: in the image above, the source texture is
32K x 32K texels. It's being rendered using vanilla OpenGL texture
calls, using a couple hundred active quadtree tiles which are each
128 x 128.
Background paging: the demo can work off of large geometry and
texture files on disk, only pulling in the pieces that are necessary
to draw a particular view. In the image above, the dataset
represents several GB of uncompressed data. The original
heightfield was 16K x 16K x 16 bits, plus the texture is 32K x 32K.
After preprocessing, it's about 500MB on disk (including JPEG
compression of the texture data), while the demo runs within about
100MB of RAM. Most of the paging work happens in a background
thread, to avoid hitches in framerate.
The code is all public domain, so you are encouraged to do whatever
you want with it. The precompiled demo runs on Win32, but the code
also compiles and runs under Linux. Try it out, and send me bugfixes!
The homepage of the project is:
[LINK http://tulrich.com/geekstuff/chunklod.html]
There is more documentation there, and links to the downloads and
SourceForge project.
(L) [2002/08/13] [DevonStrawn] [strawn@gte.net]
This is a lossy image compression program that uses wavelets.
It was written for the final project in a Fourier series and wavelets course.
The program achieves compression of up to 20% with acceptable loss of detail.
This scheme ensures that low-frequency features are compressed before high-frequency features.
This way, fine details are preserved even at high compression rates.
Here's how the compression algorithm works:
- Original image is decomposed using Haar wavelet to generate wavelet coefficients (the wavelet image pyramid)
- Wavelet coefficients are culled based on threshold value (this is why the compression is lossy)
- Remaining wavelet coefficients are encoded into a tree structure (the zerotree)
- Zerotree is compressed using Huffman coding
And decompression applies the same steps but in reverse.
One of the benefits of wavelet-based compression is that the process can be treated as a pipeline.
So we can switch out different wavelets (e.g., Haar, Daubechies, etc.) without needing to adjust any other part of the pipeline.
Or we could use an adaptive arithmetic coder instead of a Huffman coder.
The Haar wavelet is a good starting point for working with wavelets.
It's a lot simpler to work with than higher-order wavelets and doesn't require special consideration for nasty edge effects.
Click [LINK http://home1.gte.net/strawn/Graphics/ImageCompressionWithWavelets.html here] for a downloadable executable and an article with more information about the compression algorithm.
And check out my [LINK http://home1.gte.net/strawn/Personal/ArtAndTextures.html textures page] to download the textures used to generate the images above.
(L) [2002/08/14] [MarkusKark] [markus_kark@hotmail.com]
This project is my first try towards game programming (normally i'm a 3D Game Artist). My goal was to make some sort of 3D-Pirates-Multiplayer-Battle Game.
It started all on christmas evening last year, when my neighbour
mentioned: "Hey, battleships in 3D would be cool". After working the
whole night, i showed him an animated ocean on the next day and he -
being a 3D Artist - came up with a small pirate ship. I wrote an
importer and finally that little ship was floating on the waves.
Later i changed the ocean waves animation from simple sine/cosine blending to FFTs.
By the time i added a small particle system based on point sprite rendering (the smoke clouds from the cannon) and some ballistic "physics" for the cannonballs. Then came the great depression - the multiplayer part. I had no idea where to start and read a lot about network programming. In the end, everything is built upon DirectPlay Tutorials and some advices from forum posts. I hope i will find the time to turn this 'not-really-game' into a 'little-game'... =) especially the network code isn't all but optimized....and some minor bugs...errm, a LOT of minor bugs to be honest...
Some Techs:
- Script parser for all game objects, particle FX etc.
imports 3D Studio MAX ASE Files for models
Multiplayer (Client/Server) based on DirectPlay
ocean waves based on the Gamasutra article about Realtime-Water-Rendering and Animation (FFT)
If you're interested in the source code or have some comments or ideas
or just wanna write something, please send an email to [LINK mailto:markus_kark@hotmail.com markus_kark@hotmail.com].
Markus Kark
(L) [2002/08/17] [ThiloHardt] [hardt@hess-gmbh.de]
The picture above shows two screenshots from my first self-made-3d-game. Yehaw! The first one shows the players spaceship navigating through asteroids. The other one shows the spacship crashing into an asteroid creating a giant isotropic explosion. The game includes a simple collision detection, particles, 3D Meshes (3DS imports), light, bitmap font and don't forget this amazing skybox with twinkling stars :)
I couldn't imagine that i'll write an 3D Game - or better said a Demo - two weeks ago. I never had anything to do with OpenGL. I already had four years experience with Delphi, but more with databases and networks.
Two weeks ago i had found GLScene (glscene.org). An OpenGL library for Delphi. I know DelphiX, but it was to complicated. GLScene was different. In only 10 minutes you've got great results.
I started a little game. Nothing worse. I thought i could code the Skimmer sequence from Space Quest 1 - The Spinal Frontier. You know - this one where Roger Wilco drives this Skimmer in the desert heading for The Ulence Flats. He must evade the rocks.
I already had the landscape (flat Sprite with an texture), a skybox
and an selfmade Skimmer with a cool shadow. But I found an 3D Mesh of
an more cool Wing Commander spaceship called Phantom - with texture!!!
[LINK http://www.wcnews.com/WCMDF/Ship_Database/Confed_Ships/index.shtml]
I deleted the old one, deleted the landscape and resized the skybox - painted it black. I was in space now. The flying around asteroids replaced the rocks. The goal of the game changed. You must fly welfare through the asteroid field and find the Voyager 2.
Game: [LINK http://www.hardtware.de/software/asteroids.zip]
Source: [LINK http://www.hardtware.de/software/asteroidsource.zip]
(L) [2002/08/20] [NielsdeWit] [niels@breezahgirls.net]
I recently created a fairly nice particle system, and since i'm getting a bit tired of seeing dull looking games
up here almost each and every day i decided it was time to post something different ;) So here it is..
In case you're interested, it's actually really simple. One just takes an ordinary type of particle system (this one being
based on emitters spitting particles in certain or random (tweakable) directions, influenced by gravity), then sets up
a lot of them, let's say 16.000 (at least). Next step is rendering everything to a texture, i used a 512*512 32-bit one, which
seems not to kill my GPU all that much (Gf2MX). Each frame you draw the full particle system, and afterwards draw a view-port
filling black plane with the alpha set to something like 12 (on a 0 to 255 scale). Voila, motion blur. This leaves nice trails.
Fiddling around with the particle size, position, type of motion, blur
factor and other things gives fairly to really nice results.
I know that the implementation isn't really efficient for smaller particle systems (where you're better off just overdrawing a few
particles to the actual render target), but for somewhat impressive effects this might be applicable.
What the hell am i ranting about, this function ain't anything near advanced, it just looks okay. But hey, i "had" to write
something in order to get this image thru the preselection ;)
Sources and help on other topics can be obtained thru: [LINK mailto:niels@breezahgirls.net niels@breezahgirls.net] ;)
Cheers,
plek/Damage
(L) [2002/08/22] [StéphaneRedon] [Stephane.Redon@inria.fr]
This image is another snapshot of the interactive rigid body simulator I've developped during my PhD.
The collision detection algorithms used in the simulator are continuous : as opposed to most discrete collision detection methods, which detect objects interpenetrations, the present method uses an arbitrary in-between rigid motion to interpolate the initial and final object's positions and compute the time of first contact. Consequently, no interpenetration ever occurs, and no collision can be missed.
In the example above, the engine is precisely (ie without any interpenetration) and interactively removed from the car door.
Small yellow spheres materialize the contact points (either vertex/face or edge/edge).
The paper about the continuous CD algorithms can be found at
[LINK http://www-rocq.inria.fr/~redon] (paper from Eurographics)
Some movies of interactive sessions can be found too.
Regards,
Stephane Redon
(L) [2002/08/25] [WillMcGugan] [will@willmcgugan.com]
This is Net Chess Pro. I first started it over 2 years ago, forgot
about it, then picked it up again about a year ago. It's a part time
project, with occasional evenings and weekends spent hammering away at
it. I had intended to wait till I had a beta for you guys to download,
but I've recently found myself on the job market again and I thought
this would be a great opportunity for self promotion. I'm looking for
work as a programmer in Scotland, preferably Glasgow or a home working
position. My CV is on [LINK http://www.willmcgugan.com/]
With Net Chess Pro you can play email games, network games or against the computer using any engine that supports the WinBoard protocol. The top screenshot shows Gnu Chess kicking my ass (not that I was really trying). Possible moves are shown by ghosted pieces, a useful feature for beginners. All moves are rule tested - it wont show you moves that leave your king in check, or put your king in check.
The app can send email moves and a text message as a small attachment. The attachment file-type is associated so that double clicking it will launch the game. Network games have a unique (as far as I know) feature. As well as a chat-box, players can annotate the board by drawing on it with the mouse, a kind of shared white-board. You can use this to discuss moves more easily, or play hangman if you prefer.
Moves and other game events are announced with a pre-recorded voice. I have my own voice sampled and 2 others for those who can't understand my Scottish accent (you should hear me trying to say 'en passant'). I've made it as simple as possible for users to add their own voices to the game; basically voices are stored as a WAV file per word.
The graphics are rendered using OpenGL, it doesn't use any extensions and will break textures up so that it will run on lowly hardware. The board scales to accommodate the window size, and each piece has an alpha channel for anti-aliasing and effects like drop shadows. Again I've tried to make it as simple as possible for users to supply their own graphics. I did the board you see myself - not bad for programmer art but even a trained chimp can render a chess board :P.
The second screenshot is the front end. It's a page of dynamically created html that displays things like the tip of the day, statistics, saved games and such. It's a very flexible system that makes it easy to create a user interface. The html contains specially formed links that send events when clicked - so that a link can select menu options. On top of the second screen shot you can see one of my realtime bump-mapped splash screens. What can I say, I'm an old demo coder ;)
The app was written with the help of wxWindows. I can't recommend it enough, my previous GUI applications involved blood and tears, but this was relatively painless. WxWindows can do a heck of a lot more that windows and dialogs, I would even consider using it for less GUI oriented games.
I will probably sell Net Chess Pro as reasonably priced shareware with
a cut down free version so that you don't need two registered copies
to play with a friend. Publishers, if you are interested please
contact me on [LINK mailto:zenadsl2039@zen.co.uk zenadsl2039@zen.co.uk]. Also if you would like to contribute a voice, or board (in return for a free copy and mention in the about box) please get in touch.
When it's ready, I'll post a beta version on netchesspro.com (nothing there at the moment). Before anyone asks, I do have plans for a 3D version but the 2D game is a priority.
Will McGugan
(L) [2002/08/26] [IstraSoft] [istrasoft@hotmail.com]
Here's two screenshots of a 3D browser I released in july. It supports 3DS,
DXF, ASC, OBJ, LWO, and T3D formats and is mainly optimized for speed.
Average load times on my Duron 1GHz - GF2 MX400 64MB DDR :
ASCII files (DXF ASC OBJ T3D)
70 000 polygons / 40 000 vertices : 3 seconds
50 000 polygons / 150 000 vertices : 2 seconds
15 000 polygons / 60 000 vertices : 0.5 second
Binary files (3DS LWO)
120 000 polygons / 70 000 vertices : 2 seconds
50 000 polygons / 30 000 vertices : 1 second
16 000 polygons / 30 000 vertices : 0.5 second (second screenshot)
Other 3D borwsers tested with my most big models load them in minutes or
just crash ...
This project will be continued and extended. My ToDo list for Browz3D v2 is
already very very long, so feel free to try my app and send me
feedback/suggestions to improve it.
Download page : [LINK http://www.istrasoft.net/appbrowz3d.html]
(L) [2002/08/27] [SachinBadiani] [kajol_is_sexy@postmaster.co.uk]
This is a third year Computing Science project at the University of Glasgow ([LINK http://www.dcs.gla.ac.uk]) that a group of us five students did. Technology such as graphics orientated systems from Silicon Graphics fail to replace the traditional cartoon animator or automate to a reasonable degree the noticeably expensive process of in-betweening. It is the particular drawing style of each cartoonist that characterizes a cartoon and also poses the main problem in automating the cartoon animation process. This project intended to address some of these problems and aimed to provide "procedural libraries for cartoon animation".
It consists of the following components:
- A User Interface layer.
A Language layer to allow users to specify scenes - the Cartoon Scripting Language (CSL).
An Engine layer - a set of animation libraries generating images representing animation effects specified by the user.
We used a spreadsheet interface for graphical objects as devised by Marc Levoy's paper (Spreadsheet For Images, SIGGRAPH 96). Each column represents a frame and each row represents a layer. The user types in code in our custom language, CSL, presses compile and images are rendered onto the spreadsheet in 2D. One can make play the individual frames in the video player.
Code parameters include the number of particles wanted, what their velocities are, what colour scheme to use as each particle's life changes. Paths for particles can be made, and wind and gravity can affect particle movement. Such standard effects possible are fire, rain, smoke, and as shown above, water spray.
We used Java SDK 1.4.0 to build this project. Video files are saved in one file containing PNG byte arrays. This allows huge savings in disk space, and since PNG is a loss less format, you do not get the artefacts that are apparent in compression of cartoons. A video of length 61 frames takes on average 400KB. We did not use the Java Media Framework since there is incompatibility between it and Java SDK 1.4.0.
At the moment, one member of our team is redesigning the system so that the interface is in applet form on a client and computation and file IO is done on at the server end. The Faraday Lab in our Computing Science department will release the code as open source in the not so distance future?..
(L) [2002/08/31] [Mastaba] [mastabaprime@hotmail.com]
I was playing around with double sided alpha testing, i.e. alpha tests of
the form min<a<max, and this is the result. Of course most video cards
(all?) do not directly support this kind of alpha test. By using the stencil
buffer to hold the results of one portion of the test, the complete test can
be effectively emulated with 2 passes on not only current hardware, but also
older video cards. I have this singular effect demo with source code
available at [LINK http://bellsouthpwp.net/d/f/dfrey69/DoubleSidedAlphaTest.zip].
The demo uses both GLUT and DevIL and are not included. I believe I was
using version 1.6.5 of DevIL, and I have no idea which version of GLUT I
used since the glut32.dll properties doesn't show a version tab, I assume
its 3 something.
I should have another IOTD in the near future of a game I am about to
complete. :-)
Until then,
David Frey
a.k.a Mastaba on the flipcode boards
(L) [2002/09/01] [JamesLBoyd] [james@hi-toro.com]
This is a little system I put together for fast rendering of mirrors for
(limited circumstance) in-game use. It's very simple indeed, but I don't
recall seeing anything quite like it until the shots of Super Mario
Sunshine, so I just had to figure it out (I've been trying for ages, and
finally got it just about right -- it's the positioning/zooming code that
was that hard part).
Each mirror has an associated camera, which is positioned 'opposite' the
main viewing camera behind the mirror, and simply renders its view to the
back buffer. This is then copied into the mirror's texture. Mirrors only
render when the main camera is within a certain range, so they only affect
frame rates when you can see them. There are a couple of limitations:
- You can't have anything behind the mirror; not a problem if your level is
designed around this (eg. a single-sided wall behind the mirror is fine,
since its back can't be seen by the mirror's camera);
It's not 100% physically correct, so you get 'flattening' at shallow
angles (which is avoided by the tried and tested method of... limiting where
the player can go :)
It's limited to the size of the display mode here, since it renders to the
back buffer (eg. asking or a 512 x 512 texture on a 640 x 480 screen will
fail, though this example automatically creates a smaller texture). Bear
this in mind when running the demo.
Anyway, it runs very well on modern machines (eg Geforce2/3 and up), and not
too badly on low end (ATI Rage). It was developed on an ATI laptop, where it
ran quite acceptably, but I've put frame-tweening code in for this public
release, so it skips frames there :)
Try it out here...
[LINK http://www.hi-toro.com/misc/realmirrors.zip] [640k]
(Use cursors plus A and Z to move around; the mirror will follow you. Click
and drag the mirror to move it manually.)
Mail me if you need to know any more about it!
(L) [2002/09/02] [AndyOwen] [ragonastick@whale-mail.com]
This is a screenshot of Emoticon, an RTS I'm
developing. The game itself is a fair bit more
tactical than other RTSs. The army given to you
at the beginning of a level will usually be the
same army you finish with, I've taken out base
building and resource management, which changes
the way you play. I found a lot more focus was
put on protecting individual units, and I think
I like it that way.
Techically, it isn't feature rich, the
pathfinding will navigate a group through a maze
without any troubles, the game doesn't crash on
this computer and runs at a nice frame rate on
this computer. It uses DirectDraw7 for graphics,
and this version doesn't have any sound or
music. It was developed in VB, so if you want to
test out the alpha, you'll need the VB runtimes
(download link at my site)
What is planned:
- Smarter enemy AI: the current AI is ok, but
not great. It mainly acts on a stimulus response
type system, and never has any initiative to
attack the player out of the blue. It knows how
to retreat, but it would rather die, so it never
does :)
Smarter unit AI: I'm going to add in a few
extra orders you can give the units (currently,
they can move, attack, pick up and put down).
I'm going to experiment with something so you
can 'draw' a formation for the units to get in
in realtime.
Music and sound: Sound adds a great deal to an
RTS I've found, the feedback it gives is really
useful. And I fancy a touch of music here and
there :)
More units and weapon types. There are a
couple of units in the game which you won't see
in the alpha, because their special-ness hasn't
been coded yet. I'd like to have some area
effect weapons and maybe some less conventional
weapons. I made the game in the
graphical 'style' it was in so I didn't have to
stick to realism, so I might as well use this
opportunity :)
Anyway, the Public Alpha and more screenshots
are available here:
[LINK http://emoticonvb.cjb.net emoticonvb.cjb.net]
(L) [2002/09/04] [IainFraser] [WizHarD@hotmail.com]
I made this engine a few months ago and dropped it as I have now got a new
job & school. But I thought this graphics engine should be shown to the
world so here it is. Now the specs:
This a mode 7 engine such as the ones used in the orginal super mario kart
etc. It gives the sense of projection in 2D using line segments & scaling
techniques. This engine supports movement along all 3 axises so in a sense
it is 3D but notice that the levels are actully flat 2D planes.
As my first ever graphics engine I found this really hard to create.
Espcially getting a decent speed on PCs ( pentiums & 486 ). The reason the
super nintendo could do it so fast is because it had built in hardware. The
code features inline assembly to speed it up.
On the image above you see a few screenshots of the graphics engine and a
few karts driving around. It also shows a complete working MFC level editor.
I don't think I will try to make a game out of this engine. But if anyone
whould like the sourece code & the level editor please send me an email to
Iain Fraser @ : [LINK mailto:WizHarD@hotmail.com WizHarD@hotmail.com]
PS this engine uses DirectDraw 7.0 , supports DirectInput and uses joysticks
& keybaord, It also has DirectSound code which at the moment has a few
engine sounds getting louder when a kart gets close preety primitve to say
the list and a fancy UI.
(L) [2002/09/06] [PyroArkham] [pyro_akm@hotmail.com]
This is a game prototype finished in may 1998, and released for the first
time since august 2002.
It represent about six month of work by the Isla Dragon team (12 peaples
worked on it).
The engine was a mix beetween two differents 3d technologies merged
together, writen by two programmers.
Recommended configuration:
- Pentium 200 MHz processor or higher
32 Mb Ram internal memory
Windows 95/98/ME/NT/2K/XP
DirectX 5.0 or higher
8x CD-ROM player or higher
3D accelerated graphics card DirectX compatible
Soundcard with support for DirectX
Technical information:
- Hardware render using Direct 3d.
Multiple materials rendering: RGB gouraud shading, texture mapping,
additive transparency, color check transparency.
Management of 3d scenes with hierachised 3d objects.
Animated materials.
Dynamic and static lighting with projection of shades by ray tracing.
Animation of hierarchised objects in quaternions.
Very fast collision for actors / scene detection.
A basic AI was written for the scelettes ennemies.
Multi channels soundtracks.
You can find more information or download the game prototype here:
[LINK http://pyro.akm.free.fr]
Pyro Arkham
(L) [2002/09/10] [RichardNorton] [richard@arachnia.dynip.com]
This is a screenshot from the game I'm currently developing called Star Torn.
It depicts a view from the edge of an asteroid field looking out over a
nearby planet.
Star Torn is an RPG Space Sim developed with my own custom OpenGL engine and
runs under both Windows and Linux. The objects are shaded using text scripts
which are compiled at run time. This way, complex effects can be layered
together very simply (like the clouds that rotate independently of the
planet), and artists can quickly change and produce effects without any prior
knowledge of programming.
The planet halo is simply a ring which uses a colour for the inner ring
vertices which is modulated by the position of the sun, and fades to
transparent black for the outer ring. The backdrop is actually a dodecahedron
which can have textures painted upon any of its sides.
Star Torn still has a way to go before being finished. So now i will utter my
shameless plug: I'm looking for some good graphics artists (3D mesh,
textures) and possibly another programmer to help finish off the game. If you
are interested or have any questions, you can contact me at
[LINK mailto:richard@arachnia.dynip.com richard@arachnia.dynip.com]
You can also find more screenshots, a demo and information at
[LINK http://www.arachnia.dynip.com/startorn]
Richard Norton
(L) [2002/09/11] [CarstenColditz] [cc1@inf.tu-dresden.de]
These 2 Screens are from a beta-version of a landscape/plants-population
viewer. The viewer is a part of a project called "Lennè3D". Within the
project, we will develop an interactive modeler and viewer for modeling and
rendering complex virtual landscapes with high-detailed plants-populations
in realtime. We use our own dynamic LOD-algorithm to handle the very complex
geometry. Also we use standard methods like billboards, but the user can see
every leaf or branch of every plant if the distance between the camera and
the plant is small enough. So we use "real" geometry-models. Actually, our
viewer can handle scenes for example with 100.000 plants (every plant
consists of 3.100 triangles) at 6-9 fps (P4,2.4GHz,512MB Ram,GF4) or with
1.000.000 plants (3.100 triangles/plant) at 1-2 fps.
Further informations to the whole project will be found at: [LINK http://www.lenne3d.de www.lenne3d.de]
At this point of development, shadow-mapping is not yet implemented.
Greetings, Carsten Colditz
(L) [2002/09/12] [KlasM.Auvinen] [Magnus.Auvinen@o3games.com]
I was thinking about stencil shadows and how ugly the sharpness of them is.
I first came up with an Idea how to make them soft by rendering multiple
shadow volumes. That wasn't that great so I came up with a new idea so I
downloaded an example from nVidia that did stencil shadows and modified it
so they became soft and nice. The drawback is of course performance. I will
workout some of the glitches and increase the performance, and then I will
release the full source of this method.
// Klas M. Auvinen.
(L) [2002/09/15] [WayneMike] [wayne4@blueyonder.co.uk]
This is a screen shot, from my recently completed screen saver project.
It can be downloaded from [LINK http://www.scene.org/file.php?file=/demos/groups/fluid/fld_sparcs-final.zip&fileinfo]
The screen saver is 100% software rendered, Each particle system has 32,000 particles in it, a maximum of
2 particle systems can be displayed at any 1 time.
Screen saver settings include box-bluring and particle system color selection.
Hope you enjoy the screen shot, and screen saver.
Wayne Mike
(L) [2002/09/17] [MarkkuRontu] [mrontu@cc.hut.fi]
My (hopefully) final year at the university begins soon and it's
time to reflect what I have managed last year so here's my first
contribution to the IOTD. I've been following this site and the forums
quietly for almost two years now and I've mostly liked what I've seen.
All the images I selected are related and starting from up left there
is a space combat simulator I wrote for a logic programming course with
the actual simulation and AI logic written in Prolog and the simple
result viewer written in Java. This was to test whether it's feasible to
do such simulated combats. Later it can be built into the game
(with better graphics etc.). Sort of like what's done in VGA Planets
but more complicated. It's good to remember that even C++ with its immense
arsenal is just one tool in the toolbox.
To the right is a snapshot of some logs of a ground combat simulation
I'm working on for the same game. Poor Sumerian spearmen warbands
getting beaten by US infantry companies.
Next is the result of a whole year content production course which was
about game production last year. Main features of this technology demo are
custom built user interface engine (C++, SDL, OpenGL, etc. so it's fully
portable) and lots of code generation to interface with databases. This
is what the main interface of the game would look like and inside the
combat engines do their work.
Last but not least is another part of the user interface, namely viewing
the actual planets in the solar systems. I had to test if a full 3D UI
(sort of like in the old UFO-games) would be playable so I hacked up a
quick prototype. The beast also routes with a templated A* I whipped
together for a knowledge engineering course during the spring. Better
views available from my page.
Well that's enough of my last year covered, rest you can spot from my
pages :) (except for a virtual reality application made for a CAVE-like
system). If this brief intro of my works left you bursting with
questions, please go ahead and use either the Random Bits or mail me if
you like. More screenshots (and downloadables) available from my site.
- Markku Rontu aka Macroz
[LINK http://www.hut.fi/~mrontu/]
(L) [2002/09/18] [B_old] [b_old@t-online.de]
This picture shows a scene of a technology-demo I'm writing. It is the
first C++ -project ever I'm doing and the game it is supposed to be
when finished will be strictly top-down. The (yet to be-) engine uses
the [LINK http://grim.10tons.org/ Grim 2D-API], which I want to recommend
at this point, although I know that most of you people are into 3D.
In this scene you should see about 4096 particles.
The player can move in any direction and turn by 360 degrees.
The camera can be moved seperately and zoom in as well as out.
The artwork is done by myself and are just ideas and will hopefully
replaced by those of a more skilled artist later on the process. And
this is the main-reason I am posting this.
If you are interested in making 2D art, including animations, for a rather gory action game please let me know.
The project still is very young so your ideas are greatly appreciated and will surely shape the game.
(There is also question I would like to a programmer with more experience in real-time rendering than me)
So if this sounds cool and interesting please let me know!
(L) [2002/09/20] [TomLee] [tomlee@bigpond.net.au]
This image is from a remake of the game [LINK http://www.scorchedearth3d.net Scorched Earth 3D] being developed as part of an assessment
for my Diploma of IT (Software Development) course at [LINK http://www.qantm.com.au QANTM] here in Brisbane, Australia. The course itself has
a focus on games development and has both a multimedia and a programming
stream. Of course, I'm in the programming stream which explains why the art
is all horrible-looking :)
The screens show the state of the game after about a week's coding. The
entire assessment itself involves (as mentioned) a remake of Scorched
Earth - but it's not just programming. We have to go through the whole
requirements gathering and design phases, even going so far as to set
milestones for ourselves and attempt to keep to them as best we can.
At current, much of the game's logic is in place and it plays fairly well -
if a little fiddly at times. The camera system is kind of horrible at the
moment, but I'll be straight into that next week.
Some interesting notes:
- Engine ('Quill') developed by myself using MSVC++ 6.0 and DirectX 8.1.
Audio support via FMOD is planned. I have MSVC .NET, but no plans to port it
over
at the moment - maybe one day.
Structured config files in the form of non-strict XML. I use Expat to
parse the XML elements into heirarchical trees.
Light mapped, textured height maps for levels. Sky box present to enclose
the game world.
Light map actually moves over the terrain slowly, gradually changing
direction, giving a groovy cloud-cover effect. In the screen shots, you can
see
the light map best in the top right image.
Verlet integration used for bullet movement - bullets can bounce off the
side of the playing field.
Smart pointers used extensively - Quill's resource managers actually rely
on smart pointers almost exclusively.
Microsoft .X meshes
Where possible (nearly everywhere), .png images are being used as
textures.
Terrain damage. Currently only partially implemented. The reference
implementation I saw (by one of my instructors, Christian Schladetsch)
actually
recalculated the normals after each bit of damage to the terrain to
better show the shadows of damaged terrain. I've got another idea which
involves
simply dropping the diffuse color of affected vertices (calculated by
distance from the point of impact) by a small amount each time. Still not
totally
sure if I'll go with this method tho.
Menu system implemented using Quill's excellent menu base class - all
menus derived from this class need only to define how to draw a menu item
and
how to interact to mouse inputs, which means you can easily swap a 3D
menu system with a 2D one or vice versa - it's hard to express how easy it
is to
implement new menus, but take my word for it :P
In two weeks time this is due to be completed, so I may post again if the
appearance of the game improves enough to justify another post :)
Tom Lee
(L) [2002/09/22] [ChristianKlein] [klein@vts004.atlas.de]
Here is a screenshot of my Build-Engine... It loads a good old Duke
Nuke'm 3D map and tries to render it via Direct3D8. Still
some problems remain, some texture-corrdinates are still calculated wrong because of the strange texturestreachfactor in Duke.
Some other probs will appear when I try to render a sector (a room in the build-engine) that has a sector inside itself. That
is used in the game extremely often. And currently I don't know how to split the floor and the ceiling into polygons since the engine
only delivers me information about the walls. But I had reached my main goal with this small piece of software, I can load and render
the old Duke Maps.
The screenshot was rendered on my AMD XP 1600+ with as you can see my
GeForce 4 TI 4200. I render the walls as two polygons
which is not very effective thats the reason why the framerate is not very high for so simple 3D graphics.
Chris.
(L) [2002/09/24] [ArasPranckevicius] [nearaz@centras.lt]
Inspired by [LINK http://www.indiegamejam.com IndieGameJam], a group
of Lithuanian game developers organized similar event in Lithuania. The
event idea was: we give you the "engine", you come and have two days to
write games with it. The whole thing was called Lithuanian Game Development
Jam-Session (or LTGameJam), and (hopefully) it will be similar events in the
future.
In the image are screenshots of 6 games that were made during the Jam (also
there were 4 unfinished games).
More on the LTGameJam is at [LINK http://www.anycities.com/nearaz www.anycities.com/nearaz] - the
engine, the games, etc.
Aras Pranckevicius aka NeARAZ
(L) [2002/09/25] [ThomasRued] [rued@digitalarts.dk]
This image shows our latest real-time visualization of architecture. The building itself is a Danish credit association located in Copenhagen. It was originally modeled in FormZ by the architects but we exported it to 3D Studio Max where we used finalRender to bake the lightmaps, and QuickUVW to do the actual UV mapping. The camera where also animated from within Max and in the end the scene was exported from Max and loaded in our real-time system.
The topmost pictures show the building from the outside. A Vertexshader has been used to do the reflection in the windows using a spherical environment map. Approximately 200 digital still pictures was taken from the real building to construct the textures.
The next row of pictures shows the building from the inside. Left are the big entrance stairs, and right are the lifts to all the floors.
The next row shows some of the interior. The left picture show the local auditorium where the original presentation was shown on a big screen, and the right picture shows a water fountain.
The bottom pictures are made for easy compare. The left image is a real shot from within the actual building and the right is our rendering. Notice the special "yellow" and "blue" shadows around the pictures - this is the new patented ColorCode 3-D encoding which gives you true stereoscopic depth in full color. We implemented the basic system in hardware by using pixelshader 1.1 on GF3 class hardware and did a full implementation of the system by using either a multipass rendering technique on the GF4ti (ps 1.3) or single pass on Radeon 8500/9700 class hardware (ps 1.4).
The program itself requires DX 8.1 - it uses around 100 MB of texturemem which is compressed at loadtime so the actual run-time load and texture swapping is minimized, the downside however is the pretty long loadtime.
The model itself uses approximately 100k tris.
You can try it out yourself by visiting [LINK http://www.digitalarts.dk Digital Arts] for a movie and/or executable, ColorCode 3-D for some special viewers, an encoded movie and more information on the new fullcolor stereoscopic system. Detailed information on the modeling can be found by visiting Firsteye which is the company of Thomas Suurland.
Hope you enjoy it
Thomas Rued
Digital Arts
(L) [2002/09/26] [Fronc] [fronc@gdirectx-dev.de]
We are a German hobby game developer-team and want to send you a screenshot
from our game 'kampf dem mobbingclan'. Its released and you can get it
from: [LINK http://www.ec-team.net/kdmc/kampf_dem_mobbingclan_v10r.zip here].
'kampf dem mobbingclan' is an arcade-game. You have to help the little
delphin mobbi, who is hunted by a group of fish. You have to hurt the fish
or attack them with bombs, balloons...or make them drunk. ;o) for every
action you get points. The game is finished if the group catches mobbi,
or if you help him for 120 seconds. When you help him that long,
you get 500 extra points, then you can subscribe to the online high
score.
You can reach the online high score [LINK http://www.mobbingwerkstatt.de/cgi-bin/kdmc_oh/view.cgi here].
Our team homepage is [LINK http://www.ec-team.net]
I also want to ask if you would link my german game developing page. There you
can find a lot of tutorials about coding in c++, vb, turbo pascal,
java...(especially directx), 2d-3dgrafik, and sound. There is also a forum and
a section where you can offer your games. There are also a texture- and
soundarchive, and a section about books.
The page is: [LINK http://www.gdirectx-dev.de]
bye fronc
(L) [2002/09/27] [p.l.] [pe7@gmx.de]
The picture contains screenshots of 2 projects that i just uploaded at
[LINK http://www.jzone.de/p4d/index.htm] with sourcecode: a gory fight game
demo and a lowpoly 3d editor. I used the editor to make the game models.
some features of the game demo: particle system, script system,
multitexturing, physics, shadows. the stuff is written in java, and
needs gl4java from [LINK http://www.jausoft.com www.jausoft.com] to show opengl graphics.
Comments and critics are very appreciated in the forum under above url
or by email.
(L) [2002/09/30] [gruk5] [gruk5@yahoo.fr]
VKPlasma - Smooth and colorful aggregating plasmas
This plasma is generated by drawing electrostatic fields created by charged
particles.
In order to obtain nice and colorful effect, the electrostatic force fields
of each
particle applies over different color fields, and some fields are somehow
merged to
produce a cool "aggregating" effect when the plasmas approache close.
No special trick is used here. A static t->1/sqrt(t) has to be generated in
order
to draw fast, and DirectX8 DirectGraphics, locks and backbuffers are used to
produce
the smooth effect.
The demo (with source code) is available [LINK ftp://ftp.flipcode.com/demos/iotd-09-30-2002_plasma.zip here]
(56k)
(L) [2002/10/02] [GottfriedChen] [gottfried@chengine.com]
Inspired by all the recent poly reduction bump screenshots (hint: Doom3)
I tried to achieve a similar look with existing geometry and this is the
result. The image shows Klesk and Tank Jr. from Quake3 on the left
without normal map and on the right with normal mapping applied. For
calculating the normal map I convert the diffuse texture to greyscale
when I load the model and use that as a heightmap for normal map
generation. This works since artists tend to paint lighting information
into the textures. Since they can't assume a particular light
direction/position or the model would look wrong when placed into a
scene, the luminance information (from the greyscale bitmap) is suitable
for normal map generation. To apply the normal maps you have to
duplicate some vertices (those where the texture is mirrored). The demo
is part of my testbed that you can download at [LINK http://www.chengine.com www.chengine.com]. All you
have to do is to set the q3a variable in the test.set file correctly to
your Quake3 root directory. It should run on all cards with 2 texture
units and DOT3 support although I've only tested it on my GeForce2MX.
(L) [2002/10/07] [MuresanRobert] [mx_robert@hotmail.com]
BlueSky is a hacking simulator with a very strong story behind it.
If you ever wanted to prove your skills as a hacker, from the safety of your home, now you got your chance.
This is my first commercial game project as a game developer.
Download a test version from [LINK http://www.TerminalZero.com/bluesky www.TerminalZero.com/bluesky]
and give it
a spin.
Although it is not a graphicly impressive game, the hardest thing involved
in creating this game was
to offer great gameplay at an easy difficulty. It is very easy for a player
to lose track in the game.
Even with an included tutorial, we got feedback from beta testers that
finished the test level in 9 minutes, some that did it in more than 30,
or some that didn`t understand what all this was about.
This raises an interesting question in game development: gameplay duration.
As a developer I can finish the game in no time, as I know everything
about it. But how
long does it take for an average player to finish one level?
You can't make a level take too long, as the player will become bored, but
also you can`t keep it too short.
One feature I recomend to you when releasing a demo: Track the time needed for
a player to finish the game.
It can make a huge difference in your game.
(L) [2002/10/08] [Sylvain"Sly"Vignaud] [vignsyl@iit.edu]
This is the result of my last week of work: per pixel lighting with distance attenuation (in square of distance) and bump mapping on Quake I maps. I decided to work on this after I heard about Tenebrae, which is an alteration of the Quake I game to include such features. I started this one week ago, and here it is, thanks to the DOT3 GL extension.
The whole thing (lighting+texture) takes only 1 pass, using 2 texture units. The first TU compute the lighting (light vector dot normal vector for each pixel), the second pass multiply the lighting by the texture color.
Other passes are needed for shadows.
The bumpmaps are generated from the textures, which means that any Quake I level can be displayed. Ok, artist bump maps would be nicer, but I am not a graphix, only a coder. Another drawback is that even watter and lava are bumped. =(
I still have bugs on computing the tangent space in Quake III levels, but soon... =)
Speed: arount 70fps on a Duron 800, GeForce 2MX
Next steps: multi-light (easy) and soft shadows (harder).
More screenshots are available on:
[LINK http://tfpsly.planet-d.net/img/3d/Screenshots/Bump/index.php]
(L) [2002/10/10] [MARC] [rondrik22@compuserve.de]
This picture was taken from the final version of the "Shockbrowser".
This is a advanced version of my cg shader browser .
It is able to load models from .ASC and .X files and to render them with
OpenGL 1.4.
For Cg I'am still using the Toolkit 1.0. I implented some simple shaders
already but you are also able to write you own shaders with Cg,
import them and let them do the magic at realtime on the previous loaded
model.
The project will be open source when I'am done and when I have some
webpage up and running where people can download it.
It's not done yet and I still look for people who are willing to make
some more beta test's.
The project was written in C++/MFC/OpenGL/Cg.
If you have any questions, just feel free to write a mail:
[LINK mailto:rondrik22@compuserve.de rondrik22@compuserve.de]
MARC
(L) [2002/10/11] [JustinMette] [justin.mette@21-6.com]
21-6 Productions has been working hard this last year to start a game
development studio from the ground up. Today we are proud to announce
the fruits of that labor with the release of our first game called
Cyclone! Cyclone is a fun and addictive puzzle/arcade game that the
whole family is sure to enjoy.
You can download a free demo version of Cyclone from RealOne Arcade
using the following link:
[LINK http://realguide.real.com/games/?s=game_download&sub=cyclone http://realguide.real.com/games/?s=game_download⊂=cyclone]
Cyclone was built in about 3 months using C++, DirectX, and the
OGG/Vorbis SDK. Much of that time was spent building a re-usable 2D
game engine for our future games of this nature. The team consisted of
a designer, a programmer, and a sound engineer. The artwork was done by
the designer, programmer, and a little help from a friend (on the user
interface skin). One of the biggest challenges in developing the 2D
engine was getting it to run well on really old hardware - which allows
for mass distribution.
The other side of this project consisted of finding a publisher and
getting a good deal. Since it is our first published game as 21-6
Productions, we stumbled a bit in this arena but ultimately decided to
launch with RealOne Arcade. Real Networks offered a complete Beta test
(with 1000 testers), a tech-test on old hardware configurations, a
60-minute demo wrapper, pirate-protection (via their RealOne Arcade
client), and finally they provided a great deal of marketing materials
like an instructional video. Unfortunately, it took about 10 weeks to
go through the whole process and get the game out on the shelves.
Cyclone is really an experiment for 21-6 to see if these mini-games can
generate the kind of revenue which many people believe they can. The
most rewarding part of the project, however, was actually completing and
shipping a game.
We would love to know what you think of our first game so please don't
hesitate to give us [LINK mailto:cyclone@21-6.com feedback] on your Cyclone experiences. We hope you have as much fun playing it as we had
building it!
To learn more about 21-6, please visit our web site at
[LINK http://www.21-6.com]. If you are interested in receiving further updates
on our progress - you can join our mailing list at
[LINK http://www.21-6.com/subscribe.asp].
(L) [2002/10/14] [Thilo] [thilo@hardtware.de]
The two screenshots above are from my new arcade game named pipes. The game is 90% adapted from the old game LOOPZ from the Nintendo Gameboy. You have to make loops with pipe pieces. If you have made one loop then he disappears and you get points, level or life up. The higher the level the less time you have to make complete loops.
Very funny and addicted making gameplay.
There are some little eye candys like particles, isotropic explosions, transparent game elements, skydome with stars and rotating sky. The sound and music is kind an Amiga or Nintendo sound, but thats wanted ;)
The game was completely written in Delphi 6. APIs are uses are the
cool [LINK http://glscene.org GLScene] and BASS for sound support. The source code is available on request.
Download the whole game here: [LINK http://www.hardtware.de/software/pipes.zip www.hardtware.de/software/pipes.zip]
Website: [LINK http://www.hardtware.de www.hardtware.de]
(L) [2002/10/16] [YenKwoon,Hun] [ykhun@singnet.com.sg]
The above image is one of several 3D reflection techniques that i have been implementing in my free time. I called the technique used to generate the above images Virtual Camera Position (VCP). Its a multi-pass rendering technique with the 1st pass rendering the reflection to a render target (e.g. texture surface) from the "Virtual Camera Position" behind the mirroring plane. The reflections generated depends largely on the calculations of the projection and view matrices from the VCP to the mirror vertices. The VCP reflections if done properly is very accurate and almost pixel perfect. Well, not pixel perfect all the time, the texture that holds the reflections have limited resolutions. When you get really close to the mirror, the image quality degrades. The top image showed a perfect reflection of the floor texture since the bottom edge of the mirror is touching the floor. The bottom image shows a reflection from a position near the floor that revealed objects at the top of the scene behind the camera.
Another plus for VCP is that there is absolutely no limitation on
where you can place the mirror in a scene. Objects can be placed
anywhere in the scene (behind or infront of the mirror) and the
mirror's reflection can be guaranteed to be correct. The planar mirror
could be of any orientation as well. Moving, rotating or dynamically
resizable mirror is also possible! You can find a paper i wrote on
this implementation here [LINK http://www.geocities.com/startux05/programming/graphics/VCP/VCP.html]. The discussion on this paper centers on the sample implementation which generated the above images. The sample application is done in DirectX 8.1 and the scene is done by me using MilkShape3D and some free textures. Please forgive me that the scene sucks! Its programmer art ;-).
Yen Kwoon, Hun
[LINK http://geocities.com/codeman_net/]
(flipstar)
(L) [2002/10/19] [Jean-YvesLamoureux] [jylam@lnxscene.org]
Here is a small attempt of "refraction" on my beginning of software 3d
engine. This engine for now features things like that :
- Flat and gouraud shading
Backface culling (of course)
Object generation (Cube, torus, etc)
Texturing
Per-pixel alpha blending
Fake refraction (not a texture, real background is used)
Environement mapping
Etc (in fact all the basic stuff you'll find on a 3d engine)
Why software rendering ? Because I don't think putting polygons, even
textured, is a cool thing to do at spare time.
I don't have pixel shaders enabled 3d video board, and it's far too
expensive and not enough standard for now.
Sorry, you cannot download anything yet, but the demo(s) created with
this engine will be GPL'd (Release soon).
Thanks for watching, you can send comments to [LINK mailto:jylam@lnxscene.org jylam@lnxscene.org]
(Oh, and I'm looking for a job as a software developper (Games, Embedded
computers, etc), near Lyon, France. You can find my Resume at
[LINK http://www.lnxscene.org/jylam] )
(L) [2002/10/21] [AnttiDalanathLevomäki] [alevomak@mappi.helsinki.fi]
Here's my recent metaball-demo, called Lava. I got tired of the
usual 'pile of metaballs blobbing around'-scene and made a worm out of
connected metaballs chasing some particles. Looks crappy in still
screenshots, try the demo for a better effect :)
The metaballs are rendered environment mapped with the 'marching pyramids'-
algorithm, and they are connected to each others with the particle/spring
system from the 'Advanced Character Physics'-article. The metaball surface
is rendered in slices one cube high, and the surface is tracked similarly
as in an article at AngelCode. The worm is made out of 10 metaballs,
connected by 9 springs. It's written in C++ / DirectX 8.1
Additionally there are 10 balls of light flying around, trying to stay
close to the worm. Two of the worms have a lightsource attached to them,
lighting the scene.
Runs at around 60-90 fps on my AMD XP2000+ / GeForce2 GTS, probably needs
a T&L-card to run.
More info and the demo at [LINK http://www.dalanath.tk] (having problems with the
counter, try [LINK http://www.cs.helsinki.fi/antti.levomaki here] if the .tk doesn't
work)
Antti 'Dalanath' Levomäki
(L) [2002/10/23] [CharlesBloom] [cbloom@cbloom.com]
Hey flipcoders! This screenshot shows some features
of my Galaxy3 project. More info is available at
[LINK http://www.cbloom.com/3d/galaxy3screens/index.html]
The top two images show the bunny and fandisk models
at full detail. The bottom two images are wireframe
versions of the shots above them. The left two
horses are full detail (64k tris) and the right two
horses are low detail (1500 tris).
The models are standard research models. They were
automatically uv-mapped by Galaxy, a normal map
was generated, and then they were simplified. No
manual tweaking or adjustments of the models were
made.
They are lit using a simple cube-map lookup. The
lighting model is basically just CubeMap[Normal]
per-pixel. The cube map is only 8x8 on each face,
and is generated on the CPU by sampling the local
lighting environment.
The automatic uv-mapper is the most exciting piece.
It's an implementation of LSCM by Bruno Levy, with
some modifications. You can get more info on LSCM
at [LINK http://www.loria.fr/~levy/]
The tech in Galaxy3 is fully functional, but it needs
more cleanup and UI work that I just never seem to
find the time for. Contact me for more information.
(L) [2002/10/24] [powerrender] [powerrender@rogers.com]
Here are a couple of new screenshots from the PR-X engine. The scene uses fully dynamic lights, shadows, and bump mapping. Since lights are fully dynamic they can flicker, pulse, turned on/off and a variety of other effects allowing a gamer to change the environment.
Every triangle including the skinned character uses the same rendering technique, casts shadows and uses DOT3 bump mapping. Lights are done entirely with textures for per pixel lighting and attenuation. They can also be modulated with a projected texture in a single pass to give soft shadows (ie the white stripes). Each triangle is drawn using 2 or 3 passes per light (no textures, diffuse, specular) and up to 4 texture stages per pass.
The character was created by Eric Walker of [LINK http://www.walkerboystudio.com Walkerboys Studios] for a demo of the engine. Bump maps on the character were created from the texture but in the future we'll be generating normal maps from a high polygon version instead.
More screenshots that show the evolution of this engine over the past
year are available at the PR-X [LINK http://www.powerrender.com/prx website]
(L) [2002/10/25] [Sanderhoogewerf] [sander@pulsesoftware.nl]
This is a screenshot of a side project currently in development. It's a race/shooting game developed in Visual Basic using TrueVision3D and DirectX8 called Insanity Racing. It uses stencil shadows, lightmaps and a rotating skydome for a realistic sky effect. Its still a early screenshot of the game but finally it will be a 1 player racing game against bots. Main purpose for me why I'm developing this game is to learn from it, especially AI and physics are hard to program so it's a real competition for me. =)
Sander hoogewerf
(L) [2002/10/26] [Sylvain"Sly"Vignaud] [vignsyl@iit.edu]
Hello coders,
Remember my last iotd (Quake+bump)? I added soft shadows on top of it and here is the result.
This algo for soft shadows is:
- fast: 30fps displaying a Quake III levels on a Duron 800MHz, GeForce 2MX
crappy
doesn't look that good
Basically, while creating the shadow volumes with the stencil buffer, I also compute a shadow attenuation based on the distance between the occluder and the pixel, and I store it in the Alpha value of the pixel color. That means that every polygon that is displayed in the Stencil buffer is also displayed in the alphas of the color buffer.
Then when I am displaying a big dark quad on top of the screen to darken the shadow area, I activate blending based on the alpha values stored in the color buffer, and here is the trick!
More screenshots at:
[LINK http://tfpsly.planet-d.net/img/3d/Screenshots/Bump/]
(L) [2002/10/27] [BrunoLevy] [Bruno.Levy@loria.fr]
This image shows our newest results for the LSCM parameterization
method. More details are available from [LINK http://www.loria.fr/~levy]
LSCM (Least Squares Conformal Maps) makes it possible to create an
atlas, i.e. a representation of an object very usefull for texture
mapping, level of details with normal maps, ... This latter application
has been previously shown at Flipcode by Charles Bloom, see his page
[LINK http://www.cbloom.com/3d/galaxy3screens/index.html here].
To construct an atlas, the model is first subdivided into pieces, which
are flattened. The flattened pieces are then grouped in (u,v) texture
space (lower left image). The lower right image shows how a regular
grid is mapped from texture space to the object.
This parameterization has been constructed thanks to a multiresolution
version of LSCM, combined with an automatic segmentation algorithm.
(L) [2002/10/29] [BenWilson] [bennywilson78@hotmail.com]
This is a screenshot from a static ray-tracer I am developing. It is written using Visual C++ and OpenGL. Basically, a ray is fired through each pixel of the screen. When an object is hit, direct lighting and reflection/refraction rays are fired to add a contribution to the pixel. The scene above is rendered to a ray depth of 10.
It is currently unfinished, but a demo and source is available [LINK http://bennywilson.dreamstation.com/class/program3.zip here]. The project will eventually include texture mapping, first-hit speed up due to hidden surface removal, BSP tree and an active edge list for polygon ordering. Check out my website to see this and other games and programs I've developed.
Ben Wilson
(L) [2002/10/30] [GeroGerber] [gerogerber@gmx.de]
3DShadows is the application I created for my diploma-thesis which covers
real-time shadows. It works like a simple modeller where you can place and
modify objects and light sources. You can select one of three
shadow-algorithms (planar shadows, hw shadow-mapping and shadow-volumes) to
see how each of the algorithms behaves under special circumstances.
I developed this application by using MFC as the application framework and
OpenGL for rendering.
The development environment was VC++ 6, Windows 2000 Professional with a
GeForce3 graphics adapter and the current NVIDIA reference driver (30.82)
installed.
You can download 3DShadows here:
[LINK http://www.gerogerber.de/3dshadows www.gerogerber.de/3dshadows]
Gero Gerber
(L) [2002/10/31] [KurtMiller] [kurt@flipcode.com]
I spent a little time recently working with voxels. My goal was to write a simple converter that takes as input
a textured triangle mesh, and outputs a colored voxel representation. No particular reason or overly fancy results,
just experimenting a bit.
The approach I used to generate the voxel mesh is pretty simple. In a nutshell, it works like this:
- Generate a grid of cubes over the source mesh.
Throw out any empty cubes.
Color each of the remaining cubes based on the source mesh's texture.
The screenshot shows an example voxel model generated with different resolutions for the grid of cubes. The viewer
I wrote renders actual cubes (made up of colored, untextured triangles) for every voxel.
There's a more detailed explanation of the mesh conversion process, as well as a downloadable demo
of the voxel mesh viewer in my [LINK http://kurtm.flipcode.com/devlog-VoxelMeshCreationandRendering.shtml journal].
Thanks for reading...
(L) [2002/11/05] [TonvandenHeuvel] [A.W.v.d.Heuvel@student.tue.nl]
The above image was created with TReal. TReal is a program capable of
generating realistic 3D tree models. TReal generates an internal 3D
representation of a tree based on various parameters. The model used for
generating the tree is described in an article published by Jason Weber and
Joseph Penn, "The Creation and Rendering of Realistic Trees". The article
can be found here: [LINK http://portal.acm.org/citation.cfm?id=218427].
Using plugins the internal representation of the tree can be exported to a
scene file for a particular 3D program. I've currently written one plugin
for TReal, called POVTReal. POVTReal is able to output standard POV-Ray
scenes that can be rendered with the [LINK http://www.povray.org POV-Ray] raytracer.
When the user chooses to render the tree, at first an internal
representation of the tree is created. A tree is a TTree object, consisting
of a Trunk of the type TStem. Every stem has a list of substems. The tree is
recursively generated by first growing the trunk, then all the children of
the trunk and so on. The last level in the recursion are the leaves.
The stems consist of a list of sections; in fact 'circles' (when lobing is
used these circles are deformed) defined by a number of vertices. More
vertices per section of a stem at recursion level n positively influences
the quality of stems at recursion level n. The number of vertices can be
specified by the user (this is in fact an extra parameter I've added to the
model). Every stem and every section making up a stem have a local
coordinate system associated with it. When writing the section vertices to
the internal representation of the tree, these local coordinates are
converted to global coordinates. Please note that all the classes
implementing the scaling, rotating, matrices operations, and coordinate
conversions have been written by me.
The entire program is written in Borland Delphi. For this reason the program
isn't particularly fast as you might notice. I'm currently rewriting the
low-level vector and matrix routines in C++, that should significantly
improve performance.
Oh, one last thing, the source code and some additional information can be
found here:
[LINK http://members.chello.nl/~l.vandenheuvel2/TReal/]
And don't forget to have a look at a friend's site of mine who used the same
model as I did and created a Java program also capable of generating
realistic 3d tree models. His program is called Carrot and more information
can be found here:
[LINK http://home.wanadoo.nl/d_reniers/blue/edu/tue/carrot.html]
Sincerely, Ton van den Heuvel
(L) [2002/11/08] [Emmanuel] [EmmIcart@aol.com]
These are some screenshots of my current projects: TRACY & FROOGZ.
TRACY is a 6DOF volume-based realtime rendering engine. Objects are no longer
made of polygons,
but are instead made of Volume Pixels (voxels). Voxels are the pixels
equivalent in 3D.
This renderer is not yet hardware-enabled (just because volume rendering
extensions are not
common on today's 3DHW), so I had to write my own software renderer. The main
interesting
aspect of voxel objects is that they are not anymore empty: the whole
volumetric information
of a shape is stored, not only surfacic information. It becomes very easy to
modify the
geometry in realtime (digging, tunneling, modeling). TRACY supports 16bit
rendering mode,
perspective correct rendering, unlimited voxel arena size (at some memory
cost of course),
and a 3D lightmap is stored with the voxel data. This lightmap is permanently
computed by
a background thread during the rendering. The rendering algorithm is an
image-order one,
and for this reason is not too much impacted by the object geometry or size.
I've coded it
using Delphi, and the core rendering loop is still 100% integer-math pascal
code (to keep
it as much readable as possible). It could surely take advantage of SSE or
MMX instruction
sets, at the cost of a more specific coding. You can download the full source
code and EXE
at [LINK http://tracy.momorprods.com]
FROOGZ is the application of TRACY in a game project. It is a 3D evolution of
the LIERO game
(a realtime Worms game). It supports splitscreen mode (up to 4 players), a
built-in script
engine. Each item of the game is scripted, which allows a high extensibility
for the game.
Objects can be MD2 models (with alphamap) or sprites (multiple view angles).
FMOD is being
used as a sound engine. This game is still under construction, but you can
try a beta version
at [LINK http://froogz.momorprods.com]
Regards,
Emmanuel.
(L) [2002/11/09] [DallasNutsch] [danutsch@attbi.com]
Here's a little technique I would like to share with ya'll:
This image is, of course, a terrain with bump mapping applied to it. The
technique needs dotproduct3 combining, cube maps, and environment mapping.
In only works for directional lights which makes it perfect for outdoors.
The technique goes like this:
1. Use texture coordinate generation to get the camera space normals u,v,w;
2. Use the texture transform matrix to rotate from camera space to world
space, and then to light space, which in this case is the sun.
3. Use a normalizing cube map to transform from u,v,w to r,g,b
4. Dotproduct3 with your normal map
5. Add in the ambient value with addsmooth. This will knock out some
shadows, but won't overbright as much as add. This is what addsmooth was
basically created for.
6. Modulate with the texture map.
This works for not just the ground, but everything that is "outdoors". It
can be done with one pass on the newer video cards of course. The image
here is two passes. You can also modulate a shadow map in after step 5 if
you're using those. You can also add in the diffuse after step 5 instead of
ambient if you are doing vertex lighting.
-Dallas
(L) [2002/11/12] [NicolasCapens] [nicolas_capens@hotmail.com]
Here's a recent screenshot from my software rendering project. It started out as a simple spinning cube renderer, but it is now turning into an alternative for hardware acceleration API's. Although it is capable of most of Quake III's map rendering, it is not 'yet another Quake clone' as I'm only using these maps for testing its true power in a situation normally meant for hardware rendering.
Some of its current features are:
- a.. Bilinear filtering
b.. Multi-texturing
c.. Pixel & vertex shaders
d.. Flexible render states
e.. Sub-pixel/texel accuracy
f.. Per-pixel perspective correction
g.. Per-pixel exact mipmapping
h.. Homogeneous clipping
i.. Frustum culling
j.. Dynamic lighting
k.. Gamma correction
l.. Fog
The pixel and vertex shading was made possible with dynamic code generation using my assembler: SoftWire. This also made it possible to have dozens of render states created at run-time. All assembly code is heavily optimized using the Pentium III instruction set.
About the performance. With all features turned on, this kind of scenes render at about 20 FPS in 640x480x32 on my Celeron 1200 MHz. My goal is to reach at least 30 FPS, and this will certainly be possible by using some tricks common to software rendering. Per-pixel computations could be approximated by sub-affine interpolation. To eliminate overdraw, I'll probably replace the depth-buffer by a geometry based visibility algorithm like portal clipping. I am also still trying to make a scheduler for the run-time assembler to get the most out of the inner loops.
A preliminary demo can be expected around the first quarter of 2003.
More information and older screenshots can be found at: [LINK http://softwire.sourceforge.net/extra.html]
Regards,
Nick
(L) [2002/11/13] [GregMeyers] [gmeyers@forgefx.com]
This is a screen shot of an interactive 3D car maintenance demo created by
ForgeFX for Macromedia. This project is developed with Maya 4, Director 8.5,
Flash 5 and delivered through the Shockwave plugin. Maya was used for all of
the 3D geometry, animation and texturing. Director was used for all the
interactive elements with the 3D models and Flash was used for the
interface. In addition to using the standard Maya toolset we took advantage
of the Maya RTA which allowed us add the artist to add interactive elements
without taking time away from the programmer.
The biggest hurdle in this project was creating a 3D model that showed
enough detail while not having so many polys to grind the Shockwave
performance to a halt. Macromedia was eager to demonstrate the new
anti-aliasing feature which was difficult since this causes a big
performance hit as well. To get around this we went with a dynamic
anti-aliasing approach, basically turning off anti-aliasing while the model
is moving or being interacted with and then turning it on when the model is
idle. The project took a programmer and an artist 2 months to complete.
The completed demo is available at [LINK http://www.forgefx.com/demos.htm www.forgefx.com/demos.htm] - enjoy!
(L) [2002/11/15] [Buddy] [mpbetts@ragel.ca]
So it's been at least a week since the last ray-traced image here, so
here's another one for you to enjoy!
I wrote this as an assignment for my CS488 (Intro to Computer Graphics)
course at the University of Waterloo. My raytracer supports:
- spheres, cylinders, boxes, polygonal meshes
texture mapping of all primitives
reflections
CSG
bump mapping
specular, diffuse and ambient lighting
heirarchical models
automatic generation of bounding spheres for models
If you want to see a really large rendering of the above image (2048x2048
and about 2.1MB) click [LINK http://buddy.bbsg.ca/pics/cs488/rt_buddy_v2_big.png here].
Cheers!
(L) [2002/11/17] [danuabey] [silvermace007@hotmail.com]
this is a project i am currently undertaking while im on school holidays.
i needed a scripting language to embed in my projects, i found available
engines like Ruby, among others, to be complicated and, really, overkill.
so i set out to create my own compiled (virtualmachine) languge.
i had compact lingo 1.0 (my previous interperted language writen in C) i
converted it to comply with CodeWarrior7, VisualC++ and (still trying) G++
3.x.
now fully object oriented C++, libcl has 3 components, Compiler, Bytecode
Generator & soon to be a Linker.
so far the Compiler is done, i am currently working on the BC Generator.
Libcl has all the regular language features:
- stack base Assembly Generation & VM
Loosly Typed Variables
if statements & for loops
functions
inline assembly ( like in VisualC++ )
maths operations with floating (single & double) point math
experimental classes & data structures
experimental arrays & access.
similar syntax to Javascript
if i get enough response from this posting, i will seriously consider open
sourcing it, anyone interested or any questions please e-mail me:
[LINK mailto:sivlermace007@hotmail.com silvermace007@hotmail.com]
(L) [2002/11/18] [DanielPorzig] [powerpurzel@web.de]
The pictures above is are two screenshot taken from my OpenGL SpaceBattle simulation I've started to work on 6-7 month ago.
In the demo you can already pilot 13 different crafts and fight against masses of AI-enemies.
During the development I've put the main emphasis on the graphics engine so the implemented missions are not that extensive yet.
The models were modeled & skinned (by me!) in 3DS max and exported into the ASCII .ase format. Then they're imported by my own 3D editor I developed for the game to apply lights, engines, particle emitters and weapon mounts to the ships and finally converts the models so they can be loaded by the game engine.
Here are some details:
- a.. Dynamic Lighting
b.. Rudimentary AI
c.. Particle System
d.. Collision Detection
e.. Sound & Music
f.. Shop interface for weapon / craft selection
g.. Basic Flight Physics
h.. Virtual Camera
All in all the project features many basic game-elements but I'm not sure if it already has the right to be called a "game"... There's much work to do.
But it even in this state it is nice to look at and can be fun to play! So just try it!
You can download the demo here:
[LINK http://home.arcor.de/powerpurzel]
I'm always happy about feedback so feel free to mail me your thoughts about the demo!
Daniel Porzig
(L) [2002/11/19] [Bee] [bee-avispa@jcom.home.ne.jp]
These are some screenshots of my
"Real-time Per-pixel Subsurface Scattering Renderer".
(too long, huh?:<)
Subsurface scattering is very important effect for translucent material,
such as skin, marble and etc. Note that upper right image shows scattering
effect of back lighting. (The model is same as upper left image.)
I read a paper of BSSRDF, and I started to think how to implement
BSSRDF in interactive application. After a few weeks,
I developed efficient algorithm using Z-buffer. This algorithm is similar
to depth shadow mapping, but it uses depth value to calculate light
scattering distance. Currently, it is running by software rendering engine,
but I think it can be implemented by vertex/pixel shader of DirectX9.
Here's current features:
- One parallel light
Per-pixel lighting
Texturing of scattering parameters
Soft self-shadow
Envrionment mapping
Object can deform (Shading is not precomputation)
You can download the demo in my website.
[LINK http://members.jcom.home.ne.jp/himatsubushi/]
(Sorry, this page has been written only in Japanese)
This demo requires powerful CPU, but you don't need any graphic hardware
because it is fully implemented by software.
Drag & Drop some X-file (not include vertex normal ideally) to
exe file to load model data.
(If you don't have any model data, you can simply execute demo and
it automatically generates bumpy torus model.)
Click the window to change scattering parameters and light direction.
Have a fun with it!
(L) [2002/11/21] [AlexStreit] [t.streit@student.qut.edu.au]
These screenshots were taken from my undergrad project. The aim of the
project was to have a look at developing a high performance progressive
mesh and explore its application.
The image shows 4 screen shots. Each shot is of the same scene using a
different mechanism to render it. In the top right of each shot the
frame-rate is displayed. At the bottom right the number of visbible
triangles (frustum clipping) is shown, along side the number of triangles
actually drawn (by the rendering mechanism, labeled "Tris drawn").
The screen shots are taken on a horribly old machine (Pentium 200), and
show how the scene rendered at full detail results in a frame-rate of 1.11
fps (top left).
top right: shows a visually conforming rendition, where only as much detail
is removed as to be imperceptible (4.55 fps).
bottom left: distribution of 20002 polygons accross the scene (20.83 fps)
bottom right: shows a system that reduces detail until the fps reaches
50-55k (52.38 fps)
The program shown uses OpenGL and GLUT, and runs under both windows and
linux (well, most *nix).
The data structure I made basically does not touch the vertex list, and
uses the glDrawElements command to fire the objects at the card. The same
reference mesh is used by multiple instaces of the same object.
The mesh is always at some given LOD (level of detail), and has additional
information that allows it to transition incrementally to any desired LOD.
Each level of LOD has an associated error term that allows us to
intelligently distribute polygons accross the scene giving preference to
details that are more important.
As with standard PMs (Progressive Meshes), this incremental data is stored
on disk in most significant to least significant order.
It was basically an excercise at developing a *FAST* PM, and exploring the
ways of making use of it. The best feature of this whole excercise, in my
opinion, is the idea of scalable games:
Basically, because of the ordering of the data, we only need to read as
much information as we are interested in. This means that we can have a
150mb model on disk, but only read 150k of it. Reading that 150k gives us a
lower detail approximation of the full blown model. We then use this in the
game, because the game does not need much detail. However, in the future,
when they get their Geforce-18, the game can read all of the data......
There are a lot of advanced topics that I didn't get to touch, because this
is a "single subject" project... however I will be returning to do
post-graduate work continuing in this area, so hopefully I'll have some
more things to send you guys.
Things are not clear on copyright, so I won't post code/programs, but if
anyone is interested, let me know...
-Alex Streit
(L) [2002/11/23] [JurgenVanGael] [jurgen.vangael@student.kuleuven.ac.be]
In january this year Olivier Zegdoun sent [LINK http://www.flipcode.com/cgi-bin/msg.cgi?showThread=01-14-2002&forum=iotd
&id=-1 this picture] to flipcode IOTD.
Two weeks later, a fellow flipcoder, Jurgen Van Gael, joined this
project after a short meeting at the millia in Cannes and started
co-developing this project.
The major coding changes over the last 10 months on this project are:
- Object Oriented Framework
3ds Loader
GUI Framework
Minimal AI
Last summer 3 new people joined the project to fill in the art holes.
Currently Andrew (Modeller) is providing us with awesome models for our
underwater universe. Alexander has been working very hard to get
different sounds & music in the game. And finally Mark has also joined
the project to implement new environment for De Profundis by working on
plants & animals.
The future is promising! After having released the demo we already
started working on new features. What to expect:
- Better AI
Visual Effects
Scripting (Python)
Maybe even some modding support: our biggest problem at the moment is
lack of tools but work is underway to improve that.
Feel free to download the demo at our website:
[LINK http://www.immersiveartz.com].
Jurgen Van Gael
Immersive Artz
(L) [2002/11/24] [MicheálOBrien] [mobrien@europe.com]
These two screenshots are from Slickworm - a little game project I've been
working on. Currently it's just a technical demo with vehicle physics and
terrain deformation.
The vehicle can be driven over the landscape or you can use the rocket
launcher to scar and take chunks out of the terrain. The vehicle and rocket
launcher are programmer art ;-)
ODE (Open Dynamics Engine) is used for the vehicle physics.
The terrain system uses dynamic Level-of-Detail with geomipmapping, detail
texturing and a single 2048x2048 unique terrain texture. The LOD technique
is a quadtree structure stored in a table rather than using pointers. When
the terrain is deformed the quadtree for that block is recalculated and a
static vertex buffer is regenerated for each of the 4 geomipmap levels.
The explosions are made of particle systems of axis-aligned alpha-blended
billboards with perlin noise textures.
There are more screenshots and a download available at
[LINK http://slickworm.sourceforge.net] The demo will run on Linux using OpenGL
and Windows using Direct3D 8 and source code is distributed under the terms
of the GNU GPL.
My main reason for posting these screenshots is because I would like a job
in the games industry.
Cheers,
Micheál O'Brien.
(L) [2002/11/26] [PyroArkham] [pyro_akm@hotmail.com]
Dawn scared:
This is a demonstration using a special virtual reality rendering technique.
It take about two week to build.
The graphics resources come from an older Dos demonstration.
This application work in internet plugin or standard executable.
We've used Antiryad Gx, our 3d engine with our scripting langage.
The script source code of this application is also available on our site.
The virtual environment is drawn before all, then come the 3d animated
objects and other 3d particles.
We've done a little event editor for detecting the mouse click zones.
A movie is integrated to the program, using a custom video compression,
controled by the script.
The executable version work both on Win32 and Linux operating systems.
You can find more information about Antiryad 3d engine at
[LINK http:/www.arkhamdev.fr.st] or
download and run the demonstration here
[LINK http:/www.arkhamdev.fr.st/html/games.htm]
Pyro Arkham
(L) [2002/12/02] [WolfgangGeiß] [Webmaster@Wolfgang-Geiss.de]
This is a project I have been working on for a while now in my spare time.
It is an Cloth Simulation programmed in C++, using OpenGL for graphics.
To test the Simulation the Cloth ist used as a Flag and you can adjust the
wind strength.
If you would like to follow the project or to download the application visit
: [LINK http://www.codereactor.de]
Wolfgang Geiß
(L) [2002/12/03] [FlavienBrebion] [f.brebion@vrcontext.com]
This is my 4th contribution to flipcode's IOTD,
although the last one was more than a year ago :)
I've been working on real-time soft shadows during
my free time recently, and couldn't resist posting
an image of my results.
The technic is based on a render-to-3D texture
approach. It's based on an extension of shadow
volumes, which means it handles self-shadowing and
point lights perfectly. In a first pass i render the
shadow volumes to the first depth of a 3D texture, and
i then blur the next depths recursively in hardware.
When it's done, i calculate a "sharpness" coefficient
per-vertex, which takes into account the distance to
the viewer and to the light, and i render the scene
again, with the full lighting equation, modulated
by the 3D "shadow map", which i sample based on the
sharpness coefficient.
It's not perfect, but the results look pretty decent.
The demo from which these images were taken only
works on a Radeon 8500+, and run at 15-20 fps average
on an Athlon 1.4 Ghz. It uses vertex shaders and
pixel shaders, for shadow volumes extrusion, dot3
bump-mapping, specular and gloss-mapping. The CPU is
almost idle, if it wasn't for rendering the
environment bump-mapped water (requires
render-to-texture too). The bottleneck is coming from
fillrate, but surprizingly, not from the soft shadows
part. Tested with standard shadow volumes, the demo
runs at 20-25 fps average, which means the soft shadows
is only slowing it down by 20-25%. The scene is not
very complex, but also not obvious (around 15k tris).
Two DIVX videos are available on my website:
[LINK http://www.fl-tw.com/opengl/SoftShadows/]
I'll try to post the executable in a few days, plus
some source code. No Geforce 3/4 convertion is planned
at the moment (no time!).
F. Brebion
(L) [2002/12/05] [PaulNettle] [midnight@FluidStudios.com]
Today we have a shot of Open Architect 3D. This particular shot has been
shrunken from a much larger shot which can be viewed [LINK http://www.OpenArchitect3D.org/city.jpg here].
In it's purest form, OA3D is just an architecture (a sort of 3D operating
system) for 3D tools. However, as you can see from the screenshot, it's
more than just an architecture, because it can actually DO stuff. :)
What it can do, depends on the plugins that are written for it. I spent
months at the design stage of this tool to ensure that a plugin can do
just about anything it wants to. This includes the regular stuff we use
today's high-end tools for (modelling, rendering, animation, character &
facial animation, layout & level design, physics-based animation, etc.)
but also includes the stuff that we'll want to do in the future; stuff
that hasn't been invented yet.
This particular screen-shot shows off about 10 minutes of playing around
in a level editor plugin I wrote for my clients (who also funded the
development of this tool), [LINK http://www.n-Fusion.com/ nFusion
Interactive]. This level editing plugin is fully functional, quite
powerful and took me less than 3 months to write. If you're in need of a
level editor for your company, see the note below.
Plugin development goes so quickly because of OA3D's design. The plugin
API doesn't get in your way or slow you down and it provides enough
functionality to allow the plugins to focus on doing what they need to do
-- getting the job done.
As an architecture, OA3D is reaching maturity. As a usable tool, OA3D is
in its infancy; it needs plugins -- lots of them. In order to satisfy this
need, OA3D will soon become an open project, where anybody can write 3rd
party plugins, browse the source, or become a member of the core
development team.
For more information about the design and what this thing can really do
visit the website at: [LINK http://www.OpenArchitect3D.org/ www.OpenArchitect3D.org].
Note:
I can be contracted to write plugins (including proprietary plugins) for
companies in need of level design or similar tools. My contract fees are
quite reasonable (less than it would cost you to dedicate one of your
employees to the task.) Interested parties should contact me directly at
[LINK mailto:midnight@FluidStudios.com midnight@FluidStudios.com].
Be quick, though, because in these rare times when my schedule has an
opening, it's never open for long.
Thanks for reading,
Paul Nettle (a.k.a. "MidNight")
(L) [2002/12/08] [JonAlma] [jonalma@hotmail.com]
Since December last year I've been busy working on a solo project to create
an updated version of the Lords of Midnight game. This started with the
goal of learning how to code using Open GL, but things have gone extremely
well and moved on to a full-blown game development project (called Legends
from the Lost Realms, or Legends for short).
For those who don't know, Lords of Midnight was a game originally available
on the ZX Spectrum in the 1980s. It was a turn-based strategy game set in
the snow-covered fantasy world of Midnight, with the player controlling a
series of lords and their armies in the war against the evil Lord Doomdark.
The game was viewed in full 3D with armies and castles being hidden behind
mountains and forests.
There's still some way to go yet, but progress has been good (especially
considering this is something squeezed in between the day job and normal
family life). Features already in place include,
THE TERRAIN ENGINE: I've implemented the terrain engine using multi-pass
texturing with no level of detail processing. However, as the camera angle
is fixed to ground level) I've been able to introduce 2D culling to avoid
drawing anything out of view. Trees in the landscape are drawn using
billboarding, with only one billboard used per tree, this rotating as the
viewing angle changes. While this would probably look funny in a first
person shooter, it seems to work fine here. In addition only using one
billboard per tree means that I can draw more trees without effecting
performance.
Other objects (castles, villages, windmills, bridges, etc) are created in a
3D graphics package, exported as ASC files and then converted into the
homemade file format used by the terrain engine. I've used a 'Lego'
technique were a number of basic building blocks (such as towers, wall
sections, gates, etc) are created and then combined to create each
settlement in the game. The terrain data is held in a bitmap file, the red
channel being the height map, the green channel holding object information
(indicating if a tree or building is found at each location), while the
blue channel is used as an index to the list of place names used in each
scenario.
In addition I've implemented a simple climate system that changes the
skybox texture, alters fog levels and changes lighting fro day to day. Has
a big impact on visibility and therefore on gameplay.
Everything is unoptimised at the moment, but optimisation is less important
for this type of strategy game than it is for a first person shooter.
EVENT HANDLING: Right from the start I wanted to include some kind of
scripting system to help control the AI and allow scenarios to evolve as
they were played. Initially I planned to integrate an existing scripting
language into the game, but after working out what I needed this seemed to
be a bit of overkill. Instead I coded my own event handling system where
each event is made up of linked lists of triggers and responses. If all
the trigger conditions are true then all the responses to these triggers
are carried out. Triggers can include characters in the game moving to a
particular location, castles being attacked, etc, while responses can
include changes in game data (characters switching sides for example), cut
scenes and changes in the AI. It is even possible to enable and disable
other events allowing for surprisingly rich scripting possibilities.
AI SCRIPTING: In parallel with the event handling system I have implemented
an AI scripting system controlling the variety of characters in the game.
At this stage the AI can hunt characters or follow a series of waypoints
across the map. Events can trigger the loading of new AI scripts during
the game to respond to the player's actions (so that for example the
computer can switch from an offensive to defensive strategy if the player
is on the attack). Further refinements are planned, but for initial
testing the existing system seems to already be working well.
THE USER INTERFACE: As someone who spent years researching user interface
design I thought I better mention this aspect of the game. As much as
possible I have tried to make the user interface as customisable as
possible. Several resolutions are supported (nothing new there!), all
keyboard controls are completely re-definable, icons used in the game can
always be available in the game, never visible (if the player uses the
keyboard exclusively) or fade in and out as required. In addition the game
has multilingual support, with English and French versions already
incorporated into the same code (it would have been easier to do completely
independent versions for each language, but less fun).
Things to come include multiplayer support with play by e-mail and hotseat
games possible. A lot of placeholder art needs to be replaced and I need
to work on the 3D objects used (a lot of them are best described as
programmer art and at the moment there is a lack of variety in the objects
available).
To quickly describe the screen shots ...
TOP: The Legends Engine in all its glory. Things need to be polished a bit
(particularly the icons), but the basics are finished.
MIDDLE LEFT: Two images showing the different texture sets already defined
(the default 'Scottish Highlands' set and an ice and snow texture set used
to recreate the look from Lords of Midnight).
MIDDLE RIGHT: One of the larger settlements in the test scenario. I'm
currently using the same (small) set of 3D objects for all settlements, but
eventually there will be several different sets available making it
possible to have different architectural styles available for different
races or factions.
BOTTOM: An image showing a number of armies converging on the player.
Characters and armies are displayed using billboards (just like the trees).
Armies are made up of different subimages to indicate the different units
in each army (unfortunately all the armies shown in this image had the same
composition - I was testing the battle handling algorithm at the time I
grabbed the image).
Hope you like the images - if you're interested you can see more screen
shots on my [LINK http://geocities.com/jonalma/ web site] or you can send me an
e-mail at [LINK mailto:jonalma@hotmail.com jonalma@hotmail.com]. Sorry there isn't a demo available at the
moment - I've just finished a big series of alpha tests and there are a few
bugs to squash before a beta version can be prepared.
Looking forward to you comments and suggestions,
Jon Alma.
(L) [2002/12/10] [TedL.Chen] [tedlchen@yahoo.com]
Here's several screenshots of the 9 month project I'm currently wrapping up
as a job demo. It's an indie game currently without publisher. And no
fear, I won't bore you with the engine checklist. :)
But, one highlight of the game is the use of a blended skeletal animation
system similar to one fleetingly described in the May '02 Game Dev Mag.
About a dozen nodes are used for each character, and the system seamlessly
transitions between them. The mesh is then overlaid on top of this blended
skeleton.
The hard part of the whole thing was to get the aim posing (like aiming
rifle left, right, up, down) to work across the entire front half-hemisphere
of the person. Corners (eg up-left) don't do well with a linear blend
between up & left. The system employed uses a cake-slice approach, which
actually fixes this problem with the traditional linear blending. It breaks
the pose space into band slices and performs a two-pass interpolation within
and between the slices.
The rest of the game is also home-rolled. The sound system is built on top
of DirectMusic, for it's 3D and interactive music capabilities. The
graphics extensively use the D3DX extension libraries in DirectX 8. D3DX is
a very good boot-strap system, especially when dealing with meshes.
While most material dealing with DirectX usually leans towards left-handed
systems, I've opted to use the right-hand - OpenGL style. This ends up
making integration with the physics engine less tedious as you don't need to
always flip your coordinates around. Which for this game, is most
important, since getting the physics right has more effect on giving a
'correctness' feel to the controls.
The game has it's homepage at
[LINK http://tedlchen.no-ip.com/microg]
TLC
(L) [2002/12/12] [Mal] [mal@candomultimedia.com]
3D Stress Ball is the next game to be released from the canDo stable.
We have just released the beta version of this game to the public, along
with a level editor, in order to get feedback during the games middle
and final development stages.
You can view details of the game and play it's latest build online now
at.
[LINK http://www.candomultimedia.com/3dStressBall]
It uses Havok physics to create an interactive 3D world that the player
has to navigate.
If you get time, check it out and let us know what you think of it.
It'll be updated a lot over the next 8 to 10 weeks.
Mal
(L) [2002/12/14] [JaimeSoffer] [jsoffer@soffernet.com]
Fandango is a hobby project I have been working on the last year. I
expect it will someday be an useful CAD program.
It has a python driven commandline, a memory core and a OpenGL renderer.
The lowest level commands are written on C++ inside of the app; that
includes control of the vertex stack and linked lists, on the fly
calculation of normals, etc. The interface functions are then exposed to
python to make them available for the commandline interpreter.
The core holds arrays of vertex, normals and texture coordinates that
are when needed passed to glDrawArrays et al.
The included screenshot is the couple of a parallel sine transformation
and a radial one over a plane. The fandango command to create it is
'mix(func, func, 1, 7)'. Texture mapping is enabled into it using
'texture(1)'. Notice that it uses the colors suggested on the included
README.
To follow the development of Fandango visit
[LINK http://www.soffernet.com/jaime/fandango/]
(L) [2002/12/18] [lnmamacos] [lnmamacos@hotmail.com]
Ive been working on this terrain engine for a while. Its for a game that im working on. This is a 500x500 meter patch of terrain, but the engine supports infinite terrain sizes... its currently being used with an area of 400 square miles, at 1024 polygons per mile at the highest LOD.
Its current features:
Quad tree based frustum culling; multiple (infinite) texture blending layers; 3 detail texture layes; geomipmapping; realtime lighting; more that ive forgotten about?
Soon to implement:
realtime self shadowing; more that ive forgotten about?
Urg... im probably forgetting about a lot... but you can check the rest of the screenshots here:
[LINK http://www.9fish.za.net/shots/screenshots.zip]
And mail comments to [LINK mailto:lnmamacos@hotmail.com lnmamacos@hotmail.com]
(L) [2002/12/23] [ChaosRift] [chaos_rift@yahoo.com]
This is a screenshot taken from my map editor. The map
editor and the game itself share the same engine, so,
besides for the interface, the game looks like that
too.
Image info:
The image was rendered on a Thunderbird 750 MHZ, Vanta
TNT2 8MB VRAM, 256 MB RAM.
My shadows use the stencil buffer, so they require 32
BPP. All the shadows are dynamically generated,
and if the sun position moves, so will they.
There are about 7000 triangles in that picture.
For more screenshots and/or info, go to:
[LINK http://www.eternal-lands.com]
Radu Privantu
(L) [2002/12/25] [EmilPersson] [emiper-8@student.luth.se]
This is a screenshot from my latest demo (available with source here:
[LINK http://esprit.campus.luth.se/~humus/] ).
It shows some perpixel phong lighting with shadowmapping. It's done through
a fragment program in OpenGL, so it requires a Radeon 9700.
The shadowmapping works for pointlights by rendering the radial distance
into a cubemap. To conserve memory and keep high precision I multiply it
with 256 and store the fraction in the red channel and the floor in the
blue channel. This is the extracted in the fragment program. This way I can
get 16bit precision even though I only have 8 bits / channel.
-Humus
(L) [2002/12/27] [SanderHoogewerf] [sander@pulsesoftware.nl]
5 screenshots of our hobby game 'Eagle Eye Forces'. The game uses
TrueVision3D(RC3 beta version, will be due soon) and DirectX8. The sky
is build with a 2 layered cloud system blended in each other and
far-away fog for the yellowish horizon effect. The shadows on the models
are robust stencil shadows. The landscape is seamed together using 16
landscape chunks resulting a huge landscape.
The game style will be comparable with a game like Delta Force using
Game Objectives and a skills system.
Currently, the current project is about 30% done.
Sander Hoogewerf
(L) [2002/12/31] [Benny] [benny@kramekweb.com]
Machine Ball is a futuristic sport with amazing 3D graphics and realistic
physics with very simple rules: Get the ball into your opponents goal.
It's 2 player only on the same computer with optional joystick support.
I worked alone on Machine Ball. Total development time was about 6 months,
with about 200 hours of coding time.
Machine Ball uses Russel Smith's excellent Open Dynamics Engine(ODE) library
for the physics. It uses AllegroGL for cross-platform input and sound and
DUMB for music.
The graphics are pretty average and technically there is nothing fancy, just
plain OpenGL 1.1. But it still looks nice and the focus is on gameplay,
which is really very good (in my opinion of course).
I'd like to write a few words about the coding style. When I began to code
Machine Ball I decided to do it in a very clean OOP way with C++. I very
quickly got bored and started coding very sloppy. I knew what I was doing
and I had a very detailed design document, and knew that I wouldn't be
adding new features that would require total rewrites or anything. Near the
end I got super lazy and started using wacky variable and function names. If
you look at the code now it's pretty neat. In some places you find well
defined classes and in other's you find pure spaghetti code. You can sort of
see the (backwards) evolution if you look close enough. Anyway, why am I
telling you all this? Before the release some bugs popped up. They were
almost impossible to track through my code. I spent hours and hours trying
to figure out what was going on. (In the end, one of the bugs turned out to
be a bug in a library I was using). But if I could go back in time and
choose to code everything from the start properly, I probably wouldn't do
it. It would be too boring. The saved coding time outweighed the debugging
time in this project. But for a larger project, or a project that isn't
clearly defined, I'd definetly do things right.
Machine Ball website with screenshots and free download:
[LINK http://benny.kramekweb.com/machineball]
(L) [2003/01/01] [MichaelLiedlgruber] [programmingcorner@freaksolutions.com]
Inspired by many really impressive screenshots I've seen on flipcode
over the last years,
I started coding a small landscape this summer using opengl. Then, a few
days ago I thought: why not making an engine
out of it and start some game. Well, here are the first results:
I'm trying to make a speedy fun-to-play arcade-racing game mainly
focused on network playing. Maybe there'll be
computer players one day too. But currently I've other important TODOs
to get ahead, as there are:
- Optimize the rendering process: First I used brute-force rendering.
Yesterday I refactored the whole rendering code
and built in some optimizations (socalled geomipmapping for example).
But I'm still fighting against cracks and gaps.
Do some dedicated server or something similar.
Terrain following of the car: Currently I've absolutely no clue how to
do it. I've some formulas and I hope
to get some working code out of them (I'll be glad to get some
suggestions and hints on this topic :-)
Collision detection with other cars/props such as plants
A basic game-physics engine
What I already have:
- OpenGL based (partially) optimized terrain rendering engine with
multitexturing support
3DS model import (btw: thanks to Psionic for this cool, fully textured
low-poly car model)
A shadow precalculation program (this program takes 2 textures, blends
them together depending on the height
and adds shadows depending on the light position and returns a big
texture for the whole terrain)
Really nice stencil-buffer based shadows (you can see them very well
in the upper right picture)
A few comments on the four pictures:
Upper left: My engine in action.
Upper right: A close look to the jeep model with the shadows in action
Lower left: My track viewed from above
Lower right: You can see the optimization already working in progress
For more information, more screenshots and the progress of development
feel free to visit my
[LINK http://www.freaksolutions.com/pcorner/index.php?action=projects&page=buggy homepage].
If you've some comments or suggestions feel free to send me an
[LINK mailto:programmingcorner@freaksolutions.com e-mail].
Greetings from Austria
Michael Liedlgruber
(L) [2003/01/02] [MiNg] [MiNg.cs@student.cityu.edu.hk]
After one and a half month of work, here are the screenshots of my latest work - A 3d engine with per-pixel lighting + real time shadows.
These screenshots are rendered under a ATI Radeon 9000 and P4 1.6GHz system.
My demo uses the DirectX8.1 API and I perform per-pixel lighting using pixel shader 1.4. and the shadows are using shadow volume technique (Z-fail).
Here are the steps of how I render the scene:
1. clear color and depth buffer
2. draw the scene with ambient color
3. for each light
3.1 clear stencil buffer
3.2 for each object in the scene
3.2.1 update the shadow volume of the object.
3.2.2 draw the shadow volume to the stencil buffer (check for z-fail)
3.3 draw the attenuation + diffuse + spectular color of the light
That means for a scene that has n lights, it will be rendered in n+1 passes.
Also, I would like to give a big thanks to those people who had
answered my questions that I posted on flipcode's Message Center.
Finally, please feel free to contact me. I can be reached at [LINK mailto:MiNg.cs@student.cityu.edu.hk MiNg.cs@student.cityu.edu.hk] .
MiNg
(L) [2003/01/03] [lith] [lithander@gmx.de]
I don't know exactly why, but I've always been interested in
particle-effects. The process of creating effects, consisting of thousands
of little particles, by rebuilding real conditions in virtuallity is pretty
exciting in my eyes.
That's why I started to develop PixelprachtFX - a free-to-use library for
OpenGL in Borland Delphi which allows you to easily create your own
particle-effects.
The library provides a basic class called TFxSystem. When you are
implementing a custom effect you will inherit from this class and extend it
to your likes. You will set-up groups of particles, define
particle-templates and use predefined methods to apply physical effects and
manipulate the properties of your particles.
That way you can simulate friction, air-flows, gravity and similar effect
without knowing a single physical formula. And that's not the only situation
where the engine handles the complicated stuff for you. It takes care of the
rendering, manages various groups of different particles and templates and
does similar 'dirty' tasks. That way only the fun part is left to you: The
creative work of defining the look and behaviour of your effects.
After the core of the Engine was finished I wanted to see what it could do
and if it is easy enough to use.
So I developed a demo where I made extensive use of PixelprachtFX. The
screenshots you see above are from this demonstration. I've recently
uploaded it to my website [LINK http://pixelpracht.flipcode.com] together with the
sources. You're free to use the library in your own projects. If you want to
learn more about Delphi and OpenGL visit [LINK http://www.delphigl.com]. (make sure
you do! =) even if it's a german page some of the sources and samples might
still be interesting for you.)
I'd be happy for any comments! If there is enough interest I consider to
write a documentation and perhaps a little tutorial about how the engine can
be used and integrated into existing projects.
-lith
(L) [2003/01/05] [Alex] [alex_boswell@telus.net]
Hi Everybody,
I just thought I'd send a pic from the raytracer I've been writing in my spare time.
The image shows depth of field, global illumination, bumpmapping, high dynamic range textures, and image based illumination. The features it currently supports are:
- Global illumination
Anisotropic texture filtering
Hierarchical bounding volumes Grid to speed up secondary rays
A Vista-Buffer to speed up primary rays
Area lights
Hemispherical lights
Object lights, and triangle mesh can be a light source
Bump mapping
Texture mapping
Specular mapping
Environment Mapping
High dynamic range image support
Motion blur
Programmable surface shaders
Blurry relfections and refractions
Adaptive anti-aliasing
128 bpp portable floatmap output
48 bpp PSD and TIFF support
You can find lots more pics at my web site:
[LINK http://wifl.at.org/~fusion]
Alex
(L) [2003/01/07] [ArnaudCarre] [arnaud.carre@freesurf.fr]
Few weeks ago I downloaded what I call a gem : Turrican 32Kb ( you can
get it [LINK http://pouet.net/prod.php?which=2392 here] ). That was a remake of the great turrican game, running
in Windows using 32Kb only, with graphics and music ! It seems the
32Kb size for game came from a strange demo-party tradition. As I made
a library to write small EXE using DirectX8 and DirectSound some time
ago, I decide to port a classic game in 32Kb too ! One of the game I
liked the most in the golden years was "Rick Dangerous". If you don't
know anything about that great game, please go to that fantastic fan
site : [LINK http://www.deconstruction.f9.co.uk/rick/main.htm Rick Ressurected] and you'll get tons of information.
Nothing should be possible without the hard work of gameplay reverse
engineering made by "Bigorno", the author of [LINK http://www.bigorno.net/xrick/ XRick]. ( Multi-platform Rick Dangerous C conversion). Thanks to him for the main game-engine system.
If some of you wonder about the interest of making a 32Kb game, the
answer is quite simple: there's no ! :-) Just fun !
Technical details
The Rick32Kb needs DirectX8. All the game use real textures and
polygons. (well, strange for a 2d game huh ?). That
version looks like the ATARI-ST version, and has additional features:
- A demo mode !
High resolution filtered texture ( Toggle with "F" key )
An ATARI-ST soundchip emulator
12 minutes of real ATARI music
You can download and play it here: [LINK http://leonard.oxg.free.fr/rick32/rick32.html]
Arnaud Carre
(L) [2003/01/08] [JonWatte] [jwatteflipcode@thereinc.com]
Over the past few years, I've had the honor of working with a team
of extremely dedicated, talented, and far-out cool people, building
an online getaway called There. As of today, you may reach it
through the web site [LINK http://www.there.com/]
(or at least you can sign up for the public beta test).
The top one is me, inside a club. The second is some members flying
above Kantana Point. The third is a buggy gathering outside Mizmar
Cafe. The fourth is the approach to the floating islands of Saja. The
fifth is a member trying on some new clothes near Karuna Plaza.
Technical notes:
- Design target is a GeForce 2 MX or original ATI Radeon, running
on a Pentium III/800 with 256 MB RAM, with a decent 56k modem
connection, running Windows 98SE or newer.
We often hit the design frame rate of 30 fps on the minimum spec
machine.
Uses OpenGL, and requires hardware transform and lighting,
as well as texture compression. Only the standard transform pipe is
used. Avatar skinning code written in custom SSE assembly.
Written mostly in C++, served mostly from a scalable Linux cluster,
with additional customization using ThereScript™ (based on Lua).
State-of-the-art online expression capabilities, using mood-
expressing animation technology.
Many activities available where you can meet, hang out, participate,
compete, chat, and express yourself. The world is big!
The entire world is a distributed physics simulation running in lock-
step across the entire system. No cheating! If you hit my buggy with
a paintgun, the buggy rocks from the shock.
In-world shops, catalog, auctions and Therebucks™ currency.
Embedded internet browser. UI code written as Flash movies.
Built to scale much bigger than any current online virtual world or
massively multiplayer game using advanced network protocols developed
by company founders.
Developer SDK for adding to the world available.
We're hiring. Drop me a note if interested :-).
(L) [2003/01/10] [MarcHofer] [rondrik22@compuserve.de]
This image was taken from the latest version of the "Shockbrowser".
I posted some pictures of an early version of the shockbrowser some time ago.
The "Shockbrowser" is written in C++/MFC and uses OpenGL 1.4 and CG Beta 2.1 to render shader enhanced scenes.
You can load X (ascii / binary) and ASC Files, choose some of the built-in shaders or even write your own (just vertex shaders up to now) and load them during runtime. Compared to the last version I fixed a whole bunch of bugs that lead to some crashes
or some strange behavior (because of the fact that I have to do all
testing by myself...takes some time to find the bugs).
Anyway, the latest version of the "Shockbrowser" can be downloaded at
[LINK http://www.theshellshock.com www.theshellshock.com].
It uses still the beta 2.1 of CG but will be ported to the new CG 1.0 official release a soon as I managed to get into the whistle and bells of the new version!
MARC
(L) [2003/01/12] [JariKomppa] [jari.komppa@kolumbus.fi]
After I posted Textmedia as an IOTD (see the old IOTD [LINK http://www.flipcode.com/cgi-bin/msg.cgi?showThread=09-28-2001&forum=io
td&id=-1 here]) I received a bunch of suggestions and recommendations,
most of which had to do with actual usability of TextMedia. Textmedia was
never meant as a real player! =)
Anyhow, as I was preparing for [LINK http://www.altparty.org Alternative
Party] and the [LINK http://www.tAAt.fi/tmdc TMDC5 prizegiving
ceremony] there, I updated the good ol' textmedia a bit.
New features:
- Ability to seek within a file (cursors for per second seeking or
control-cursors for per minute seeking)
Ability to pause and resume (space)
Toggle for looping
Tons of commandline parameters
New experimental colorful ascii art mode (most stuff still looks better if
you enable the desaturate filter).
Screen captures from:
Top left - Shakira, "Whenever, wherever"
Top right - Enya, "Caribbean blue"
Bottom left - Björk, "Army of me"
Bottom right - Garbage, "Stupid girl" (in color)
(all are mpegs or avis).
It naturally looks better in motion =)
You can get textmedia2 from [LINK http://iki.fi/sol/files.html#other here] on my site. Comments
still appreciated.
In other textmode news, by the time you read this the [LINK http://www.tAAt.fi/tmdc TMDC5] (fifth pseudoannual text mode demo
competition, mentioned by [LINK http://www.flipcode.com/cgi-bin/msg.cgi?showThread=11-14-2002&forum=io
td&id=-1 this] IOTD) has also ended, so be sure to check out the winners
from that site.
(L) [2003/01/13] [PaulVarney] [paulvarney@yahoo.com]
Hi, I'm a professional game artist (11 years as a lead artist on such games as Sacrifice, XCOM etc). Over the last year I've been taking a busman's holiday and working on my own solo project - while learning to program (an artist learning to program - scary).
Here is a screenshot from my completed game Virtual Insanity. I
released the game today and I've put up a full demo for everyone to
download at my site [LINK http://www.farfromearthcorp.com www.farfromearthcorp.com]. By all means, please download it and
give it a go - dozens of screenshots over on that site also for you to look at.
Virtual Insanity was written in a powerful but relatively unknown
language known as Dark Basic. Dark Basic is written on top of Direct X
and it makes it easier to get your concepts into a prototype stage
faster than anything else out there. I hear all the time "but you
can't program a game in basic, it's basic after all" - well, the
language shouldn't really be called basic - it's a long way from what
we know as basic, it really does allow you to get into it at a fairly
low level - so I wanted to prove that I could make a cool looking
game that would show off the language. So far, all of my
colleagues have been literally blown away with the speed and quality
of this game and none of them would have guessed that anything 'basic' was involved and was created by just 1 person.
The game features 80 levels, stunning (IMHO) animated background effects and it is silky smooth even on lower spec machines. The levels are generated dynamically (I build the maps into poly's based on 2D data), 3 Dynamic lights keep the action glowing and over 20 multilayered background FX designed to make your head spin - Everything from Radars, nebulae, firestorms to Tornadoes.
(L) [2003/01/15] [devonzachary] [sock_devon@hotmail.com]
This screenshot shows a test of my new sky code for my engine, currently
called "Sock". It uses SDL and OpenGL for window managment
The sky-engine simply generates a sky based on a few paramaters. Each cloud
plane moves independently, the sun can be positioned wherever you like,
stars and planets can be added.
Unfortunately, it's not designed to be viewed from non-orthographic angles,
and therefore isn't that useful for a terrain engine, or such; but it should
make a nice backdrop for my 2D projects.
When the system is initialized, you pass it a directory and it loads all of
the art from that directory. This makes it very simple to create alot of
spectacular skys with relatively little work.
Nothing to technically advanced (no perpixel lighting or anything), but it's
pretty to look at.
If you want to watch it move, you can download an early demo at
[LINK http://members.shaw.ca/devonz/SockEngine.zip]
I'm developing my engine using Dev-CPP. My video card is an ATI Radeon 9000
Pro, and it runs at around 230 frames per second on my system.
-Devon Zachary
(L) [2003/01/19] [AndreasMagnusson] [amag@rotd.org]
Basically this is a 2d b-spline editor and when you've put 4 (or more) control-
points a sample is created in memory (currently limited to 1 sec). The sample
gets it's amplitude from the y-axis of the points on the spline and it's
frequency from the difference in the x-axis. So by moving two control-points
closer you increase the frequency between them and so on...
You can also model another spline which will then be the lower-bound of the
sample.
Anyway I post it as an IOTD because I found it quite amusing to create
different sounds. The kind of sounds you can create (ASFAIK) are the kind you'd
find in old-school space shoot'em ups.
Currently you can't save, load or export sounds to wave, so it's quite useless.
I plan to add that in a near future though.
I use [LINK http://www.fmod.org FMOD] to play sounds, I could've used DirectSound,
but I really like FMOD. It's possible you need some FMOD-dll to run it though.
You can download the program at [LINK http://www.rotd.org/amag/files/ssc.zip]
/Andreas Magnusson
(L) [2003/01/21] [The Ostrich] [n/a]
[LINK mailto:n/a The Ostrich]
This image was generated using two programs of mine. The first was my tree
generator program, and the second was my new raytracing engine. Neither is
yet complete - The tree generator requires some support for gravitational
constraints and moment sums, and the raytracer needs support for diffuse
interobject lighting and soft shadows.
The tree generator program uses a parameterised stochastic model to generate
the branches and leaf positions/orientations. Once the model has been
generated, the program outputs a script file of primitives (cylinders and
spheres for the branches, and references to a leaf subscene file for the
leaves). This is then read by the raytracer.
The raytracer sorts the scene (in this case about 100,000 primitives) into a
binary hierarchy of bounding spheres, using a minimum sum of surface areas
heuristic to evaluate 10 randomly chosen splitter planes for each split in
the hierarchy. The program the uses a depth rejection technique, where
spheres further away than the closest intersection found so far are rejected
without further evaluation. The image in question is a detail taken from a
2560x1920 top-down render of a tree model, with 9 directional lights, and no
ambient component at all. None of the primitives are textured, a fact which,
combined with the multiple lighting directions, gives the image a somewhat
'anime' feel.
The only part of the scene that was actually made by hand was the leaf model
(since I don't have a 3D editing package, I just typed the coordinates for
my design into a script file by hand).
For other examples of my work, see my website:
[LINK http://www.fractal-landscapes.co.uk]
-The Ostrich
(L) [2003/01/23] [JohanPeitz] [johan@freelunchdesign.com]
Alex the Allegator 4 is a classic 2D jump 'n' run combined with some tricky
puzzle solving. Guide Alex through the jungle in order to save his
girlfriend Lola from evil humans who want to make a bag of her.
Why is it in so few colors and in such a low resolution?
The IOTDs usually features terrain editors and amazing 3D-tricks, so I
expect some confusion. :) As you can see from the screenshots above, Alex4
runs in a spectacular resolution of 160x120 with only 4 colors. It's a
hardcore platform game in true Nintendo fashion and spirit. The extremely low
resolution and few colors puts advanced technical stuff to the side and
forces me (as developer and designer) to streamline the gameplay.
In order to pinpoint that old-school feeling, the game is accompanied by
chippy music and blipp-blopp sounds,
Alex the Allegator 4 will, when it's done, be released with full source
code, but so far there is only a two level demo available. Also, in the
final release, a level editor will be included.
Get the demo here: [LINK http://www.freelunchdesign.com/alex4.shtml http://www.freelunchdesign
.com/alex4.shtml]
Johan Peitz
[LINK http://www.freelunchdesign.com Free Lunch Design]
"Hardware is nothing, gameplay is everything."
(L) [2003/01/24] [WayneMike] [wayne4@blueyonder.co.uk]
This is a screen shot, from my recently completed screen saver project. It can be downloaded from:
[LINK http://www.scene.org/file.php?file=/demos/artists/fluid/fld_water.zip&fileinfo]
if the above link does not work then the scene.org admin have moved
the file to our main directory
[LINK http://www.scene.org/dir.php?dir=/demos/groups/fluid/] look for fld_water.zip
All code was done in Microsoft C++ and MASM.
The screen saver is 100% software rendered.
The only major problem i had developing the screen-saver, was trying to maintain a decent
frame-rate. The image cycling mode blends two images together in real time using no look-up
tables, at first i just used a standard linear interpolation something like the below:
c = (cb * t + cf * (1 - t))
that was done for every color component (r,g,b) on a 512x384 surface. yes it was slow, far to
many calculations were being performed to acheive the effect, in the end i put together an alpha
blending function using MMX instructions. the function works on two color components at a time
and the results were very fast. Infact i had enough cpu cycles left to perform anti-aliasing.
Screen saver settings include:
3 diffrent backgrounds,
and an image cycling option, that cycles through the 3 available backgrounds using alpha blending.
Hope you enjoy the screen shot, and screen saver.
Wayne Mike
(L) [2003/01/28] [NickVanTassell] [nvantas@bellsouth.net]
Greetings fellow Flipcoders!
It has been a while since my last IOTD was submitted way back in July
2000. Back then I was still playing with 2D gaming. Now I introduce
Retribution. It is a Battlezone II style game that I have been
creating since the beginning of summer. The features are pretty
extensive:
- A Billboard system for the grass and menu
A parameterized particle system for the rain and unit exhaust
A mesh manager system for the tree, tall grass, and unit models (All of which I created in 3DS Max - I know they suck!)
Geo-mipmap terrain complete with trilinear filtering (geo-morphing) as proposed by the paper by William DeBoar
The grass, sky dome, waterfall, particle systems, and bump-mapped pond are all animated
Editor allowing positioning and rotation of objects, billboards, particle systems, fogging parameters (color, pixel / vertex, start, end, depth, etc.), FOV, far clipping planes, terrain modifiers including parabolic raise / lower, and individual or group vertex modifications, and full load and save capabilities
Plus the usual stuff: pick rays for object selection, view frustum culling, and rudimentary occlusion culling
The terrain uses generated textures by taking into account terrain height, slope, and blending in of what I call a path map. The path map allows for the blending of additional textures that would not normally be generated just by taking height and slope into consideration.
The framerate is pretty pitiful, at only 20fps, but there is not much optimization between switching rendering states and texture stages. It is written using DirectX 8.1 and Visual C++ 6.0 with no MFC!
Please feel free to email me about any comments, suggestions, critiques, etc.
The next phase is to implement enemy AI using autonomous steering behaviors and a parameterized BOID system for flocks of birds and other animals.
Happy coding,
Nick Van Tassell
(L) [2003/01/30] [TobiasJohansson] [tobias_johansson@lycos.com]
This is a collection of screenshot from a platform-game called Gonny
Jr which we made as a 5-week gameproject in school.([LINK http://www.playgroundsquad.com www.playgroundsquad.com])
It is using RenderWare for graphics (otherwise 5 weeks would be really hard) and fmod for sound. It doesn't have lots of cool features, except maybe particle effects and a nice console (with a dir command which I really miss in most 'professional' consoles).
There isn't a demo available, and I'm not sure if there will be (I'm not too pleased with my programming ;).
The development team was:
Programming:
Me (Tobias Johansson)
Concept Art:
Christopher Brandstrom
Level Design, Modeling and Animation:
Carl Johansson
Emil Gustafson
Sven Forshell
Zilla Thorneny
Christopher Brandstrom
Music
Tommie Ravn
greetings Tobias Johansson ([LINK http://polygone.flipcode.com])
(L) [2003/01/31] [JohnPalevich] [jackpalevich@msn.com]
I was playing around with my new ATI 9700 card and the DirectX 9 HLSL, and I came up with this pretty Mandelbrot-based pixel shader.
Here's the fx file for the pixel shader. Just load it into the DirectX 9 Effects browser of the DirectX 9 SDK. (Available from msdn.microsoft.com.) Unfortunately, if you don't have an ATI 9500/9700 card, you may not see the exact same image. The beautiful color stripe pattern around the edge of the Mandelbrot set does not appear if you use the RefRast device. I think that the stripes are an artifact of the way the ATI pixel shader pipeline handels floating point overflow.
I would be very interested in hearing from GeForceFx owners how well this shader works on their card. If you have such a card, you might try increasing the MANDEL_STEPS constant, as I understand that the GeForceFX can do many more steps per pixel shader than the ATI 9700.
---- Begin jhp-Mandelbrot.fx
// Mandelbrot Shader effect file
// (C) Copyright 2003 by John H. Palevich
string XFile = "teapot.x";
int BCLR = 0xff202080;
// transformations
float4x3 WorldView : WORLDVIEW;
float4x4 Projection : PROJECTION;
#define MANDEL_STEPS 11
int TEXTURESCALE = 2.0;
struct VS_OUTPUT
{
float4 Pos : POSITION;
float2 Tex0 : TEXCOORD0;
};
VS_OUTPUT VS(
float3 Pos : POSITION,
float3 Norm : NORMAL)
{
VS_OUTPUT Out = (VS_OUTPUT)0;
float3 P = mul(float4(Pos, 1), (float4x3)WorldView); // position (view space)
Out.Pos = mul(float4(P, 1), Projection); // position (projected)
Out.Tex0.x = Pos.z; // Compute Tex0 U and V from position.
Out.Tex0.y = Pos.x;
Out.Tex0 *= TEXTURESCALE;
return Out;
}
float2 MandelbrotStep(float2 a, float2 t0) : COLOR
{
float2 result;
float2 a2 = a * a;
result.x = a2.x - a2.y;
result.y = a.x * a.y * 2;
result += t0;
return result;
}
float4 PS20(VS_OUTPUT In) : COLOR
{
float4 Color;
Color.rg = In.Tex0;
Color.b = 0;
Color.a = 1;
int i;
for(int i = 0; i < MANDEL_STEPS; i++)
{
Color.rg = MandelbrotStep(Color.rg, In.Tex0);
}
#ifdef CLAMP_COLORS
// Clamping is required if you want the output to look the
// same on both the Ref-Rast and the ATI 9700.
// But I've commented it out because it ends up
// getting rid of the beautiful stripe fringe effect around
// the main Mandelbrot pattern. (I guess RefRast
// and the ATI card do different things when handleing floating point overflow.
// Maybe it's the difference between 24-bit floating point and 32-bit floating point?
float dist = Color.x * Color.x + Color.y * Color.y;
return dist > 2.0 ? 0.3 : Color; // Replace color fringe pattern with boring grey.
#else
return Color;
#endif
}
technique TMandelbrot_PS_2_0
{
pass P0
{
VertexShader = compile vs_1_1 VS();
PixelShader = compile ps_2_0 PS20();
}
}
------- end of jhp-Mandelbrot.fx
(L) [2003/02/03] [NeilWakefield] [nwakefield@clara.co.uk]
This is a project I've been working on for the past four or so weeks (on
and off), also known as "Yet another goddamn Perlin terrain
implementation". It's basically a small hovercraft-like vehicle you can
drive around a reasonably large terrain, and. that's it.
From a technical point of view, it has quadtree/frustum-culled terrain,
particles and shadow volumes. It uses v2.0 pixel shaders for the sky
and terrain so while it will run on a Geforce3 or above, it will look
very strange if you don't have a recent Radeon or a GeForceFX.
The executable and sourcecode can be downloaded from my webspace at
[LINK http://www.bath.ac.uk/~py9naw/cv/demos.html]
I should say a big thank you to Tom Slezakowski for the textures, Si
Brown for the use of his spring-based camera (stolen WITH permission :)
), and everyone in the flipcode IRC channel (especially dirtypunk,
nuvem, psykotic and goltrpoat) for help, support, bug reports, and
general abuse about my pixel shaders not working on their graphics
hardware.
Comments are more than welcome (it's probably easiest to contact me in
the IRC channel).
NeilOfDoom
(L) [2003/02/04] [BartlSteinmayr] [alphastrike@gmx.net]
Alpha Strike is a classic, 2 dimensional, vertical scrolling
space shooter, with pretty impressive graphics. It is written completely
in Delphi using the DirectX headers from
[LINK http://www.crazyentertainment.net]
and a very small self-coded graphics
unit, that renders textures using simple planes in a orthographic
projection matrix. That way it uses full hardware acceleration for
filtering and blending. The game itself will be freeware, but is still far
from being releaseable.
At the moment, you can download a playable alpha version from my
[LINK http://www.alphastrike-retribution.de.vu homepage] (sorry, German) or
directly from [LINK http://mitglied.lycos.de/paranoidsoft/asr-alpha.htm]
If you have any comments or suggestions, please [LINK mailto:AlphaStrike@gmx.net mail me].
Sincerely,
Bartl Steinmayr
Please excuse my bad English.
(L) [2003/02/06] [JeffEvertt] [jevertt@msn.com]
Here's a screenshot from a little game I've been working on in my spare
time. I recently finished it and released it as a shareware game. When I
started working on it, I wanting to build a fairly full featured physics
engine. The game idea came later. Now that it's done I don't know if I'd
really call it full featured. It supports spheres, boxes, and polys and
all their combinations. It does do friction calculations for object to
object and object to terrain collisions. And it does have a nice
constraint system that works between any two types of physics objects.
One of the things I did that I would definitely recommend to others is
to keep your physics system on a separate update loop from your game
logic and render calls. Also, keep the separation of wall time and
simulation time separate and distinct.
The engine I wrote for this game can support about fifty to one hundred
objects bouncing around on a 1GHz machine. But, I'm sure I could squeeze
a lot more out of it - I didn't get around to doing many low level
optimizations since it ran fast enough for my game right off the bat.
One of the things that worked really well graphically (which is also
shown in this image) is the use of a mirror effect to end the game's
relatively small worlds. It fills up the unused screen real estate with
something interesting to look at.
I also had an interesting experience releasing a shareware game. I'd
love to discuss it with any other shareware game authors out there.
For more information or just to check out the demo, go to.
[LINK http://www.evertt.com]
Jeff Evertt
(L) [2003/02/09] [far_colony] [far_colony@hotmail.com]
This is a screenshot from my pre-alpha project Far Colony, a game of
space exploration and colonization in the 23th century. The screen shows
the user interface with the main view in opengl which contains the orbital
objects of the current planetary system and the selected planetoid
object at the center. To the left there's the main information panel.
This game is made with Delphi and GLScene for all the opengl parts. It
uses for all star systems the data calculated by a generator created
also in delphi, the result of a work based on variable sources as the old
software accrete for example.
The game will be freeware but no download is available for the moment
until a playable beta is out.
All the code and graphics are made by myself except for the textures of
the planets who comes from various sources.
You can visit Far Colony site at
[LINK http://far-colony.naskel.cx/index_en.html]
for the english version and
[LINK http://far-colony.naskel.cx/index.html]
for the french version.
For any comments you can mail me here: [LINK mailto:far_colony@hotmail.com far_colony@hotmail.com]
(L) [2003/02/10] [BjoernGdanietz] [bjoern@towernet.de]
These are screenshots from a project called "stuntcar racer 2001".
The aim of the project was to create a remake of the classic
StuntCarRacer from Geoff Crammond.
You can download the game at [LINK http://stud.fh-wedel.de/~stuntcar/download.html]
There are binaries for Windows and Linux. There was a
BeOS-Version also but I can't find it anymore.
The physics relies on a mass-spring-model and to accelerate the
collision-detection a quadtree is used. An octree wasn't neccerary
because the track never crosses itself (no tunnels).
The graphics-API is OpenGL. For the platform-independance
GLUT is used. There is a SDL-version also.
There is no sound.
There is no AI implemented, but you can record your own laps
and race against yourself. Recorded drivers are given in four
flavours: bad, normal, good, excellent.
To record the laps each keypress is recorded with a timestamp.
Unfortunately you can't exchange the files between different
binaries. It seems to be that an error in the physics accumulates,
so that the car is at the wrong position for the replayed
controlcommands. This can be caused by a slightly different
floatingpoint-code caused by different compiler-settings,
different compilers or different libraries.
If a float-value is internally cached by the FPU it is stored with
an higher precision and the result of the next computation not exactly
the same as it would be without the cache.
The game was a project during my studies of media-information science
at the University of Applied Sciences, Wedel - Germany.
This project was done in 2001 by Klas Kalass,
Christian Finckler, Claus Praefcke -who later ported it to
an IRIX-system to play the game in a VR-cave - and
me, Bjoern Gdanietz.
The car-model is based on a high-resolution model, designed
by Dan Schmidt, Olaf Ross and Bjoern Gdanietz.
-Bjoern Gdanietz-
(L) [2003/02/11] [MarcoPappalardo] [elmargo@skynet.be]
This is a small game I've been working on during my spare time from
work. It uses OpenGL for rendering, and DirectX for input and
audio. It features multitexturing, dot3 bumpmapping, stenciled
shadows, quadtree heightmaps, and nice glow and particle
effects. I've just made the game available for free download at
[LINK http://www.caprioli.cc/survivor],
Comments are very appreciated !
Regards,
Marco Pappalardo
(L) [2003/02/14] [EmmanuelICART] [EmmIcart@aol.com]
Some time ago I submited an IOTD of my TRACY engine, a realtime volume
renderer aimed at game programming. Here is my first game made with it :
FROOGZ, perhaps one of the first FPS in a fully destructible environment.
FROOGZ is basically a 3D evolution of the Liero/Worms kind of games. The
level maps are made of voxel/volume data, which makes realtime tunneling &
destruction very easy to program. Due to the nature of the levels, the maps
are relatively small to preserve memory (a 256x256x256 map data takes about
50 Mb RAM), which produces very intense deathmatchs.
On the technical side, I made 2 versions of the renderer: the software
renderer is a raycaster (a ray is thrown in the scene for every screen
pixel), while the OpenGL renderer is more classicaly based on a Marching
Cubes kind of algorithm. In order to keep the maximum flexibility for
realtime modification of the voxelmap, there is no data optimization, and the
OpenGL mesh is computed in realtime for every frame. Every voxel data holds a
color information plus a lightmap value. The lightmap is continuously
computed in pseudo-realtime, using a soft-shadow raytracing process (pseudo
realtime means I allow a dedicated time for each frame to the raytracer to
compute the lightmap. So the lightmap is not completly refreshed for each
frame, just some part of it according to the CPU speed). The sprites are made
of classic MD2 meshes.
The game itself makes use of a scripting engine/compiler. Every moving object
on the screen is controled by scripts (including particles), so that it
becomes possible to add new weapons, characters, game modes and effects
without recompiling the code. For the sound part, I'm using FMOD.
The top 2 pictures represent the software version of the game, while the 2
middle ones show the OpenGL version (including the old-fashioned anaglyph
rendering I love so much). And the last 2 pictures show the splitscreen
versions of the game (up to 4 players on the same screen).
FROOGZ is a freeware project, made using Borland Delphi. the current version
is 0.91. The final release is near, I'm currently working on adding some new
weapons and creating a nice helpfile for the SDK (so that adding new items
does not give a headache). The source code will be available as soon as the
v1.00 is out. You can download the current version (1.57 Mb) at:
[LINK http://froogz.free.fr/FroogzSetupv0.91.exe]
and here is the Froogz website: [LINK http://froogz.momorprods.co http://froogz.momorprods.com]
(L) [2003/02/16] [JosePlano] [j_plano@hotmail.com]
Hi I'm a member of a Game programing group in Argentina; this is the Particle
Studio (a.k.a. P-Deriko). I did this program to control the render FX of a
particle engine and save the FX in a propertary format to use in the 3D
engine. The exe "demo" is not available yet, because we are in the debuging process
:( but the oficial page of the group will be soon online with the engine
demo and the tools.... see you soon
(L) [2003/02/17] [ChrisC] [zppz@yahoo.com]
Here are some screenshots of a game I made last year
using OpenGL, ODE and FMOD. It's a race/rally game
(Win32) where you compete against the clock, but
instead of a car you have a little hover racer thingy.
The intention was to give an impression of great
speed, which turned out to be harder than I thought.
You can record a lap and watch your replay, all mouse
and keyboard input is recorded and the whole
simulation is calculated again for the replay, which
prevents cheating but made for some tricky bug-hunts.
Unfortunately the racer is pretty tricky to control at
first - a nasty learning curve but it makes the
high-scores more meaningful.
The bottom-left screenshot is of the in-game editor,
which is actually the same executable as the game. I
tried to make it as simple as possible for people to
make tracks of their own. The game and related info
plus some other stuff useful for gamedev can be found
at my website: [LINK http://zppz.homeip.net]
Partly to gain experience and try my hand at making a
'game engine', and partly as an exercise in willing
myself to follow through and complete a project for
once, this took about 6 months of my spare time.
(L) [2003/02/19] [windssoft] [techsupport@windssoft.com]
It's a tool for creating compelling lighting effects. By
using it, you can easily achieve professional lighting in a realtime
3D scene. It also has the ability for geometry
processing, tailored for light maps: group tanglesome triangles to
surfaces. This ability is especially useful for those scene
modeling with general 3D-Soft(for example,3dsmax,maya,etc). The
lighting data can be directly saved to BMP files, or output all data
of the scene to a custom format file through Export-Plugins. For more
details, read the manual on the website: [LINK http://www.windssoft.com]
(L) [2003/02/20] [ArasPranckevicius] [nearaz@centras.lt]
My colleague came up with an idea for shadow volume extrusion - if you want
to use simplified mesh for the volume and have self-shadowing - extrude the
frontfaces, not the backfaces!
The image on the top shows "conventional" shadow volume, where backfaces are
extruded. The bottom image has frontfaces extruded.
More on this technique and a small demo is at
[LINK http://www.gim.ktu.lt/nesnausk/nearaz/texts/revext.html]
(L) [2003/02/22] [EricGrange] [egrange@glscene.org]
A screenshot from the 'Archipelago' demo of GLScene ([LINK http://glscene.org], you can get the demo there,
along with Delphi source). Terrain rendering is a well trodden subject where geomipmapping and brute
force seem to have taken the honors recently... However, if the GLScene renderer is an hybrid
capable of mixing brute force tiles with dynamic Level Of Detail (LOD), this demo uses
view-dependant dynamic LOD exclusively.
Technical details:
- 512x512 heightmap at 16 bits precision
16 1024x1024x24bits terrain textures with detail map
tile-based, split-only ROAM dynamic LOD
animated waves, depth-based transparency
steerable sailboat with dynamic wake
basic OpenGL, nothing fancy, not even VAR/VAO, sorry ;)
You should expect more than 210 FPS on an Athlon 1800+ with a GF4 Ti 4200 at 1024x768x32, and this
figure is fill rate limited (140 FPS on the same CPU with a GF2 Pro in 800x600). The demo makes use
of the stencil buffer, so start it in 24 or 32bits desktop mode if you want to avoid software
rendering on some drivers.
The initial purpose was to showcase large textures (hence its size...), but it ended sweet enough to
demonstrate what simple dynamic LOD is capable of: most of the 512x512 heightmap is within visible
range in the demo, that would be 500k tris without dynamic LOD, which are reduced to 5k-13k by ROAM,
i.e. peanuts.
The landscape is fully tessellated by a split-only ROAM at each frame, using a tile-based
implementation close to what Bryan Turner describes in his Gamasutra article. CPU-wise, tessellation
itself takes a fat millisecond on a 1800+, the twist being that rendering starts before the
tessellation has completed, so it's not a wasted millisecond for the graphics hardware, especially
since the triangles being rendered are eating a higher than average share of fill rate.
The smaller wireframe image is a cutout from a wireframe screenshot, you can see that the triangles
on the far mountain have almost the same size as those on the nearby mountain (which is the whole
purpose of dynamic tessellation).
After the terrain layer comes a water layer, that renders wavy tiles over the visible terrain tiles
(reuses terrain tile culling), this pass is actually the range-limiting one in the demo (uses
several good-old-but-slow sin/cos per vertex).
Art credits:
- Terrain elevation map and textures by Mattias Fagerlund
([LINK http://www.cambrianlabs.com/Mattias/]), heightmap and sedimentation
maps created with World Machine from Stephen Schmitt
([LINK http://students.washington.edu/sschmitt/world/])
Sailboat model and textures by Daniel Polli
([LINK http://virtualsailor.dansteph.com])
Water and detail textures from Lemog's 3D Textures
([LINK http://www.3dtextures.fr.st/])
Wake texture is mine, behold programmer art! ;)
Eric Grange
[LINK http://glscene.org]
(L) [2003/02/24] [StephanReiter] [st_reiter@edumail.at]
Well, another landscape demo :-) Let me just inform you quickly what
my piece of work is capable to do:
- standard skybox, uninteresting ;-)
renders large landscapes with dynamic LOD - I'm using GeoMipmapping here ...
quadtree for frustum culling
the demo uses a static vertexbuffers + a dynamic indexbuffer for each 129x129 chunk ...
LOD is computed for each 33x33 chunk based on the distance to the camera
LOD of chunks, which go more into the direction of being flat, is scaled down - the second screenshot shows that pretty well ...
the borders between chunks of different level of detail are tesselated in such a way, that almost no gaps occur -> there are still some minor problems ...
the screenshots are based on a 1024x1024 heightmap with unique textures for each 128x128 patch, + a detail texture applied; rendered @ 32bit in a 800x600 window
runs at an average fps-count of 70 on my ole crappy 'puter ( PIII 450, GeForce 2 MX 400 <- *ouch* )
people that were as kind as to test the demo reported fps ranging from around 250(Geforce 4) to 60(Voodoo 3) - so it's pretty much optimized and let's room for other additions!
I still have no clue whether to build a small game around this landscape-engine or just keep it improving with no particular aim in mind ;-)
Stephan Reiter
(L) [2003/02/26] [PaulBaker] [paul.baker@university-college.oxford.ac.uk]
"The Octagon" is my game engine project on which I have been working for the last 6 months, on and off. It displays Quake 3 bsp maps, Quake 2 md2 and Quake 3 md3 models. All are lit using per-pixel lighting and bump mapping, and all surfaces cast stencil shadows.
There are two classes of light available for use. The first are standard point lights, and the second have projected cube maps. These can be used to emulate spotlights and anisotropic light sources.
Gross visibility testing is done using the bsp and frustum culling per sector. This is then refined by testing if each individual face is within the camera frustum. The same procedure is used to see which faces are lit by each light.
Firstly, everything visible is rendered with its decal texture multiplied by a small constant plus its emissive texture, in order to provide the base for adding light. Then, for each light, stencil shadows are cast for each object which the light influences, and then a hardware-specific codepath lights the surface.
After all of the lights have been handled, particles which emit light of their own are added to the framebuffer. Then, we loop through the lights again and draw any non-light-emitting particles (such as steam particles), lit by any lights which influence them.
The demo requires at least OpenGL 1.3 support and is available for download at:
[LINK http://users.ox.ac.uk/~univ1234]
Full source code is supplied with the demo.
(L) [2003/02/27] [IgorKravtchenko] [igor@obrazstudio.com]
Here is a snapshot taken from the game Star Ancestor currently in development at Obraz Studio.
There is no trick or final improvement on this image. It was captured directly in the game from a GeForce3.
For the technical side, you can notice here a massive use of [LINK http://www.flipcode.com/cgi-bin/msg.cgi?showThread=COTD-HDRImageReader&forum=cotd&id=-1 HDRI] for illumination, diffuse and radiosity.
Typically, we use a lightmaps exporter from our 3D Software -Lightwave 3D- and import them under our tools to be managed by the graphic's renderer through modulate context.
We use a proprietary 3D engine called OZOS (ObraZ Operating System) which is currently used for both RT applications and CGI previewing (pub, video clip, etc...).
You can grab more informations here : [LINK http://www.starancestor.com]
Igor Kravtchenko
OBRAZ Studio, Paris
(L) [2003/02/28] [vladv] [vladv@cfxweb.net]
These four screen shots are from my latest free-time project. I named
it "Island Tycoon", but I have a strong feeling that I'll change this,
because it just doesn't sound good. Anyway, the future game is based
on my engine, Un3D, and it is supposed to be a clone of Transport
Tycoon. First what the engine knows until now:
- landscape (LOD optimization based on the GeoMipMap paper here on flipcode), with splatting, quad tree clipping
extremely cool skybox (actually cloud plane, start plane and sun with sun flares)
ocean water
animated objects
primitive particle simulator (will change this, and because I don't like it, no picture of it)
a very complex spline generator (for roads, heightMap...)
texture shaders (simple ones, but nevertheless shaders)
network ready (not tested on a real network yet)
I'm using OpenGL, DirectInput and DirectPlay (quess for what)
The game knows until now how to handle roads, vehicles, vehicle orders (that means that they can go to "Station 1" and load 30 kilos of gold), factories (they work on scripts) and stations (that provide goods for vehicles and factories from other vehicles and factories). The roads are based on a quite complex spline generator, but very easy to manipulate. You actually have full control to what you can build (check out the upper right image).
The upper left image shows the landscape texture splatting thingy. The upper right image is a little older one and it shows some bridges (they are generated automatically when the road gets too steep or too high from the ground). The lower left image is an artistic one (in the distance two factories, and the road that connects them), and last but not least, the lower right image shows an oil drill and a station (please don't laugh at my poor 3DSMax skills).
Any more info, you can find at [LINK http://un3d.curvedspaces.com un3d.curvedspaces.com]. No demo YET, but I expect to upload one after next week (around 10-11 march).
(L) [2003/03/03] [MarkusIlmola] [ilmola@hytti.uku.fi]
Screenshots from my latest project called "Mole War".
Mole War is a first person shooter that takes place under ground surface in
fully destructable 3D environment. The players can dig their own tunnels
freely. Indestructible steel walls prevent the players from escaping too far
from the battle zone.
Features:
- Destructable 3D environment.
Lightning effects.
Skeletal animated mole models.
Level editor.
20 weapons.
Splitscreen-mode.
The terrain is created from voxel data by using the marching cubes algorithm.
Lightning effects are calculated per vertex in CPU (no vertex shaders yet).
Rendering is optimized using octree and some other tricks. Collision detection
is done with sphere-polygon intersection algorithm. All models are made with
Milk Shape 3D and the game itself is written in C/C++.
Mole War can be downloaded from my website: [LINK http://markus_ilmola.tripod.com]
If the site is down try this link instead:
[LINK http://personal.inet.fi/koti/markus.ilmola/mw20b.zip]
(L) [2003/03/05] [anton] [ant@butant.com]
Here is a screenshot of my cute little game for MacOS 10. It is called
BeeCells. The goal is to arrange six or more balls of the same color
together in a group. After balls are arranged they disappear. After
each turn the computer puts more balls on the board and your task
becomes more difficult.
Nothing cutting edge:
- Cocoa
Objective-C
of course Project Builder and Interface Builder
MacOS 10 rocks
Do you want me to port it to Windows ?
Do you want me to make 3D version of BeeCells ?
I might consider posting source code if enough people are
interested.
There is a very simple 3D OpenGL demo on my web site. It is a very simple
terrain with a skybox. It works both on MacOS 10 and Windows. I do not
know how it works on different machines and graphics boards. so I need
some feedback from people. Try it and tell me how it works. Also, a
Shaders demo is coming. There are screenshots on my web site.
Visit my web site: [LINK http://www.butant.com www.butant.com]
(L) [2003/03/06] [PaulBaker] [paul.baker@university-college.oxford.ac.uk]
"The Octagon" is my game engine project on which I have been working for the last 6 months, on and off. It displays Quake 3 bsp maps (including curved patches), Quake 2 md2 and Quake 3 md3 models. All are lit using per-pixel lighting and bump mapping, and all surfaces cast stencil shadows. It is written in C++ and uses OpenGL for graphics.
You may recognise this image as a similar one was displayed on the 26th of February. Unfortunately, the university network was down for 20 hours whilst the image was showing. Anyone who tried and failed to access my website should be able to visit it now.
The engine supports two classes of light, point lights and anisotropic light sources (with projective cube maps). Gross visibility testing is done using the bsp and frustum culling per sector. This is then refined by testing if each individual face is within the camera frustum. The same procedure is used to see which faces are lit by each light.
Firstly, everything visible is rendered with its decal texture multiplied by a small constant, plus its emissive texture, in order to provide the base for adding light. Then, for each light, stencil shadows are cast for each object which the light influences, and then the hardware-specific codepath lights the surfaces.
The engine currently supports three different codepaths, which are used to take advantage of the capabilities of the hardware on which the engine is running. Only the lighting calculations are dependent on the codepath used.
There is a standard codepath which uses only core OpenGL 1.3 features. This provides diffuse lighting in three passes per light.
The NV20 codepath uses ARB_vertex_program, NV_texture_shader, NV_register_combiners and EXT_blend_color to reduce the number of passes required on nVidia Geforce3 and above hardware. It also introduces specular highlights.
The R200 codepath uses ARB_vertex_program and ATI_fragment_shader, along with the 6 texture units available on Radeon 8500 and above cards from ATi to evaluate the entire lighting equation (diffuse and specular) in a single pass.
The geometry uses up to three texture maps for each surface. As well as the standard color map, each surface has an emissive map, and a normal map for the bump mapping. In the alpha channel of the normal map, the gloss map is stored. This is used to modulate the specular lighting to produce surfaces which are shiny/not shiny on a per pixel basis.
After all of the lights have been handled, particles which emit light of their own are added to the framebuffer. Then, we loop through the lights again and draw any non-light-emitting particles (such as steam particles), lit by any lights which influence them. If a light which is illuminating a particle system has a projected cube map, this is also taken into account, as can be seen by the stained glass window in the image.
If available, NV_vertex_array_range or ATI_vertex_array_object is used to increase vertex throughput. This does provide a benefit, but not a huge one since the major bottleneck is fill, not vertex transfer.
The demo and full source code are available from [LINK http://users.ox.ac.uk/~univ1234], where you will also find my other projects and my "simple bump mapping" tutorial.
(L) [2003/03/07] [EricGirard] [e.girard@worldonline.fr]
This demo is written in C++ under MS Visual C++ 6 and use the SGI OpenGL API. It groups together my lastest knowledge
for deep-water animating and rendering, in particular:
- FFT (Fast Fourier Transformation)
Surface Dynamics
Navier-Stokes
Water optics
Dynamic Foam
Another one feature of the PhysicsEngine in work actually is: Level geometry modification used mechanic laws, in concrete terms, if for example
the player launch a rocket to the base of a guardsman tower, according to the point of impact, the latter can lead in her fall as well other elements,
like a second nearby guardsman tower or headquarters down below. (reserved for the players that like radical methods better than infiltration !)
The development tools used for this game are MS VisualC++ 6, 3D Studio MAX 4, Valve StudioMdl, Milkshape 3D 1.5, Ulead PhotoImpact 3, Adobe Photoshop 6, Gimp 1.2, etc... And i have programmed two personal softwares: Aurora Editor (Level editor) & Pathfinder Editor (Bots path/waypoints editor).
I'm a 20 years french student and my diploma certificates are:
- School - leaving diploma of general mechanic
GCE of science and industrial technology with mechanic speciality
I'm actually at University for general studies of mathematics, computer and applied sciences. (DEUG MIAS)
My holiday season job is formative in informatique centre and i hope to work in the computer games industry in the future.
Download of this demo is available at my homepage: [LINK http://whitenight.chez.tiscali.fr/]
For contacts & feedbacks write at: [LINK mailto:e.girard@worldonline.fr e.girard@worldonline.fr]
Regards,
Eric "Whitenight" GIRARD.
(L) [2003/03/10] [JoshTippetts] [vertexnormal@email.com]
This is a screen grab of an isometric, OpenGL rendered 2D
dungeon-hack/maze-crawler I'm calling ShadowLands. Based (roughly) on
a largely abandoned graphical rogue-like I was once coding called
OGRESlash, this new iteration moves from turn-based to real-time
Diablo-style gameplay. It includes several types of randomly generated
mazes, including outdoor groves, fields, caves, and towns.
ShadowLands represents a new step in 2D for me, in that I've
discovered the wonders and pleasures of Blender as a 2D art
generation tool, and no longer have to content myself with blotchy,
smeary artwork hand drawn with the Gimp. Zeke (the moving statue
with the lightsaber) has the dubious distinction of being my first
rude attempt at character modelling and animation using Blender, and
so is cursed with stilted movement and a gimp leg, not to mention an
unnatural stiffness of the spine, skin that looks like marble, and a
large set of donkey ears.
My set of usable artwork at present is pretty sparse, and although
OGRESlash was fairly mature, ShadowLands is severely broken in terms
of functionality, as I've been forced to re-write large portions
from scratch to accomodate the switch from turn-based to real-time,
and from straight-on view to isometric. But between work, real-life,
and sleep/mealtimes/showertimes I am slowly but steadily making
progress.
No website up yet-- not until I have more to show and am ready to
release a version for download.
Currently, I am developing under Linux and SDL/OpenGL, and while I
haven't tried a Windoze port, I plan to include such a port in the
future, when I've had a chance to blow the dust off my old Windoze
box.
Please feel free to email me with any comments or criticisms. (Just try not to be too hard on poor Zeke. He suffers from enough severe emotional and self-esteem problems as it is. :)
VertexNormal
(Josh Tippetts)
(L) [2003/03/13] [LordTrancos] [lordtrancos@softhome.net]
This image shows what can be done with my lastest work; know as Pulsar LMTools.
Pulsar LMTools is a set of tools developed with Borland Delphi/Kylix
that are used for generating lightmaps. The license is GPL, so full
source code is included with Win32/Linux binaries.
Features:
- Direct Illumination.
Light Types: ambient, direct, omni and spot.
Although uses a custom (but easy and documented) 3D file format,
Direct3D .X and Autodesk
3DS converters are included.
Textures used as input (not always needed) must be 32bpp TARGA.
Textures output can be; 16bpp & 32bpp TARGA, and 24bpp Windows BMP
Octree for speed.
MaxScript for exporting 3DS Max/GMax lights.
LMTools can be downloaded from next sites;
Temp. mirror, recomended;
[LINK http://personal.telefonica.terra.es/web/afx/lmtools/]
DXLab page (in spanish but has an english section; just click on the
UK flag);
[LINK http://www.dxlab.tk]
[LINK http://dxlab.host.sk] (dxlab mirror)
(L) [2003/03/16] [MatthewMTrentacoste] [matt@squarewithin.com]
Tempest started as a class project which I then rewrote to utilize the new
functionality available with DirectX 9 as a means to learning the new
features in the API. It is designed to run on an ATI Radeon 9700, and does
not contain much in the way of fallback paths. I have not had the ability
to test the game on any other cards, but any card that adheres the DirectX 9
specification should work. The game is designed around trying to make high
level shader programming easily accessible as a means to controlling not
only render state but that of the objects it is used to render.
The main feature is an AssetManager class that is given paths to .fx files,
which it then loads, binds variables using a similar semantic to the DX 9
SDK EffectEdit sample. It will also load textures and models referenced by
the file, and provide a simple interface to rendering loaded meshes, which
providing a more robust interface for rendering arbitrary primitives while
managing the state internally through the Effects. This provides access to
the majority of methods through a simple high level control and frees the
programmer from the responsibility of having to create all of the required
texture and model objects by hand.
It does not currently contain various aspects usually found in games such as
spatial partitioning, as my goal with this demo was to focus more on
utilizing as much of the GPU's abilities as I could. Also, the format of
the levels is such that other methods become more efficient at determining
visibility, and avoiding the need for more complicated methods.
The track is constructed from two Catmull-Romm splines subdivided to a
specified level of detail. It aligns the cross-section spline along the
skeleton spline at each point and creates the skin of the object. Because
it is constructed from 2 splines, it can be parameterized with two
variables, giving a very simple way of updating positions of objects on the
track in a reduced parameter space and avoiding the need to collision detect
between the track and objects since they are fixed to it. It can convert a
parameterized position to a 3D transformation to render the model.
It utilizes various other DirectX 9 features, and contains such effects as a
projective texture headlight for the ship, intricate texturing methods
through dependant reads in the pixel shader pipeline, and using occlusion
queries for determining the state of various entities in the game and how
they react to the player.
The majority of the configuration is data-driven and a game can be setup
through a series of text files to configure the game state and effects files
to configure the render state.
I have not done much play balancing at the moment, as the game is more akin
to a visualization than a robust game. Though in my opinion it is quite
hypnotic. There are many things that can and should be optimized or made
more elegant. The game allows me to easily extend it to introduce new
entities and how they are rendered, which was the goal.
The source code will only run on a 9700 or comparable card, and is in some
serious need of documenting and cleaning before it is good enough to be
released. Please direct any inquiries to [LINK mailto:matt@squarewithin.com matt@squarewithin.com].
(L) [2003/03/18] [Chris] [chris@barney.zapto.org]
This was written for the LGP devcompany competition
[LINK http://www.linuxgamepublishing.com/devcompany.php]. In short,
linuxgamepublishing wanted a team of 8 developpers to create a Linux
game (potentially cross-platform also) for which they guaranteed
publishing. One part of the application was "to do soemthing cool in no
more then 2K". This is a really odd thing since the 2K actually refers
to source code characters (excluding "\t\r\n "). Henceforth what you're
looking at now is a falling snow demo written with SDL/OpenGL. Of
course it looks better when it's animated, since it's written with SDL,
Windows and Linux users alike may check out the link posted above in
order to check it out (source code only).
On the technical side of things, the snowfall animation is done in a cpu
speed independant fashion and is based on a random angle diffrenciation
method. most old-school snow demos were simply doing a random
positioning diffrence of the snowflake but this doesn't look too good
since it doesn't do a smooth transition (ie: it can jump from x += [-10
to +10]). By using the angles as a diffrence, we can basically
guarantee that the transition will be smooth since the angle can only
change of so much per seconds. Besides the animation, the flake itself
is a texture which is generated on the fly. I'm using a Korn fractal to
generate the bounding pixels for the fractal and then, I use a floodfill
algorithm to add transparency around the white flake. All of this is
done with less 2000bytes. You can also take a look at the other
finalist's sumissions at the web site. Some are pretty impressive
considering the contraints.
Chris
(L) [2003/03/20] [KjellAndersson] [kand@lysator.liu.se]
This IOTD shows the texture creation tool "Caustics Generator".
Caustics can be described as the light pattern you see at the bottom of a
pool on a sunny day. This tool will let you render such caustics patterns.
The rendered images can be animated and used for realtime graphics and
are tileable in both space and time.
Caustics are caused by the fact that light is reflected or refracted one
or several times before actually hitting a surface. The more light that
is refracted to the same area on a surface, the brighter the area will be
lit.
The patterns rendered by this program are calculated by simulating the
effect of light refracting through water. The water surface is made
tileable in both space and time in order to make the rendered images
tileable.
You can change the rendered pattern by altering several parameters such
as water depth, amplitude, wave frequency etc. Some examples of rendered
textures are shown in the image above.
The rendered images can for example be used as realtime textures for
games and animations.
The program is released as GNU GPL and can be downloaded from:
[LINK http://www.lysator.liu.se/~kand/caustics/]
/ Kjell Andersson
(L) [2003/03/23] [MaxShelekhov] [mail@ghoulisharts.com]
This image shows some sci-fi 3D model collections: Aircrafts. Alien
Invasion. Hovertanks. Buildings. The models were created in 3DsMax 5.0,
and the Textures were painted in Photoshop 5.5. All models are lowpoly
under 1k each, textured with 512x512 textures. They're ready for use in
real-time engines and games.
If you're interested in buying them, they're available [LINK http://www.ghoulisharts.com/buy.html here] at reasonable
prices. More information is available on my web site here:
[LINK http://www.ghoulisharts.com www.ghoulisharts.com].
(L) [2003/03/25] [AlexanderFestini] [alexander.festini@web.de]
The terrain renderer was written as part of a project thats being
worked on by some students of the university of Ulm ( [LINK http://www.neverending-
odc.de/ http://www.neverending-odc.de/] ). After not caring about
terrain at all I was surprised how well it went and worked on it just
for fun every now and then (the total time invested might be about 2
months full of afternoons).
I wanted to write something that wouldnt immediately look like someones first terrain and also something that would avoid the things i hate in games.
Sharp edges from low poly landscapes and reloading all the time and having me wait to play on. Also LOD popping is still kind of annoying, though
its visible rather on the texture than the geometry. Most problems are probably well known to everybody who wrote a terrain engine: memory is never
enough to support to view distance you would want, there's always too few texture units and the result will never look good enough, especially not
from far away and close up the same time. And of course, not knowing how much CPU power the rest of the game would need, I wanted to use
only the absolute minimum and let the graphics card do the work. Which of course ended with GeoMipMapping and looking for Occlusion Culling
that wont require much CPU time or memory (and im still searching).
The result is GeoMipMapping with 5 LODs, a potentially endless world with always 9 heightfields (513x513) in memory and a view distance of about
2km (though after placing the terribly redundant texture coordinates somewhere else i might double this and use 1025x1025 heightmaps). A
Quadtree will speed up culling later on (not making much difference with the time for about 600000 squareroots to spare each frame right now). It
features a slightly buggy but extremely cheap Occlusion Culling thats using its own low res zBuffer and likes to cull visible parts when the camera
gets close to steep walls.
Though the viewing distance is not as far as i want right now it keeps you from seeing the new parts of the terrain being loaded and created (you
can though, if you turn off fog and enable far view). It might look like its just moving parts around, because every heightmap is the same but its
reading the heightmap and the textures from hard disk and creates the geometry on the fly by only creating a few chunks each frame.
There arent many tools yet, just a simple one to create lightmaps and normalmaps from a heightmap and a quick hack to make sure there wont be
seams along the edges of the heightmap.
Textures and heightmaps were taken from other terrain engines so i could compare them a little better. The sourcecode is free though as its neither
special nor commented, but of course if anybody is interested i wouldnt mind to clean it up and add some comments. Current version and source
can be found here: [LINK http://festini.device-zero.de/downloads/index.shtml]
(L) [2003/04/01] [SaschaWillems] [webmaster@delphigl.de]
Ave Flipcoders!
After watching your IOTDs from almost the beginning of flipcode, I was a
bit disappointed that almost every IOTD has gotten something to do with
a project written in C/C++, so I decided to show you some screenshots of
my actual project that I'm programming in Borlands Delphi.
On the screenshot above you can see three different maps from
NapalmBomber3D, a 3D-Bombermanclone entirely written in Delphi that uses
OpenGL for graphics and the FMOD-Lib for sound.It took me about a week
to finish (including graphics and 3D-Models) and beside the game I've
also started writing a series of tutorials on programming a
bombermanclone.Those tutorials will be released on the
[LINK http://www.delphigl.com Delphi-OpenGL-Community], which is a german
page dedicated to OpenGL and Delphi (hence the name ;-) ).The first tut
in this series is already up, and the second one will follow in the next
few days.
Enough smalltalk.Let's talk about the technical side.As mentioned twice,
it's totally written in Borlands Delphi and uses OpenGL for it's
graphics.Sound and music are played using the famous FMOD-Library.The
3D-Models you can see (Players, Trees, Bombs) are in the 3DS-Format und
then loaded into the engine as displaylists.No keyframeanimations yet,
but this may change in a future release.
Other techniques used are Timebased Movement, textured Fonts and
animated Explosions via Billboards.
As you can see, there are no fency ultra-bombastic-geforceFX
rendertechniques in the game, but what I think is the most important
thing : IT'S FINISHED! (Besides some additions in the future).
You can grab your copy here :
[LINK http://www.delphigl.de/nbomber3d/NapalmBomber3D_Alpha.zip]
It weightens 2.56MByte, and comes with 6 maps.The mapeditor is also
finished, and I'll upload it as soon as I've written an "How-To-Use" and
as soon as it's translated into english, so that you can make your own
map.And now download it, have fun with it and please tell me what you
think of it.
For future updates visit my page : [LINK http://www.delphigl.de]
And if you're speaking german then also visit [LINK http://www.delphigl.com]
where I'll publish the bomberman-tutorial series.
(L) [2003/04/04] [DavidFrey] [dfrey@bellsouth.net]
GridWar is my first complete PC game. Over the years I have tried
making some kind of game but always ended up with "engineitus", the
symptoms of which are the repetitive creation and abandonment of
partial game engines. But with age, discipline has become more
important to me, so one day I decided to just pick an idea, go with
it, and stay focused. I resisted the temptation to do other things as
much as I could, no matter how boring the coding got when writing the
necessary yet mundane elements. There is nothing at all special or
unique on the technical side of things of this game, it is just a
simple DirectX 8.1 game, using Direct3D, DirectInput, and DirectMusic
interfaces. The game plays like Battleship, but with a little
twist. It supports single player and multiplayer via tcp/ip. The game
is available at my personal webpage, [LINK http://bellsouthpwp.net/d/f/dfrey69]
Thanks,
David Frey
aka Mastaba on the Flipcode forums
(L) [2003/04/08] [MarkVince] [henrytheninth@hotmail.com]
These screen-shots are taken from BrindFX work-in-progress '1944' demo. The
demo has been put together to highlight features of the XNS engine. The demo
is of a (huge) island and features a beach-landing battle, village area,
farms, minefields, railway, railway yard, military compound and much more.
Where this differs most from some other games in
this genre is that EVERY structure (including trees, bushes etc.) are
destroyable in a completely non-scripted fashion.
Advanced hierarchical modelling methods are used to create buildings which
can be destroyed exactly at the point of impact of rockets and mortars.
This is combined with an intelligent collision system which relies on the
original object geometry rather than simplified meshes so that the player
can do things such as blowing holes in structures and leaping through them,
buildings can be destroyed to the point of
individual bricks, rafters etc. while maintaining respectable frame-rates.
The landscape is created using 'volumetric feature editing' - a technique we
have developed for applying features with geometric shape constraints such
as roads, ditches, and so forth on to a noise-based
base terrain. This terrain is fully deformable ( rockets, mines and mortars
all produce craters) and is rendered using a proprietry CLOD algorithm
generating triangle strips.
Models such as buildings are developed and exported as X files and
pre-processed into their optimised and exploding representations.
The support routines necessary for AI ( enquiring about collision,
visibility etc.) are all complete and we are now developing our character
animation system and hope to have it integrated shortly.
All foliage moves in the breeze casting shadows and sounds and effects can
be 'painted' onto areas of the environment to enhance atmosphere.
We are also close to completing a racing-game demo using this technology
where you can enter or leave your vehicle, launch rockets into spectators
and so on, and are investigating the feasibility of a
Medieval castle / war game where highly detailed castles can be sieged,
attacked, destroyed etc.
(L) [2003/04/09] [fries] [friesdadude@crosswinds.net]
This is an engine ive been working on for the past couple of weeks. It features mainly per pixel lighting: diffuse bump and specular bump, with distance attenuation. Every light also has a cube map projection texture associated with it to do other cool special effecs like spot lights. There are still bugs with the engine and lots of things to fix and implement. Ive also only implemented the NV15 codepath, the other codepaths will come as soon as i get the hardware, ive only got a gf2MX ;) (i cant wait till i find the money to get a 9800 pro 256 ddr2) heh.
The engine is also fully controlled via scripting with LUA (the best scripting language around).
This makes it pretty flexable...
Other than that theres not much too it... Still in early early development, and it needs a lot of cleaning because the code is getting pretty dirty.
Oh yes... If anyone wants to make a nice model of a human face for me,
for free ;) they are more than welcome. It needs to have wrinkles in
the skunk and also skin pores, quite detailed, and good quality. I
would like the extra surface detail in a normal map as well ;) and the
mesh itself to be about 500-1000 polygons. Hair doesent matter, he can
be bald. Textures also required, with a specular reflection/gloss map
;) Well, email me at [LINK mailto:friesdadude@crosswinds.net friesdadude@crosswinds.net] if you feel like helping out :>
Thats all i guess...
-Luke (fries) Mamacos
(L) [2003/04/11] [KurtMiller] [junk@flipcode.com]
The above mess of colors represents a screenshot from Paint Defense,
a new game just released by [LINK http://www.gradientstudios.com Gradient Studios].
Not exactly the sort of game that folks might've expected to follow
Strayfire, but hey hey.
The official PR-ish description, goes like this:
Paint Defense is an action-packed painting game for both the artist and gamer
in you! Put your speed and creativity to the test in this wacky, addictive, and
wildly colorful painting game! For each level, you're presented with a picture outline.
Your goal is to use the mouse to paint over the outline. What's the catch? Hordes
of crazy distractions, from tanks to trucks, try their best to completely
disrupt or erase your painting! Its pure painting madness!
Exclamation points galore. Anyway, the game runs under Windows
and was written in C++ with MSVC6. Its a 2d game running in a DIB window.
The sprite scaling/rotating is performed via texture mapping.
Many months ago, I slapped together a concept demo in my free time
to test the fun factor of the idea, but once I decided to implement the
full game, the actual development time was about 2 months (doing the programming, art, and music myself.)
Most of the little tips I wrote about in my Strayfire
[LINK http://www.flipcode.com/misc/sfarticle/ post-mortem]
held true for me. For instance, the editor in the screenshot was one of the
first things I wrote, which lasted through the project's completion
with no major changes or headaches. And again, the most frustrating "grunt work" parts were
level content development and the dreaded bug-fixing / polishing phase.
Compatibility testing seemed to be much easier with a 2D game,
but I can't say that for sure yet since the game demo was just released
to the public yesterday.
If you want to check out the free demo version, swing by [LINK http://www.gradientstudios.com/paint/ here].
I hope you like it.
I've successfully run it with wine under Linux, but no promises there.
Kurt Miller
(L) [2003/04/14] [MatthewJ.Stephens] [mstephens@labyrinth.net.au]
I have been working on and off on a scripting language which allows you to compose interactive dynamic computer generated environments which I have called Vanilla.
Vanilla loads and displays 3D models, animations and sound then allows you to move them and virtual cameras around in various ways.
It uses still uses DirectX 8.1, eventually I hope to have the time to upgrade it to DirectX 9.
From a script, that references media, you can set up multi-texturing, environment mapping, motion, collisions, emitters, particle systems, volume shadows and some other stuff.
Most entities have a particle or locator associated with them which can be accellerated by various forces over time. For example you can set a center and force of gravity then assign locators to be affected by it over time.
After a while on this project a sense, process and respond structure emerged which is analagous to a nervous system. Within the script sensors can be defined which detect various changes in the environment. Synthetic neurons can be defined which trigger custom responses when specified sensors are activated.
Responses can be used to inhibit or excite geometry, dynamics and other sensors.
Vanilla can load and run skinned key-frame animations although I have only got the tiny.x from the DirectX sample in my example as I am well aware of how involved creating a skinned animation is.
I have documented much of the script which is a *.chm file.
You can download Vanilla from [LINK http://www.labyrinth.net.au/~mstephens www.labyrinth.net.au/~mstephens]
Matthew J. Stephens
(L) [2003/04/16] [anton] [ant@butant.com]
Here is screenshot of my cute little game called BeeCells3D.
Maybe some of you remember my last Image of The Day. It was posted on
[LINK http://www.flipcode.com/cgi-bin/msg.cgi?showThread=03-05-2003&forum=iotd&id=-1 March 5th].
A lot of people enjoyed Mac version of BeeCells.
One person wrote to me: "I've been playing BeeCells and put Warcraft
III to one side for a while...."
Today I am showing to you 3D version of BeeCells for Windows. It took
me few sleepless nights to make BeeCells3D. I wish a day has 36 hours.
The goal is to arrange six or more balls of the same color together in
a group. After balls are arranged they disappear.
After each turn computer does put more balls on the board and your task
becomes more difficult.
Nothing cutting edge here:
- OpenGL rocks
MFC sucks
C++ is ok
In the future BeeCells3D will have some nice effects. Imagine chrome
balls, furry balls, glowing balls, bumpy balls...
I will finish basic version of BeeCells3D first and I will be adding
effects one by one.
It will be some kind of proving ground for new shaders effects.
BeeCells3D is cross-platform and runs on MacOS 10 too.
On MacOS 10 I use Objective-C++ to glue Cocoa and C++. (Objective-C++
is a very strange beast)
You can download Windows version from my web site:
[LINK http://www.butant.com/beecells3d www.butant.com/beecells3d]
I am going to post MacOS 10 version of BeeCells3D soon.
Enjoy. It is free.
(L) [2003/04/18] [BartWyatt] [bwyatt@cyberonic.com]
This is from a game demo I recently produced. The image really doesn't
do it justice as in motion the fan turns causing a shadow to drift
across the board (ala Carmacks reverse and some vertex shaders for
shadow volumes), the green guys jiggle, and the lightning arcs nicely.
The game is Antivirus and it's a basic puzzle game. I used its creation
to try out Cg as well, so it makes use of some Cg vertex shaders. It
took me about a week from concept to demo, including learning the ins
and outs of Cg. Here's a quick rundown of the features:
- Vertex Shaders : NVIDIA and ARB vertex program extensions through Cg
Dynamic textures : rendered real time with bound Pbuffers
Noise Deformation : deforms vertices over time via Vertex shaders
Vertex blending : creates smooth transitions between node states
Random Lightning : interesting & random arcs based on noise
Shadow Volume extrusion : dynamic via vertex shaders
Dynamic Shadows : Zfail/Carmack's reverse for robust shadows
Fullscreen glow : using Dynamic texturing
If you want to download it from the link below but be warned it requires
you to download the Cg Compiler (10megs) from nVidia (link in the
README.txt) and have a card that is supported (GF3+, Radeon 9200+).
Usual disclaimers apply, feel free to send me comments.
NOTE: The Cg scripts are plain text and compiled at runtime that's just
how Cg likes it. I don't want to hear anything about poor commenting or
formatting in them ;). Also don't try to learn from them I am an
obfuscated coder and these were my first Cg scripts.
[LINK http://www.cyberonic.net/~bwyatt/antivirusGL.zip]
and if you don't have the Card to run that version you can download the
basic version which has all the gameplay with none of those nasty
graphical candies (or instructions for that matter):
[LINK http://www.cyberonic.net/~bwyatt/antivirus.zip]
Editor's note: If you're having trouble with the links above,
the downloads are available [LINK ftp://ftp.flipcode.com/demos/iotd-04-18-2003_antivirus.zip here] (831k) as well.
-bart
(L) [2003/04/20] [PatrickKooman] [patrick@2dgame-tutorial.com]
Here are some screenshots of our completed Asteroids clone. I created it
together with Leonard Schreur, who did the graphics. The gameplay is very
alike Asteroids, maybe except for the "boss" stones :-)
We created it to get more practice in 3DS Max (Lenoard) and SDL and its
related libs (me).
Some features:
- Antialiased Sprites
Pixel-precise collision detection
(Cross) fading using alphablending
Technical:
The game is programmed with C++, SDL, SDL_image, SDL_mixer and BFont.
Because of all the pixel operations (antialiasing), and (on most hardware)
non-accelerated alphablending, all rendering happens onto a software surface
(all images also reside in system memory). After each frame, the software
surface is copied to a hardware double-buffer, which is then flipped, so we
still get synchronized blitting.
For more information and downloads, please follow this link:
[LINK http://www.2dgame-tutorial.com/sdl/asteroids/asteroids.htm]
(Please note: Windows version only!)
Patrick & Leonard.
(L) [2003/04/21] [DerekJones] [funkmasterjones@hotmail.com]
If you know anything about Java, its that its really really slow with 3-d or any type of pixel graphics. I want to make games that are at least some-what playable on low-end machines, so I decided to use vector graphics. Theres very few vector engines in java (or any language for that matter) so why not make one.
The engine's be rewritten a couple times and resused in just about every game I've made. This game i started about a week ago and I've focused on making the code as modular as possible since the start.
Features:
- True 3-d vector graphics
Mesh Morphing (top image)
Collision Detection
Mesh Explosion (takes a model and blows it apart into a million pieces)
Realistic AI (not the smartest, but feels like a person)
It's an action-strategy hybrid with an open-ended world. You can make money by completed missions or becoming a pirate, then you can upgrade your weapons,ship or even by AI controled teamates.
Derek Jones
If you want a copy then you can email me at: [LINK mailto:funkmasterjones@hotmail.com funkmasterjones@hotmail.com]
(L) [2003/04/22] [ChristianSchuler] [cschueler@teamtoro.de]
[LINK http://www.sabotage1943.com Sabotage 1943]:
Cold. Sinister. Unimaginable.
Sabotage 1943 is an upcoming sneak 'em up, and working for this project is
actually quite enjoying and satisfying. Here are some screenshots of my
robust stencil shadow engine that I worked on since september. All images
show original content.
The pictures in the top row show the effect of moving a light source (it's
actually a tyre as you can see on the second picture) behind the door. The
engine tries to use depth-pass shadows as much as possible and reverts to
depth-fail otherwise. It is also using kind of shadow volume intersection
optimisations like the ones recently presented in NVidia papers.
The pictures in the bottom row show the dynamic occlusion culling in action.
As the camera moves to the right, some distant objects are occluded by the
wall in front of the viewer. The little b/w-image in the bottom screenshots
is the content of the occlusion buffer while the red outlines are the edges
of the shadow silhouettes. To save as much fill-rate as possible, the shadow
volume of each object is tested against the occlusion buffer separately. Of
course the bounding volumes of the light sources are tested as well.
(L) [2003/04/24] [Respawn Games] [n/a]
[LINK mailto:n/a Respawn Games]
Bubble Bomb is a highly addictive puzzle game brought to
you by
Respawn Games. This is our first game so we decided to start small
and go with a traditional 2D game.
The game itself is written in [LINK http://www.blitzbasic.com BlitzBasic], which I
cannot recommend highly enough for those looking for a fast, stable
development environment.
For people looking to quickly develop games, Blitz really can't be
beat. A quick example would be displaying an image on the screen. 4
lines ...
Graphics 640,480,32
id = LoadImage( "c:\texture.tga" )
DrawImage( id, 0, 0 )
WaitKey
This turns on the graphics screen, loads a texture, displays it and
waits for a keypress before returning to the desktop. Simple and
bloodless.
This game doesn't feature anything really fancy in terms of graphics
tech but it plays smoothly, runs fast and the UI is solid. Pretty
good for a first project!
You can download a demo of the game at
[LINK http://www.respawngames.com/bubblebomb www.respawngames.com/bubblebomb]. You can also register and get the
full version if you like what you see in the demo!
(L) [2003/04/25] [LorisBognannni] [loris128@libero.it]
Again, landscape stuff!
These are some screenshots I took from a new program i am developing for learning purposes, named ShadowCaster.
Its function is simply to create colormaps and lightmaps for a 256x256 terrain.
Lightmaps are created using a raycasting technique: rays are shot from
a definable light point to the borders of the heightmap.
The first four images show the integrated 3D viewer (uses OpenGL).
The bottom-left shot shows a lightmap created with the "embossed" technique, while the bottom-right image shows a lightmap created using a cos-like function (i.e. the shadow intensity decreases with a cos function).
The program is made in VB (for shorter dev time...)
These are the features of ShadowCaster:
- Five shadow generation techniques
Two texture generation techniques
Four blending techniques (used to blend the shadowmap with the colormap)
You can set the position of the light emitter in any point of the map
Customizable shadow decay(length) and darkness
OpenGL 3D Viewer (needs a LOT of optimizations!!)
Currently limited to 256x256 maps :(
If you are interested in ShadowCaster, please come visit my web page at
[LINK http://www.freewebs.com/gljakal/]
Loris Bognannni (glJakaL)
(L) [2003/04/28] [AaronHilton] [videogamer@shaw.ca]
These images show a ray casting engine I wrote last weekend (April
18-20). It was a fun and short project to simulate a laser striking
some scene elements (right now only spheres). The engine uses SDL for
input, timing, and graphics initialization, and OpenGL for the 3D
acceleration. The first image shows a simulated laser emitter striking
a large sphere, which in turn bounces a few rays off a second sphere.
And the next, the large sphere is used as the emitter, which bounces
rays off the second sphere. Camera controls behave very much like my
controls for Quake in fly mode. These images show around 5000 rays
each, and render at a friendly 20-30fps on my GeForce3. No
optimizations have been bothered with as of yet, so scene complexity is
still an evil O(n^2) issue. Not that it matters with only two scene
elements.
- Aaron.
(L) [2003/04/30] [Billy Zelsnack] [billy_zelsnack on yahoo dot com]
[LINK mailto:billy_zelsnack on yahoo dot com Billy Zelsnack]
Here is my latest toy. A demo can be found at:
[LINK http://www.shapemaniac.com/bziotd.php www.shapemaniac.com/bziotd.php]
I love physics. Working on physics has been some of the most rewarding
programming I have ever done. I can't emphasis how cool it is to build some
sort of contraption out of a bunch of parts and it JustWorks. I remember a
couple of years ago when I saw the first Ipion demo. It was just so amazing
to me. Now I have built something along those lines myself and it feels
really good.
It is definately not commercial quality physics or anything yet, so it is
still pretty easy to break things. Currently there are no spatial structures
for anything so performance has a ways to go. The pairwise collision is
implemented as brute-force triangle-mesh against triangle-mesh. The
triangles you see are the triangles being collided. A better plan is to
usually use composited primitives for most things, but I wanted to get the
tri-mesh/tri-mesh case working well first.
The framerate is limited to 50fps which is the same rate the physics are
updated at. If you start dropping more than a few fps below 50, the physics
will run slowly and things will appear to be in slow-motion. I have a 800mhz
machine with a GeForce4ti and the worst I have seen it was 42 fps.
BTW. I currently am looking for interesting and challenging work (on or off
site). The more interesting the work, or the more cool the location, the
better.
(L) [2003/05/02] [RemonvanVliet] [remonvanvliet@hotmail.com]
This is a real-time raytracer i wrote in Java just as a little test to see
if i could do it. It features reflection, shadows, phong lightning, adaptive
subsampling and more. The subsampling obviously also works for reflected
objects, reflected shadows, highlights etc.
The framerate isnt great at the moment but apart from the subsampling it
isn't optimized at all yet and is actually a fairly generic raytracer.
Go to my site at [LINK http://remon.mojomedia.at] and click Projects to see the
applet in action. Note that some people will need Sun's 1.4 VM to run this
properly.
(L) [2003/05/03] [PetruSoroaga] [contact@whiteblobs.com]
My name is Petru and I'm responsible for this dynamic
shadows demo.
I created this demo in order to test different ways to
generate dynamic shadows. Finally, I stopped at
Carmack's reversed method.
Basically, all the lighting informations are generated
in steps, and in the final step the material
information is added (textures).
1. First, all the scene is rendered on ZBuffer and
Screen using ambient light.
2. For each light:
2a. Draw shadows volumes using stencil buffer.
2b. For each light draw all static objects with
lightmap of current light (or no lightmap, just vertex
lighting for dynamic objects) taking care of the
stencil buffer.
3. Blend objects materials into scene.
The scene uses an Octree for objects management,
shadows volumes are clipped to scene, lightmaps are
optimized (are filled up in big textures).
In order to run the demo, you need DirectX8 and a 3D
card that suport stencil buffers. On mt Radeon 7000 it
runns acceptable (due to fill rate limitation on this
card).
You can turn on/off lights, disable/enable material
rendering and other stuff.
This is intended to be just a quick view of how
stencil shadows may look.
The only disavantage I see to using shadow volumes, is
that the shadows are pretty hard in some places. But
this can be changed...
The demo can be taken from here:
[LINK http://www.whiteblobs.com/tech/lightdemo.zip]
Some more screen shoots are here:
[LINK http://www.whiteblobs.com/tech.htm]
Thanks.
(L) [2003/05/05] [OdellHicks] [ohicks@attbi.com]
During my current bout with unemployment, I've been messing with things
I've been wanting to, but couldn't while busy with work. More specifically,
playing with those nifty features on my Geforce 3 : )
This is a screenshot from an engine I've developed from scratch. It's
actually pretty useful in it's current form, and with some decent models and
textures, a full game could be made from it.
Current features:
- Completely vertex and pixel shader based - no use of the fixed function
pipline
Terrain rendering (uses a repeating detail texture with larger color maps)
and collision
Static meshes (MS3D and .X formats)
Interior areas (Quake II maps) and collision for the interior
Segmented and 'skinned' animated objects (MS3D format)
Scene graph hierarchy and culling of objects and terrain
Reflection mapping, real-time reflecting water, and bump/normal mapping
Shadows on everything, being cast by anything, even the terrain
Character control, with minor transitions between actions (a bit clunky at
the moment)
Heat distortion ( texbem / render-to-texture scheme)
The screenshot shows a scene that is fully shadowed from a flashlight -
anything will cast a shadow onto anything else (even the terrain casts
shadows!) via hardware shadow mapping. The framerate dips down to 45fps on
my GF3 + 1ghz Athlon.
For more information, please visit my website at [LINK http://odellworld.com/]
(L) [2003/05/07] [DellaRocca] [adr@bvdep.com]
These are some screenshots I took from a new program I am developing for
learning purposes, named LSTEditorCS(Large scale terrain editor, the CS
is for CSharp).
With it, you can easily generate a terrain and make some modification on
it(scale it, generate texture, generate simple shadows).
It use the csgl library for the rendering in OpenGl.
I began it to learn c# and windows forms but rapidly I developed its
"sister ship" in MFC and C++ (to do some bench).
In a few days (or weeks, depends on my sparetime), I will put the 2 on
[LINK http://www.users.skynet.be/della-rocca my website].
For the moment, the only way to move, rotate and zoom-in / out the
rendered terrain is using the wheelmouse and the middle button(I will
add a mouse option soon).
The sources of the two projects will be released too.
Della Rocca Antonio
(L) [2003/05/08] [StephanUnverwerth] [S.Unverwerth@gmx.de]
My name is Stephan Unverwerth and I have put a new site online.
I will constantly update it as I create interesting programs worth sharing with the community.
You can download the programs with full source code and binaries.
There are two programs online right now:
2DBsp is a demo for BSP-Trees that are used for CSG (constructive solid geometry) operations
right now the demo supports CSG_Add and CSG_Subtract but feel free to extend it as you like
it uses standard GDI-Calls only, so it is 2D for the sake of simplicity
The IOTD shows some "rooms" that were created using CSG operations.
Every line's endpoints are drawn as well as their normal vector.
TraceR is a simple Raytracer that can do: 4x4 Antialiasing, Reflections, Spheres and Lights.
Also, feel free to extend this little prog and let me know what great ideas you're working on.
The IOTD shows some spheres arraged in a spiral-like order. some of theme are reflective some not.
The reflection recursion is limited to 10 iterations and 4x4 AntiAliasing is activated. The original image
was 512x384 and just took TOO LONG to render ;)
Please visit my Homepage and send me some wise words...
Sun-Creations: [LINK http://www.sun-creations.de.vu www.sun-creations.de.vu]
(or if that link doesn't work...) [LINK http://mitglied.lycos.de/sunverwerth/]
(L) [2003/05/10] [Helium3D] [helium@planetiso.com]
This is Helium 3D, my first FINISHED and released game using DirectX 9. It is basically a maze game where you must find the exit using a lot of items and avoiding strange enemies. You drive a ball that will lose air every time you move so is very important the way you use it. All graphics (textures and models) were made entirely by me (hey I'm just a coder ;) and their psicodelic look make the game look very cool. You can use the level editor (bottom left corner) to produce new levels and load them in the game, so this way the levels can be shared on the net. The game is totally written in C++ and uses DirectX for rendering, input and audio. The models were made using MAX 5 and then exported to .x format.
The game features mainly:
- DirectX 9
A kind o quadtree for scene subdivision
Particle systems (smoke and sparkles)
Timebased physics system
Dynamic lights
Textured fonts
Huge levels to explore
Easy to use 2D level editor (Fast and powerfull :)
3D Sound
You can download the demo at
[LINK http://www.planetiso.com/helium/esp/files/helium3d_demo_eng.exe]
For more screenshots and info about the game visit [LINK http://helium.planetiso.com]
See ya!!
(L) [2003/05/12] [SylvainLefebvre] [Sylvain.Lefebvre@laposte.net]
These are four screenshots of my Drops of Water shader. It is an animated
effect
showing drops falling allong a surface. The shader relies on a
fragment program and therefore no geometry is required for the rendering of
the
drops: all is done in texture space. The two pictures on the left are only
one
geometric quad textured with the shader. The drop shape is encoded in a
texture. The shader instanciates the drops in texture space where asked by
the
application. A transformation (scaling and rotation) can be applied on each
drop. All happen like if drops were sprites drawn in the texture.
The rendering of drops is done using a faked refraction effect. The
rendering
of the underlying surface is done with the Phong model. The specular and
diffuse
coefficient are modulated by a texture to achieve a wet effect. This texture
represents the wet areas. It is obtained by rendering the drops as white
spots
at each time step. The new state is blended with the old texture to
accumulate wet areas.
The Drops of Water shader will be explained in detail in the upcoming
[LINK http://www.shaderx2.com ShaderX2] book.
Videos are available at [LINK http://www.aracknea.net/shaderx2/]
(L) [2003/05/13] [Undeadenemy] [undeadenemy@decksix.com]
This is only my second rendering in 3d Studio Max, it is a picture of two planets with triple suns in the background. Both planets are the same size. I used a bump-map for both and just messed around a little bit to get the look. The planet on the left was textured with a skybox texture. I used the planet material included in MAX for the bump map and added in a dirt texture to add another bump map on top of that. Then I increased the bump amount to make it seem deeper. For the planet on the left I used the aformentioned dirt texture and then added a bump map with the same texture. I picked a blue ambient/diffuse light as well. For the background area I used a slight fog and the Smoke material for the environment map. After the rendering I opened the image in Adobe Photoshop and added in a 105mm Prime lens flare in three different locations.
(L) [2003/05/14] [JaniPeltonen] [jani@orcagames.com]
Here are some pictures of what my company has been working on.
All these screen shots are from our new game 'Talon' running on various mobile phones. The taller pictures on the sides show the game running on SonyEricsson's P800 and the center image show the game on Nokia 3650 and Nokia 7650.
The games are written for Symbian, a very cool operating system for mobile phones. It is also the first REAL object oriented operating system that I have worked with.
Making games on mobile phones is an interesting challenge. The devices are generally very powerful but also very limited in terms of memory and input capabilities. A major portion of the game design effort goes into working out how to get around the limited input capabilities. The key layouts are also seldom designed with gaming in mind and tend to be quite different from one phone to another. The P800 is actually stylus based and hardly uses any keys at all.
A further complication is that documentation for Symbian tends to be poor (although gradually improving) and often the best source of documentation is the OS header files.
For downloads and more pictures please visit [LINK http://www.orcagames.com www.orcagames.com]
Jani Peltonen
(L) [2003/05/16] [XycsoscyX] [xycsoscyx@hotmail.com]
I have been posting on the message board for a while, and finally decided to post some screens of my progress. The two screen shots are of my engine running, with and without the texture pass. As you can see, the frame rate is kinda sub par, but that's because the geometry is total over kill, I intentially added extra geometry to see if I could still maintain decent frame rates (running on my GeForceII GTS). The engine runs entirely through vertex shaders, with all the data exported from Max using custom export plugins. Here's a run down of what I'm doing:
- Support for multiple paths and archive file search
Extensive (but sadly unoptimized), custom math library
Custom scriptable and extendable UI, using XML for data
UI Desktop system, with support for data and function binding
Custom shader fragment linker and compiler system
Extendable mesh, world, and effects plugin managers, currently:
Static and Skinned meshes, including skeletal animations for the skinned meshes
Portals used for world visibility, and octree's for speeding up
collision detection
Bump mapping and attenuation for the world and objects:
Triple pass on anything without volume textures or 4 texture units
Single pass on anything with volume textures or 4 texture units
Cube map color filters, for effects such as spot lights
These are some of the highlights of the engine. I'm mostly using this as a test bed for new technology, it's extendable enough that I can easily implement new features and effects, without having to rehaul (like I've done so many times), the entire engine. I've already gotten a pretty solid base for the graphics, which is why I'm working on collision detection and physics (which, I'm sad to say, are seriously lacking). The engine so far looks really nice though, when running. I have a nice demo setup, with some basic collision detection, and will post it online when ever I find a place to post it. Also, thanks to everyone who's been able to answer many of my questions on the forums, your help has been much appreciated.
(L) [2003/05/18] [MikeSnow] [tsunamirealms@hotmail.com]
I am working on developing a massive online RPG. The screenshot you see here
is a snapshot of the World Editor. This project is being developed with
DirectX 8.1
The game is based off a game I made ages ago called Tsunami, a text based
LPMud. This game is up and running even today at
[LINK http://www.tsunami.thebigwave.net]. Once a player reaches a certain level
they become wizards and, using our world editor, are able to create and rule
over their own domains.
We will soon go live at [LINK http://www.tsunamirealms.com] (as soon as we can get
the domain pointed to the correct IP).
We are looking for 3d artists and developers to contribute to this project.
Please contact me at: [LINK mailto:tsunamirealms@hotmail.com tsunamirealms@hotmail.com] if interested!!
Thanks,
Mike
(L) [2003/05/19] [MatthiasGall] [matthias@sechsta-sinn.de]
Welcome to sechsta sinn's »Die verbotene Welt« (The forbidden World), a real time strategy game project.
Earth was the arena of a interplanetary war and became uninhabitable. The planet was quarantined, and all life was evacuated. All? Not all. A forgotten group of men barricaded in subterranean bunkers. Sickened by the aftermath of the war, a new kind of mankind was bred: the Bunkermenschen. Hundrets of years later, a troup transport of the KPB (Konföderierter Plantenbund, confederate alliance of planets) is on course near planet Earth and encounters technical problems. The ship has to go down on the devastated surface. Not knowing how to deal with each other, the encounter of the two parties ends in a terrible armed conflict. Who will prevail? The technologically highly advanced KPB, or the hard-bitten, steeled Bunkermenschen?
We are a team of amateur game developers, mainly based in and around Cologne, Germany. Our main goal is not to create a state-of-the-art game, but to finish a complex project. Die verbotene Welt is developed in our spare time since two years and has been rewritten from scratch twice in the early development stages. Most of the team members meet up every two or three months for a weekend, which is very important for an ongoing motivation.
Both parties have discovered the advantages of ruin defilate on the upmost screenshot. Unfortunately, noone wants to avoid. KPB attack with a hovercraft tank, a heavy "Panzerknacker" mech and several light Gladiator cyborgs. The Bunkermenschen try to defend themselfes with one light and two heavy battle tanks and soldiers armed with riffles and anti tank missiles. There's also a paramedic right of the big tree. The left screenshot in the second row shows a small KPB resource facility in the desert scenario. Some Gladiator cyborgs and two anti-aircraft rocket towers are protecting the scrap store (left) and the melting furnace (right). The shot to the right shows a Bunkermenschen base with two generators, housing, barracks, and a melting furnace. The construction vehicle (center) is used to build a new generator. The red outline indicates that construction is not possible at this place. The bottom left screenshot shows a ingame event cutscene from our first demo mission. A Bunkermenschen ballon destroys a KPB interim base that was hidden in the forrest. A female Bunkermenschen reporter explains the situation to the player in a video. The bottom right shot shows a scene from an outdated demo mission. The player has to guide a convoy to take over a abandoned base, but the KPB interfere with a devastating bomber attack.
Both parties feature different user interfaces. The rusty Bunkermenschen interface is an always on top design, while the silver KPB interface can be rolled in and out. Both interfaces consist of low level unit controls (behaviour and walkie-talkie-mode, special modes like guard, patrol or berserk), energy displays, a customizable minimap, and build controls.
The game is developed with Visual C++, graphics are rendered with Cinema 4D. It features fully scriptable AI and mission handling using Lua as the scripting language. Everything in the game can be controlled from within the scripts. The API is fully documented on currently 40+ pages. AI control on any level (unit-based, group-based, player-based) allows both generic and very specific mission design. Eight types of influence maps can be evaluated for AI decisions. An ingame console is available for debugging purposes. The whole GUI system is scriptable.
Also have a look at MissEd, the DVW mission editor suite at [LINK http://www.games-net.de/hosted/mgall/devsuite-huge.jpg] (huge image, ~500kb).
Read more about sechsta sinn and our projects at [LINK http://www.sechsta-sinn.com]
Feel free to write any comments via email or flipcode forum. We appreciate any commendation and criticism.
Cheers,
Matthias Gall
lead programmer
(L) [2003/05/20] [IikkaKeranen] [fingers@mail.planetquake.com]
This is a screenshot from Digital Eel's latest game, Dr. Blob's Organism.
The game is nearly finished, and we'll put up a demo version soon. You can
find some information about the game and more screenshots at the official
website: [LINK http://digital-eel.com/organism/]
The game is based on Conway's Life algorithm. Each level has one more more
"nuclei" that generate random cells, which propagate outward. Your mission
is to shoot at the blob and prevent it escaping the petri dish, and destroy
the nucleus in order to advance to the next level. Various powerups and
special effects add some spice to the mix.
Organism is my first completed OpenGL project, and pretty simple at that. I
only used OpenGL 1.1, but it's plenty good for a fun little arcade game and
runs on pretty much every computer you can find (except older laptops). I
used SDL for keyboard input and SDL_mixer for sound, so it'll hopefully be
easy to port the game to Mac and/or Linux as well. To allow simple user
modifications, standard file formats (targa, wav, ogg vorbis) are used.
Iikka Keranen
(L) [2003/05/22] [SergeyVorsin] [regmail@hotbox.ru]
Project Digital Nature.
I've included only 2 pictures, but they illustrate the program
capabilities not too badly.
These pictures are rendered on GeForce4-Ti4200, at about
speed 100fps.
Here are some features of the rendering engine:
- Terrain: using high resoultion light-maps (that increases
reality,
terrains shadows supported), up to 4 texture stages, (for
example,
20480m x 20480m with detail level 10m).
Larger terrains can be made of segments, this reduces
memory & processor
overhead, fractal terrain generator, real maps import
capability as well.
Bump mapping.
Dynamical sky, (that means you can set any time in the
environment
and it will reflect real properties)
Clouds, up to 4 levels (not polygons).
3D Terrain plants (trees, plants e t.c), fractal
generator of trees
which can generate large range of tree types (up to 65000
plants per sector).
Water, which includes such effects as: reflection,
speculer highlights, transparency.
Cliff & snow texture generator, which optimizes using
video memory.
External 3D objects render supports all the properties of
materials (bump mapping,
reflection, e t.c) real shadow volumes cast at all
objects in scene.
The project is developed on VC++6.0, using Direct3D8.
E-mail: [LINK mailto:regmail@hotbox.ru regmail@hotbox.ru]
(L) [2003/05/25] [NinjaCross] [ninjacross@yahoo.it]
This is a particle fountain generated with a tool i'm working on for the OpenGL projects "Eternal Eclipse" and "Isle Assault".
At this moment the particle system is a stand-alone application, but
once finished I'll implement all its functionalities in the engines of
the mentioned projects.
The main feature of this application, is that particle-emitter and particle-behaviours are completely scriptable using a script file.
This permits the programmer to build a lot of particle effect simply
realizing a small script that determine how particles interact their
selves, and how the emitter creates them.
The main parameters that the programmer can set with the scripter are:
- Gravity of the environment
Viscosity of the environment
Direction and speed of the particles
Average life time of the particles
Range of the life time
Coefficient of the gravitiy interaction between the particles
Colour and size of the particles
Particles generation amount
Ciclic/monotone emission
Wind simulation
Currently i uploaded on my web site some screen shoots and a demo version of the engine with an hard-coded particle model (so no scripting features).
The URL of my web site is [LINK http://www.ninjacross.it] and the
project (with the demo) is described [LINK http://www.ninjacross.it/pagina15.htm here]
For any question or discussion please e-mail to: [LINK mailto:ninjacross@yahoo.it ninjacross@yahoo.it]
(L) [2003/05/27] [CarlPedimina] [cpedimina@krysalide.fr]
My name is Carl Pedimina and I'm co-founder of a technical and graphic sub-contractor company.
Daarwind is a technical and graphic demonstration we have made in order to show our capacities. It was done in three months by four persons: one programmer (me) and three graphists.
We have used our own game engine called Seed. Some technical information:
- Use of Octtree for spatial partitioning
Skeleton Animation system (with animation blending)
Realtime shadow (using texture map)
Sound streaming
Daarwind (the main character) has 2400 polygons and about 30 bones
There's about 31000 polygons for the level (without dynamic objects)
Real time wind management (for the grass, the bamboos and tree leafs)
Multi texturing management (look at the reflection effect on pipes)
Particle system
Use of DirectX8.1 for 3D, Input and Sound
You can download a demo here: [LINK http://www.krysalide.fr/daarwind.php].
You can send me any comments via email or flipcode forum.
Cheers,
Carl Pedimina
Technical Director
(L) [2003/05/30] [StephanReiter] [streiter@aon.at]
The two screenshots show the latest addition to my terrain engine: a dynamic sky with animated clouds.
The sky gradient is computed from a list of colours, which includes information about the sky-colour in the north, east, south, west and at the top of the sky at any given hour. The colours are then interpolated 1) to find the colour for the current time 2) to get a smooth gradient for the whole sky.
After the sky gradient has been rendered, I blend the sun as a
billboard. Concerning the sun: it's not as simple as that. I've also
included dynamic lightmapping into the engine, which computes
terrain-lightmaps (including shadows! :-)) over several frames.
The clouds are then rendered using a technique I found in the ATI-cloud sample. Check the ati-website for more information; basically I translated the vertex- and pixel shaders into DirectX HLSL and tweaked them to suit my needs. And finally I add a glow around the sun to the scene if it is not occluded by mountains - a simple ray-check is the base for this.
Stephan
(L) [2003/06/02] [Billy Zelsnack] [billy_zelsnack on yahoo dot com]
[LINK mailto:billy_zelsnack on yahoo dot com Billy Zelsnack]
I was looking at the [LINK http://telekinesys.com telekinesys.com] site (parent company
of [LINK http://havok.com havok.com]) last
night and saw this video of a conveyor belt simulation. I thought it looked
pretty cool. So instead of filling out the Havok evalation request form for
the 3rd time in vein, I decided to just make something like it in my stuff.
I don't think this demo is as technically cool as my previous IOTD, but I
thought it looked pretty neat anyway.
There are 50 boxes/spheres and 2 ragdolls riding around. Nothing you can
manipulate in this demo, you just fly around. It is frame limited to 50fps
and doesn't drop below that on my system (amd800 with a ti4200). You can
download the demo at [LINK http://www.shapemaniac.com/bziotd.php www.shapemaniac.com/bziotd.php]
(L) [2003/06/06] [ArasPranckevicius] [nearaz@centras.lt]
Inspired by [LINK http://www.indiegamejam.com/ IndieGameJam], a
group of Lithuanian game developers organized a similar event in Lithuania. The idea was: we give you the "engine", you come and have two days to write games with it. The whole thing was called LTGameJam, and it's alredy the second event (the first one had it's [LINK http://www.flipcode.com/cgi-bin/msg.cgi?showThread=09-24-2002&forum=iotd&id=-1 IOTD] also).
The theme for the event was "physics, cars and stuff". The engine for the games was developed beforehand, externally using [LINK http://q12.org/ode/ ODE] for dynamics, [LINK http://www.codercorner.com/Opcode.htm OPCODE] for mesh collision and some of [LINK http://www.lua.org/ Lua] for configs/levels. The engine developed is rather general-purpose (resource management system, DX9 renderer using effects framework, pipeline, entity/component framework etc.), with all LTGameJam specific stuff in a separate project.
The image shows screenshots of several games that we managed to do. All the games, screenshots and complete source code (including the engine) is at [LINK http://jammy.sourceforge.net/2003/].
Aras Pranckevicius aka NeARAZ
(L) [2003/06/09] [SylvainLefebvre] [Sylvain.Lefebvre@imag.fr]
These are screenshots of my latest game: [LINK http://www.jalweg.net Jalweg].
The idea was to develop a small game with a simple-yet-interesting
principle:
you control a small sphere (the hero) in a level and you are chased
by at least one big metal sphere (a monster). The goal is to destroy
all the other spheres (the balls) by making the monster colliding with them.
If the hero collides with a monster it is destroyed ... and you lose.
However the hero can safely collide with the balls.
I tried to make the game easy to play (no big documentation, simple controls
...) and to
minimize the interface: launch the game, press space, and you are playing.
Many choices were made in order to keep the development time under control
while trying to add the minimal set of required functionnalities to create a
fun game.
For an example a replay feature was added in order to allow players to show
how they can solve a level => this allows to maintain a competition on the
game
web site - which I hope will increase the game interest. The game also
includes a
level editor. I think it is important for this type of action/puzzle game to
let
players create and share their own levels.
Instead of trying to create 3d models by myself (which would have resulted
in bad looking models :), I chose to base Jalweg graphics on simple shapes
and to use per pixel bump mapping (diffuse+specular) in order to obtain a
more
appealing result. Everything is rendered multiple times to handle the
multiple light sources. There is also a reflection effect on the ground.
If not for playing, try it to see these effects ;)
The game is entirely programed with OpenGL and NVidia / ATI extensions.
However if your hardware does not support the required extensions, you can
still
play (without the nice effects). I am using the gluX library for detecting
and calling extensions.
For more informations and for downloading the demo version please go
on [LINK http://www.jalweg.net http://www.jalweg.net/]
So I don't want to go further into details (this is already a long text :)
and I hope
some of you will have fun playing this little game !
(L) [2003/06/12] [Blender] [blender@mbnet.fi]
Finally I got something to show in the IOTD myself. This is a
screenshot from my particle editor/system which I just got finished in
my sparetime. It's nothing fancy, but it is a nice interface for
creating little particle systems and saving them in a file.
This is also my first attempt to do windows dialogs with MSVC++6.0.
After some searching in MSDN and disturbing people here on flipcode
with endless amounts of questions I learned stuff in notime.
So.. again with the particles. There are many useful parameters to set
and fix to create virtually any kind of a particle system that user
wants to. The renderer is based on OpenGL and includes nothing fancy.
The actual particle system is located in a separate dll, which the
editor loads and just fills a structure for the particle
system. This same dll can then be loaded in any other program
(including my 3D engine) and the exact same results are achieved than
in the editor. I've also written a simple LOD, but the optimizations
are still quite few.
If you are interested in getting the editor and using the system in
your own projects, see my website at [LINK http://koti.mbnet.fi/blender] if
I'll put them available for download sometime.
-cheers
blender
(L) [2003/06/15] [TrentPolack] [trent@codershq.com]
This is a screenshot from one of my demos from my chapter in Jeff
Lander's upcoming [LINK http://www.darwin3d.com/book.html Graphics Programming Methods], entitled "Building a Flexible Terrain Engine for the Future". The article covers my own take on Willem de Boer's geomipmapping, coverage of Thatcher Ulrich's Chunked-LOD algorithm (which is, essentially, an evolution of geomipmapping), and also detailed coverage (along with some kick-ass demos) of ROAM 2.0.
The screenshot shows off my geomipmapping implementation (using OpenGL along with SDL), which gets an average of about 120-140fps with 150k triangles on the screen (so, about a throughput of 18 million triangles per second), without taking any advantage of GL's new standardized vertex-buffer extension, or nVidia's VAR extension. Not too shabby, if I do say so myself. :)
And, while I'm plugging Graphics Programming Methods, I might as well
plug my book Focus on 3D Terrain Programming, and my upcoming
book about multiplatform 3D game programming (tentatively titled
Windows and Linux Game Programming). </SHAMELESS_PLUG>
Trent Polack
[LINK http://trent.codershq.com]
(L) [2003/06/16] [DonWilliamson] [don@donw.co.uk]
This is an implementation of Spherical Harmonic Lighting to partially simulate Global Illumination for static models on a per-vertex level, in real-time. The executable itself contains a lot of SH-specific visualisations such as an Associated Legendre plot and 3D representations of the SH bases.
The simulation starts of by generating SH co-efficients for each vertex in 3 types of lighting model: diffuse unshadowed, diffuse shadowed, and diffuse inter-reflected; all lit by an HDR image light source. For each vertex, integration over the sphere is performed using a Monte-Carlo Estimator with 10,000 samples, and then projected onto 4 bands of Spherical Harmonics. For the first time the program starts this will take a while to generate, after which the SH coefficients will be cached to file for you to run again.
There is also an implementation of Ivanic/Ruedenberg's SH rotation algorithm, presented in verbose form that should be easily correlatable with their original paper. This manifests itself in the form of back-rotating the HDR light source SH vector into the model object-space.
Both the source code and executable are available on my webpage for
those interested in the technique: [LINK http://www.donw.co.uk] .
(L) [2003/06/18] [DamonDuBois] [damon@wizardslab.com]
After years of looking at stuff in the IOTD gallery here, I've finally finished a project of my own. It's an arcade game called Net War. The gameplay in it is kind of inspired by the arcade classic Missile Command. You play a network security agent who is defending data banks in a large corporation's mainframe computer against invading hackers. As hackers come down paths through the grid you need to drop Black Ice bombs on them to prevent them from getting to your data banks. There's a few types of hackers with different behaviors and some power-ups to add variety to the game play.
Technically speaking I haven't done anything very advanced or tricky here. It's programmed in C++ and DirectX (just DirectDraw and DirectSound).
It's not anything incredibly impressive, but I think it turned out to be a pretty fun game. Mainly I'm glad to have finally finished something.
If you want to read more about it or try out the demo, go to [LINK http://www.wizardslab.com/NetWarInfo.htm]
Damon Du Bois
(L) [2003/06/19] [DierkOhlerich] [chaos@xyzw.de]
This screenshot shows render-to-texture effects and multisampling running at
the same time.
I was first frustrated that this is not possible with DirectX9.0. You may
render into a multisampling rendertarget, but you can't use that as a
texture.
But DirectX9.0a saved my day, you may now stretchblit from a multisampled
rendertarget to a texture surface.
The screenshot is taken from the final version of "fr-025: the.popular.demo"
which won the demo competition at the "breakpoint 2003" party. it shows all
kinds of render to texture effects, and together with multisampling it looks
super "smooth". download it at
[LINK http://www.scene.org/file.php?file=/demos/groups/farb-rausch/fr-025-final2.zip&fileinfo]
and see for yourself.
(L) [2003/06/22] [StefanJohansson] [stejo127@student.liu.se]
These are screenshots from a RTS game that i have been working on for some time that is finally coming into the stage where its at least marginally playable. Its notionally set in the 19th century although i haven't cared about keeping things historical. Probably i will add tank/aircrafts at higher tech levels and call it 19/20th century. Some current features includes
- Most of the standard features found in todays RTSes
Economy system based on the principle that the player should be able to make interesting research/infrastructure decisions but still be able to concentrate on the battles.
Supply calculation for units on a level normally only found in some TBS wargames.
User modifiable AI, each hotkey group can be assigned its own AI loaded from dll files.
Fast pathfinding using a three layered approach.
Dynamic terrain, explosions will create craters and I will probably add some terrain changing units.
Random map generator that can take hint files to create unique maps.
Some nice graphic features like reflective water and dynamic clouds.
The screenshots shows
- Overhead view of a battle
All out rocket fight
Zoomed out view of map color coded for supply level
Random map created with a rather unsubtle hint file
Of course there is a lot still to do including, unit graphics (pretty nonexistant at the moment), better unit control/AI, more units, out of game stuff (option, lobby etc), new terrain texturing.
The current work in progress version can be downloaded at [LINK http://www-und.ida.liu.se/~stejo127/spring.zip www-und.ida.liu.se/~stejo127/spring.zip]
//Stefan Johansson
(L) [2003/06/24] [BachQuocTuan] [contact@openskull.com]
These screenshots show my first finished game : SnakeFire
It's a snake-game, (deja vue ?!) but mine is different . The gameplay
is the same as the classic one, but in my version, tha map is bigger than
the screen ! So the game area is bigger and the game more fun ! There are
also lots of items...
About the technical part, there is nothing very advanced.
Programming language : C++
Graphic API : DirectX
Sound API : DirectX
(directX8.1)
I'm really proud to have finished (finally) a game !
I hope you'll try it : [LINK http://www.openskull.com] ; And i'm wating for your
feedback.
Hope you enjoy it !
Bach Quoc Tuan
(L) [2003/06/26] [JamesGregson] [jgregson@dal.ca]
This image shows my latest terrain engine. I've stolen the landscape and
texture images from [LINK http://ohad.visual-i.com/exper/exper.htm here]. In this shot
there are 80,000 triangles within the frustum or approximately 2.4M
tris/second, which is not terrific as terrain rendering algorithms go.
However, this engine features smooth LOD. There are no LOD states that get
switched and stuck together, instead a constant level of detail (pixels/poly)
is defined and maintained at all depths. There is no spatial partitioning
system, and there is also extremely little overdraw. There is also a highly
accurate and extremely fast occlusion culling algorithm which allows extremely
fast (negligible time required over and above the tesselation of the
landscape) culling of invisible terrain regions, and terrain-object occlusion
culling in about 10 operations per object bounding volume vertex. There is
also nearly constant (~6% variation) system overhead, and minimal memory
usage. The algorithm scales to all terrain sizes (I've tested it with 256x256
up to 16384x16384 heightmaps) with no performance penalty. And since the
detail is constant at all depths, although there is a lower overall triangle
throughput the triangles that are rendered are used very efficiently which
probably makes up for it.
The above scene took 27 ms to update the landscape. With all the portions of
the process that can be moved to graphics hardware are omitted, the update
time drops to 16 ms. With SIMD and standard optimizations, that could likely
be halved again. Next generation cards that have the ability to do texture
lookups in the vertex transformation stage (ie. compliant with the glSlang
spec) would be able to implement all but an initialization phase and 3 matrix
multiplies per frame as dynamic vertex buffers (giving all the advantages
above but with essentially zero system overhead)
James Gregson
(L) [2003/06/27] [GabrielGambetta] [gabriel@mrio-software.com]
Look at the picture. It's a classic raytraced image with reflecting
spheres. Not impressed? Let me enumerate the features of the raytracer
which rendered it :
- Sub-pixel accuracy
Cast shadows
Arbitrary number of spheres
Arbitrary number of omnidirectional light sources
Reads the scene definition from a text file
Produces 24 bit raw images of arbitrary size
100% written in C, without using any external library
Still not impressed? What if I told you the complete source code is 1971
bytes long?
Yes, it's not a typo. One thousand, nine hundred and seventy one bytes of C
code. And it could be reduced a little more in expense of "clarity".
You can download the source code and a demo scene at
[LINK http://www.mrio-software.com/2k_raytracer.php].
Gabriel Gambetta
(L) [2003/06/29] [KriS] [programmer@takas.lt]
These are some screenshots from our cRPG game - Post Nuclear, which is inspired
by Fallout 1 / 2 games.
Short descriptions of screenshots and some technical details:
-top: game screenshot. Game engine is tile based (like in Neverwinter Nights) it
means that map is created from square tiles (1 metre x 1 metre) and of top of
them I put 3d objects (everything is very similar to chessboard). This solution
has some advantages and disadvantages. In tile based engine it's very easy to
cull objects and to create good pathfinder - it's enough to use A* algorithm,
which is fast and accurate, also creating new maps is very fast, but they can
look similar, if you don't have many various tiles and objects. Now game uses
DirectX x models (with skeletal animation), but it can also render quake3 md3
models (with animation). We decided not to use md3 models, as they are very
large compared to binary x if you use a lot of animations (in md3 animation is
keyframmed, so every new animation must contain information about all the
polygons of the mesh). Currently lighting is handled by DirectX lights, but
later we'll use per pixel lighting and some stencil shadows.
-bottom left: editor screenshot, creating new map. Map editor is very simple -
some user interface (made with Borland C++ Builder) connected with game.
Connection is made by passing editors window handle as a parameter to games
executable, then the data is exchanged by sending messages to each others
windows. Large data is exchanged using file mapping. Basically in editor you
just place various objects using few clicks. There is an idea to remove tiles
and objects, which are covered by other ones and can't be seen, but we don't
know if we'll add this feature, as we plan to create a fully destroyable
environment.
-bottom right: editor screenshot, creating new dialog. This tool is used for
creating new dialogs and testing them. When you save your dialog game editor
parses it to create a [LINK http://www.lua.org LUA] script, which is later used by
the game. It looks something like this:
function n1()
setText("Hey stranger! Hold on!")
addReply("[you turn your head to the side of the speaking voice with surprise]",0,2)
end
function n2()
...
(Tip: it's possible to do it with a single function, but then you have to use
multithreading (or something similar) wich is just a pain-in-the-ass and creates
many bugs)
And in game this script will show a dialog with question "Hey stranger! Hold
on!" and one reply to it: "[you turn your head to the side of the speaking voice
with surprise]".
You can find out more about the game here: [LINK http://www.x-k.ten.lt]
KriS & sKiD
XK Entertainment
(L) [2003/07/01] [DmitryPryadkin] [pryadkin@inbox.ru]
I started working on a project, you can visit its page:
[LINK http://user.rol.ru/~rollover/]
I'm an aspiring newbie trying to write a game. Currently I'm
developing a tech demo and map editor where these two pictures are
taken from.
I'm using Delphi 6 with OpenGL for the map editor and Visual C++ 6.0
for a tech demo. At the moment, map editor is capable of doing interactive
terrain creation by means of mouse clicking. The techinques I used
are spherical bumping and a fault algorithm.
My plan is to go from my current projects into developing a game
like Warcraft 3. I realy like it for its gameplay.
(L) [2003/07/02] [KjellAndersson] [kand@lysator.liu.se]
Recent trends has gone more and more towards end users wanting to
customize their games. Some while ago I came up with some ideas on how
this could be achieved. The goal was to make both novice and expert users
able to modify the game. I needed a target game to try out my ideas on so
I pulled out a Breakout clone that I wrote a few years ago. My main idea
focused around using a virtual machine that was called upon when certain
events happened in the game. The virtual machine code was also to be able
to call native code in the game core engine. This was for the expert
users. For the novice users there are premade templates for things that
can be used instead.
The middle image above shows the final level editor of the game. A brick
on the playfield is selected and the OnUpdate code is being edited. This
code is called each frame update. Each brick has three callbacks: OnInit,
OnUpdate and OnHit. The VM-code shown uses the game core function
SetImage, which changes the current image of a brick. Images are defined
in the "Subtype images" tab in the shown dialog. The game core has 18
functions callable from the virtual machine such as moving the brick,
adding score, playing sound etc. The user also has the ability to define
own graphics and sounds to use.
The VM-code is written in assembler due to the fact that I never wrote any
higher level laguage compiler for my virtual machine.
The results of my trials became a whole new version of my Breakout clone,
now called Break GOLD. This version is somewhat different than other
clones in that each level is unique in its gameplay. The images shown in
the background are four examples of different levels that can be made
though the level editor. In the top left level you have to collect keys
in order to be allowed access through doors. In the top right image the
bricks cycle its colors when hit. The goal is to make the three bricks
have the same color. In the bottom left image you have to hit two of
equal kind to remove them. In the bottom right image time is limiting
your gameplay. Bricks are removed every second and you need to hurry to
make good score.
Since the level editor is released with the game, the user has the same
ability to make new and innovative levels as I did when creating the
levels released with the game.
More information, downloads and screenshots can be found at:
[LINK http://www.lysator.liu.se/~kand/breakgold]
(L) [2003/07/05] [CallumPrentice] [mediator@callum.com]
This is a montage of some shots from a media library I'm working on. It allows you to use
varied media sources as textures in your application. It takes care of the initialization,
transport, scaling, filtering issues for you. All you do is give it a URL (online or local) to
the piece of media you want and you're set.
Current supported media types include Web pages, Windows Media (avi, wmv, asf, mpg, [divx])
and QuickTime (mov, Macromedia Flash), memory textures (you write whatever you like to memory
and it's used as a texture - 3D M.A.M.E. anyone ;)) and Window Grab textures (any active
window, hidden or not is used as a texture). Support for other formats including Real coming
soon.
There is a simple demo online at [LINK http://radicalpixels.com/mediator/mediatordemo.zip] and you
can contact me at [LINK mailto:mediator@callum.com mediator@callum.com]. Feedback is very welcome. Thank you.
(L) [2003/07/08] [MatthieuDederichs] [bxw@3dengine.net]
This is a screenshot of Engine, a particles systems manager, which has been developped by 3 friends and me for a school project.
Engine has been developped with OpenGL and SDL, using C++.
It is currently available for Windows.
Here are some features :
- Simple particles systems
Advanced particles systems, with billboarding, texturing, collisions
Physics ( gravity, electric and magnetic fields, .. )
Particles-rendered primitives (cube, torus, cylinder, .. )
3DS Loading and particles-rendering (see other screenshots to understand
Texture editor
Keyframer, with linear and Bezier interpolations
OpenGL GUI
More screenshots are available here : [LINK http://www.3dengine.net/shots]
Web : [LINK http://www.3dengine.net]
Feel free to contact us for any question. Feedback is welcome !
Matthieu Dederichs a.k.a. bxw
(L) [2003/07/12] [JordanIsaak] [jordanisaak@hotmail.com]
After starting several game projects and inevitably losing interest when progress slowed down after an initial burst of energy, I decided to try a really simple game design. The idea was that if I knew exactly what I was going to do before I actually did it, I would be able to keep my focus and not get lost in feature bloat or get bogged down trying to do a big project on my own.
The result was Amoebic, a very simple puzzle game. There's not much that's interesting about it from a technical standpoint, aside from the procedural background generator I wrote for it.
Basically, the generator consists of three stages: a basis noise generator, a fractal sum operator which sums up different octaves of noise, and a color map operator. By choosing between several different types of basis noise and color maps, as well as randomly varying parameters for the fractal sum, a range of different backgrounds is generated.
Amoebic is downloadable from [LINK http://members.shaw.ca/jordanisaak/amoebic.htm]
Jordan Isaak
(L) [2003/07/14] [ChrisEgerter] [powerrender@rogers.com]
Here are a couple of new screenshots of the Prototype engine (formerly Power
Render X). The engine is built in C++ and uses STL, PowerRender 5, and ODE
and has been in development for a year and a half. The engine started off
as an experiment with per pixel
lighting and has been through several changes such as radiosity and shadow
maps before using the full dynamic lighting and stencil
shadow methods used now.
Some of the engine features are:
- Unified lighting: per pixel bump mapping and shadows on every surface
Glow effects:- using 2 passes of separable gaussian blur
Depth of focus: blur between 2 render targets based on z distance
Soft stencil shadows: gaussian blur per light
Projected lights: project a texture on any object instead of point lights,
unlimited projected textures in a scene
Scripting with LUA and a custom script language for AI
PS 1.1 and PS 2.0 shader paths
BSP based level geometry and integration with Quark editor
Exporters for models and character animation in 3D Studio MAX and Maya
You can find more screenshots and movies at [LINK http://www.3dengine.ca/prx]
Chris Egerter
(L) [2003/07/15] [SurianoFabio] [benedetto.suriano@tin.it]
I've coded an A* path finder based on the article of Justin Heyes-Jones
[LINK http://www.geocities.com/jheyesjones/astar.html]. I've used
a rad ide to create the gui of my program.
A* is an algorithm based on euristic function to reach the goal state and
instead of other alorithm like Dijkstra or breadth first visit it's the best because it
visits less node up to final state. The interface's functionalities are more simple and understandable.
Here is a program's screenshot for further question or to request sample binary, contact me:
1)Red Circle is the start state
2)Green Circle is the Goal state
3)Red squares are the steps that algorithm perform to reach the goal state
4)black squares are unwalkable walls
5)white squares are walkable roads
(L) [2003/07/17] [ScottBean] [Scott@Mad-FX.com]
First off, I will openly admit, the first thing I check when on the
internet every day is flipCode's IOTDs. Very fun to see what everyone is
working on. Ironically, this is only my first IOTD.
I've been developing a 3D program named Mad F/X and decided it was time
for it to support HLSL and open up shader development to it's users.
After seeing ShaderMan (a graph based RenderMan shader development tool)
in action, I decided to write a similar program for today's shader
hardware. The project is going even better than anticipated and there
seems to be quite a bit of interest and demand for such a tool as many
are looking for new ways and more powerful tools for creating complex
HLSL shaders for use in their titles / projects.
The first image is ShaderWorks, sporting a smooth VC7 style interface.
On the top right of the image, is the graph based shader editor. You can
simply link functions and blocks to create HLSL vertex and pixel
shaders. The window with all the code is an HLSL generated dynamically.
The split-preview option is on showing regular rendering on the left and
HDR + Effects on the right. As cinematic effects become more mainstream,
and image based rendering is used more and more in games and demos, I
decided to support HDR and many other image based rendering effects, as
the high dynamic materials you create need to be visualized in an HDR
environment for testing. The 4 bottom images, show some preview
snapshots of HDR at work along with Motion Blur, AfterImage, Blooming,
Ghosting and Streaking. It's 10x cooler in real-time.. believe me.
Here's some more info.
ShaderWorks
Introducing ShaderWorksT, the newest breed of hardware shader
development tools. As hardware grows more powerful, the potential for
shader complexity is inevitable. Developing and managing these complex
shader entirely from scratch using ASM shader code is a thing of the
past. Imagine yourself creating your own complex HLSL shader by simply
loading from dozens of pre-defined input, output, constant, texture,
sampler and function
blocks and effortlessly linking them together with a few clicks of a
mouse in only minutes! ShaderWorks will definitely further bridge the
gap between artists and programmers by allowing both to seamlessly
interact in the once pain staking shader development process.
More information and images can be found at :
[LINK http://www.mad-fx.com/products/products-shaderworks.shtml]
ShaderWorks Includes
- An export SDK with a sample skeleton application
An Integration kit (for quickly enabling your projects to render
ShaderWorks materials)
A Visual C++ AppWizard with a sample application
Hundreds of re-usable shader functions and sample materials
Access to ShaderWorks.com (Shader development community)
Code and information on each custom constant semantic type used in
ShaderWorks
ShaderWorks Features
- Uses DirectX 9's powerful HLSL (High Level Shader Language) C style
shader standard
Extremely powerful and easy to use graph based user-interface
Little or no coding required
Supports distribution of re-usable HLSL shader blocks and functions
(shader algorithms)
ShaderWorks materials and integration kit will be used in upcoming Mad
F/X 2.0 software
Supports all shader models up to 2.0 extended
Global blocks and constants for use by every technique or rendering
pass in the material
Exports to DirectX 9 proprietary Effect (.FX) file format
Split screen (for previewing regular rendering along side effect
enabled rendering)
Dynamic DX9 HLSL parser (creates HLSL shaders on the fly while you
edit your material)
Auto-compile feature dynamically compiles while coding
Full HLSL support enables Predication with upcoming DirectX 9.0a
release
HLSL Post rendering effects (16 or 32 bit floating point texture
support)
HDR (High dynamic range)
Glare (Afterimage, Bloom, Streaks, Ghost)
Motion blur
Depth-of-field
HLSL real-time post processing filter stack
Filters include (projector, emphasize contrast, edge soften, edge
detection, pale coloring)
Defaults to FFP (Fixed Function Pipeline) rendering which is supported
by older hardware
Half and Full precision float
User-defined custom semantics (they can then be handled by your own
custom engine)
ASM output viewer
Dual screen switching support
Artist layout and area for outputting custom data with exported
shaders
And much more ...
ShaderWorks is not yet available and pricing is not yet known. Beta
testing will most likely begin in a couple of months. If you wish to
bundle ShaderWorks with your products or re-sell ShaderWorks in the
future, please contact me directly at Scott at Mad-FX.com.
Scott Bean
President / 3D Software Engineer
Mad Software, Inc.
[LINK http://www.Mad-FX.com www.Mad-FX.com]
(L) [2003/07/21] [Billy Zelsnack] [billy_zelsnack on yahoo dot com]
[LINK mailto:billy_zelsnack on yahoo dot com Billy Zelsnack]
[LINK http://www.shapemaniac.com/bziotd.php www.shapemaniac.com/bziotd.php] for the demo.
The claw is built from lots of parts. More than you would think from
just looking at it. Lots of hinges, servos, and motors. This demo also
stress joints a hell of a lot more than a ragdoll does. It does jitter
a bit and refuses to go to sleep, but I wanted to ship this thing.
Picking up the guy and the ball is kinda tricky. It is also fun to pick
up the stick and attempt to bat things with it. I also like to put the
ragdoll in the box and push it up the hill. Yeah, I am easily amused.
Random stuff:
It is supposed to always run at 40fps and doesn't drop below that on my
800 and ti4200. If you have a slow graphics card it could be a problem.
(Read: Very lame graphics implementation)
None of the servos have limits on them so they just let you keep going
and going, so be a bit careful with that.
Those two little lines near the claw springs are to damp the claw from
swinging too much.
Remember you can also control it with the mouse.
Remember to use left shift to drive faster.
Yep.
(L) [2003/07/24] [GilZussman] [gil@gilzu.com]
"Goose Chase" is a fast-paced platform game that reached its final
stages of development and it is scheduled to be released this fall.
The player rambles through the level avoiding traps and enemies to find
each of the geese and scare them till they eventually blow up.
Some of the game features:
- Each of the levels is completely randomly generated, so each
time you play the game you have a totally different experience
5 different areas and sub-areas to explore
Smooth character animations
Particle systems for bonuses and atmospheric effects
Simple, but effective tile-based engine
Exploding geese =)
Check out [LINK http://www.gilzu.com] for more
information about the characters, the story and a quick peek behind the
scenes.
(L) [2003/07/27] [BenSpencer] [ben@tetsisoft.co.uk]
These images are screenshots from my latest attempt at a complete 3D engine from the ground up in C++ and assembler. The engine does not use DirectX, OpenGL or any other pre-written 3D graphics API nor does it rip off any code from any open-source API [***Shiver of disgust!***]
The project is called Phocast is at a comparatively basic stage but eventually I plan add a ray tracing model which uses the real-time engine as a pre-visualiser. Eventually I hope to integrate it into my final year project at university.
Visit my site at [LINK http://www.raytracing.co.uk www.raytracing.co.uk] for a complete list of features and new additions to phocast.
Anyone who is interested in learning how to write this engine with me can contact me at the address posted on my site.
Thanks!
Ben Spencer
(L) [2003/07/28] [SvenHerrmann] [sven@chessbrain.net]
On these screenshots you can see the upcoming screensaver of the ChessBrain project.
The goal was to create a nice looking ScreenSaver using OpenGL which doesn't use too much CPU time (afterall the normal ChessBrain client runs in the
background and need to do his job).
I think I achieved that goal, but of course the restriction of not having all the CPU time ended up in the decision not to have better (volume) shadows and stay with
planar shadows.
The good thing is, that the whole thing should run on any graphics card supporting OpenGL 1.1
Special thanks go to Corey Kruitbosch and Mile Germer for their nice 3d chess models
A Beta version is available at at [LINK http://www.chessbrain.net/bbs/viewtopic.php?t=517]
For those who don't know what ChessBrain is (I guess that should be the most people here a short explanation:
The ChessBrain project is a non-profit international effort to construct a massive chess-playing computer using thousands of networked machines. For more
informations about the ChessBrain project visit [LINK http://www.chessbrain.net/]
(L) [2003/07/30] [GregSnook] [snookg@msn.com]
This is an image of a terrain engine\ocean water system I've been
working on recently. The images show the ocean water shader in action,
with a randomly generated island in the background. This is an update to
one of the demos included with the book Real-Time Terrain Engines using
C++ and DirectX 9 from Charles River Media. I'll be continuing to
support and extend the sample engine included with the book on my web
site, [LINK http://www.mightystudios.com www.mightystudios.com]. The
updated ocean water shader shown can be downloaded from the site, but
the source code included with the book is required to build the complete
demo.
Terrain Engine Features:
- Roam, Chunked and Tiled geometry methods
Quad-Tree visibility culling
Random terrain geometry and texture generation
Animated cloud cover
Atmospheric light-scattering illumination model
Ocean Water Features:
- Animated, procedural geometry using FFTs to generate wave motion
Can be tiled infinitely in all directions
All visual aspects (water color, specular strength) controlled by a
single gradient texture.
Both systems are written exclusively using HLSL vertex & pixel shaders
for DirectX 9
Greg Snook
[LINK http://www.mightystudios.com www.mightystudios.com]
(L) [2003/08/01] [DaveHodgson] [dave88@ntlworld.com]
The image is from my first complete game called Sliders and was
developed using Visual Studio 6 and OpenGL. The audio is handled entirely
by the FMOD system.
Development from concpetion to completion was around 2-3 weeks. The
biggest issues faced came in the form of making sure that the boards don't
start with a ton of matches from the get-go. It would seem like a simple
logical problem to fix, but a surprising number of bugs arose from the
'fixes'. Chalk that one up to incompetence. The graphics are pretty
straightforward using Orthogonal projection and some wrapper functions that
take the information about the sprites and compile them into the necessary
vertex arrays to speed up rendering.
If you ever wanted a reason to use FMOD this is it: I tried every audio
system I could find, and they were all either too limited, too complicated
or too pricey.
[LINK http://www.newdeltagames.co.uk]
(L) [2003/08/04] [FabianGiesen] [ryg@gmx.net]
The final version of our 64k intro "fr-030: candytron" has just been
released, so I decided to give it a shot and submit it as IOTD.
We had two primary intentions with this intro, which was a) voice
synthesis/singing and b) flexible, realtime-animatable mesh processing.
I can't say much about the voice synth and it doesn't translate well
into an image anyway, so instead of the usual engine-feature lists I'm
gonna focus on the mesh processing.
We started with a list of operations we needed to do interesting meshes
(based on the experience we made with the predecessor intro, fr-019):
Bone animation, Catmull-Clark subdivision, Extrude ("pull out" one or
more polygons from the mesh), Randomize (some noise added on the vertex
coordinates to get distorted objects), and Calculate Normals (to get
proper shading). To make it all realtime, we needed to split those
operations into topology processing (operations that change connectivity,
number of polygons/vertices/edges, etc.) and pure vertex processing (i.e.
anything that is just dependent on vertex attributes). The idea was that
only the vertex processing part needs to be executed per frame to do
animation - and that idea worked out quite well, as the intro shows
Mesh processing is not really an interesting subject by itself and because
no one wants to look at morphing cubes, we needed to make things a bit more
interesting for our viewers. This is where Josie (top-left screenshot) comes
in, our charming assistant. The top-right screenshot shows Josie walking away
from us with some ... well, morphing cube to the right (we couldn't resist .
Or, actually, it's an extruded cube, so if you didn't get what I meant with
"pulling out" polygons in my original description, this screen probably helps.
The bottom left screenshot shows a "water" surface (just a plane with some
displacement, we used perlin noise for that, which is what we used to implement
the "randomize" function in the original design too), all animated in realtime
and with those "towers" growing out of it (extrude again). The bottom right
screenshot shows Josie jumping (bone animation), with dynamic subdivision and
extrusion to grow those tentacles out of her, plus some nifty material effects
to get the half-wireframe-half-solid look (looks much better in motion).
As said above, it's a 64k intro, so all of that code and data had to be crammed
in a pretty small space; it's neither especially fast nor especially long, but
we are very pleased with the end result anyway. If you want to see for yourself,
you can download the whole intro from
[LINK http://www.theproduct.de/fr-030_candytron_final.zip]
Some fast facts about the intro: It was developed with Visual C++ .NET 2003
during
a period of about 4 months (January to April of this year) by 4 people and came
2nd place in the 64k intro competition at breakpoint 2003 (an annual demo party
in
Germany). This is the final version which features some additional and improved
code & content, and was released just a day ago. It should run well on pretty
much
any reasonably recent machine, look up the readme for details
- Fabian "ryg/farbrausch" Giesen
(L) [2003/08/06] [JetroLauha] [jlauha@cs.Helsinki.FI]
Here is some screenshots from my games Stair Dismount (Porrasturvat)
and Truck Dismount (Rekkaturvat). Upper left image is taken from
the Stair Dismount, which was released a year ago in August 2002.
Rest of the images are from the sequel Truck Dismount which has
just been released. Stair Dismount won the Assembly 2002 game
development competition, and the Rekkaturvat is taking part in
the Assembly 2003 game development competition.
Check out [LINK http://www.assembly.org].
I didn't post an IOTD of the Stair Dismount last year as I thought
that I'll write a more lengthy post mortem about it. But time passed
and I was busy all the time, so I never got around to doing that.
Development time was just about 1,5 weeks for each. Both of the
games use OpenGL for the rendering. As can be seen from the images,
the graphics are very simple. They are still good enough for the
games to be fun, and focusing on other things made it possible to
develop these games in such short timeframes. For Stair Dismount it
took noticeable part of the development time to just tweak the
physics setup and get it somewhat stable and behave well enough.
I used the same base for Truck Dismount so I saved some hassle,
although I also made usage of some new features I hadn't touched
before in the ODE physics engine.
I made also heavy use of available libraries to put up the game and
all the features in it, which saved me a lot of time. Usage of extra
libraries isn't always a good thing though, especially if you don't
have any knowledge of them beforehand. Before starting to make Stair
Dismount I spent quite some time trying out several GUI libraries
and found out that none of them seemed to actually fit my purposes
this time, or at least not without some extra time to get a good
enough grip of the libraries not to get badly stuck while deadline is
getting closer. I could have used that time to make own GUI stuff,
which I ended up doing anyway. Due to lack of time I ended up doing
the GUI for Stair Dismount in horrible way. As I learned something
from this, I did it a bit better for Truck Dismount - in middle of
the development I stopped and took two days to make a simple GUI
framework. This is still not very much time to do a GUI system so
it's not very comparable to any actual GUI libraries, but it was
good enough this game and still a bit nicer to work with than the
stuff I used in Stair Dismount.
You can check out some development screenshots of Stair Dismount from
[LINK http://tAAt.fi/taat/porrasturvat/productionscreenshots/ here]
with timestamps and small comments about the progress. I have took
some similar screenshots from Truck Dismount as well, but I'll show
them up somewhere later.
Here's a list of libraries I found useful when developing these games:
- SDL, SDL_image, SDL_mixer ([LINK http://www.libsdl.org])
ODE ([LINK http://opende.sourceforge.net/])
Ogg Vorbis ([LINK http://www.vorbis.com/])
libpng ([LINK http://www.libpng.org/pub/png/])
libjpeg ([LINK http://www.ijg.org/])
libcurl ([LINK http://curl.haxx.se/libcurl/])
FMOD ([LINK http://www.fmod.org/])
CFL ([LINK http://iki.fi/sol/])
zlib ([LINK http://www.gzip.org/zlib/])
expat ([LINK http://www.jclark.com/xml/expat.html])
I also used tool called [LINK http://www.natew.com/juice/ Juice] to model
the guy from physics primitives. The body parts are kept together with
spherical and hinge joints. The guy can still get to some poses which
don't look very realistic even that some of its joints are properly
limited. This is because I chose to limit the amount of required
joints because using lots of them pumped up the CPU requirements.
Truck Dismount also has net top scores for comparison with other
players. The net scores can be viewed in the game and also from the
game home page. Stair Dismount also used to have net scores, but I
disabled them after too many hacks as I didn't have enough time to
make an updated version of the game with more preventions for that.
I took a bit effort to make cheating slightly harder in Truck
Dismount, but still it didn't last long. People just don't count
their hours when they have fun with a game and some good debugger
software. I don't validate the scores directly on the server
from the hit parameters as it would be quite CPU intensive, but I
have taken that into account and might make an external validation
software later.
The home page URL for the game is:
[LINK http://jet.ro/dismount/]
(L) [2003/08/08] [Stephane Redon] [n/a]
[LINK mailto:n/a Stephane Redon]
This image is from an interactive demo of our new discrete collision
detection approach for large-scale environments, in which the
Stanford dragon (250,000 triangles) breaks when the Stanford bunny
(35,000 triangles) falls on it. The demo runs on a pentium 2.4 GHz with
a NVIDIA Geforce FX 5800).
This discrete collision detection method is a graphics-hardware based
approach, which takes advantage of the new occlusion queries of the
recent graphics cards to efficiently cull away most of the non-colliding
objects or sub-objects. As opposed to most GPU-based methods for
collision detection, this method doesn't require frame-buffer readbacks.
This allows to achieve a high frame-rate for complex bodies. Moreover,
since no data structure is required, the method handles naturally
deformable bodies, breaking bodies, and changing topologies.
As this demo is essentially designed to test the CD method, the physics
part of the demo is a very simple implementation of impulse-based
physics . The dragon is organized in triangle strips and a heuristic
is used to remove some strips and propagate the fracture when the bunny
collides the dragon. Since no penetration depth is computed, the
velocity of the contact point on the bunny is used as the contact
normal. This gives satisfying results in this case. Note that the demo
shows that the method handles N-body collision detection as well, as the
parts falling on the floor may push parts which are already resting (cf
video [LINK http://www.cs.unc.edu/~redon here] )
The lighting in this image is a very simplified (hacked / not exact)
version of CPU-based image-based lighting, tested for fun. However, the
immediate-mode implementation was rather slow (15 fps, including
collision detection and physics) and has been replaced by simple
lighting in the video. We plan to implement the lighting in hardware
later (thanks to Paul Debevec for the permission to use his Light Probe
[LINK http://www.debevec.org/Probes images]).
More information can be found at my [LINK http://www.cs.unc.edu/~redon page]
at UNC (dragon video.) or at the paper's [LINK http://gamma.cs.unc.edu/CULLIDE/ page] by Naga Govindaraju (the paper's
first author).
Cheers,
Stephane Redon
redon [at] cs [dot] unc [dot] edu
(L) [2003/08/10] [LevDymchenko] [levdym@virtualray.ru]
This is screen shot from my concept game AntiPlanet. It is first PC 3D shooter
game based on real time ray tracing engine.
Demo is available here.
[LINK http://www.virtualray.ru/eng/download.html] (7MB)
Game details and technology presentation supplemented with wide theoretical
basis is available here.
[LINK http://www.virtualray.ru/article/raytracinggame.html]
I hate this screen shot as others and even want to remove it back. Because
static pictures do not represent well the main features of my ray-tracing engine
VirtualRay. Such as dynamic lighting, real time soft shadowing and dynamic scene
changing. By the way, here is list of graphic engine's features. I give it
accordantly to resolution 1024x768x32 and usage of modern CPU like Pentium4 and
AthlonXP
1. Rendering scenes containing thousands visible spheres. Actually, scene
may be really infinite, only local potential visible part is limited in sphere
number.
2. Per-frame computation of scene lighting. Every light source is dynamic.
Motionless light sources are dynamic to, because of scene my change around.
3. Per-pixel lighting and shadowing.
4. Soft shadows with alternating softness coefficient. It approximates
physical-correct soft shadows.
5. Up to 8 light sources per sphere. Thus, object could cast up to 8
shadows. Really, number of active light per sphere is 2 because of performance
lost.
6. Spot and directional color light sources are supported.
7. On each frame, position of any object can arbitrarily vary.
8. Rendering is carried out in true color.
9. Bilinear filtration of textures is supported with two modes, performance
and quality.
10. Limited management of transparent spheres is supported. Spheres'
transparency degree can dynamically vary. So transparent spheres can smoothly
turn opaque and vice versa. Independent transparency for each color channel is
also supported.
11. Two engine modes. Planet mode with flat rounded simple surface and space
mode with out dimensions. Rounded surface form horizon effect when far objects
smoothly disappear behind horizon. It allows simple visualizing of infinite
planets.
12. Relatively smooth frame rate. With out jerks.
Technology presentation also includes link to pre version of VirtualRay SDK
with source code examples.
Lev Dymchenko
(L) [2003/08/11] [BenjaminJillich] [benjamin.jillich@gmx.de]
This is a screenshot from my particle system editor i have developed for
a small racing game. To the system itself: It supports point, box,
cylinder and sphere emitters. Emitters pulse periodically since their
isn't set up an emission variance. Emission rate is the number of
particles to be created in one second. You can apply modificators on the
particles by clicking the check boxes. The more modificators are enabled
the slower the system gets. It is also possible to add new custom
modificators to the system. I use DX for rendering. The yellow box you
see is the system's AABB.
(L) [2003/08/12] [ChristopherColyer] [admin@turt99.com]
Turt's Puzzle Blocks multi-platform puzzle game, designed for both Linux and Windows. Turt's Puzzle Blocks is also the current project of Turt99 Productions. The goal of the project is to gain experience C++ and Object Oriented Design, as well as to help in the learn process of Linux as a development platform.
Turt's Puzzle Blocks is created using KDevelop 2.1 under Linux Redhat 9.0, and uses the SDL libraries. SDL was chosen because it is a multi-platform library that would allow the seamless development for 2 operating systems. SDL main library supplies the support for the windows and the display, but Turt's Puzzle Blocks also uses two additional SDL libraries SDL_image and SDL_Mixer. SDL_image supports the use for PNG and TGA files, which allows for Alpha blending and results in clean lines and smooth graphics. SDL_mixer is used for playing sounds and the background music.
Please visit [LINK http://www.turt99.com www.turt99.com] for more information, and more screenshots.
(L) [2003/08/13] [JesseLaeuchli] [jesse@laeuchli.com]
This shot shows Volumetric Clouds being rendered. The demo uses 2.0 Pixel shaders under DirectX to render the clouds.
It does this by sampling a 3D texture of Perlin Noise, and using it to build a 5 octave fBm. The fractal is then used to
disturb the point currently being rendered. The point is then fed into an implict equation. If there is more then one
implicit equation being rendered(in other words, more then one cloud), then it is possible to blends between them.
This is similar to the effect described in Texturing and Modeling, except adapted for more limited resources. A
friend of mine had this running at ~20 fps on his graphics card. The thing that would most improve this
effect would be the ability to generate noise on card. I know you can does this if you use PS_2_X, but
then you can not run it on ATI cards. Generating 3D Textures can take quite a long
time(not to mention the texture memory which it eats up). Also, a texture of noise has a much more
limited range then most noise implementations. Baring GPU noise on all pixel profiles however, it would
be nice to have 4D textures, so that the clouds could be animated.
(L) [2003/08/17] [TheNorthernDragons] [feedback@northerndragons.ca]
The Etherium is a 4k intro created by the Northern
Dragons, a mostly Canadian demo group. The Etherium
took about six months of work and 7600 lines of code,
including 4500 lines of production-quality x86
Assembly and 2100 lines of C++ prototype code. From
start to finish, our objective was to create the
best-looking 4k intro possible.
To save space, most visual effects in this intro rely
on alpha, z-buffer, and backface culling tricks. For
example, our reflection technique uses alpha blending
and z-buffer clipping, rather than the more expensive
env-mapping or render-to texture techniques. We also
perform cross-fading between scenes by tweaking the
alpha channel on the affected objects, rather than
mixing two separate scenes.
The main idea behind this intro is code recycling. By
writing generic routines, we reuse the same code in
many locations. For example, we have a routine that
takes a 20-byte list of key colors, and interpolates a
256-entry color look-up table. We use this routine to
color everything, including textures, diffuse vertex
components, and stars. As another example, we use the
texture generation routine to make a height-map for
the island, saving several hundred bytes of code.
You can get The Etherium from
[LINK http://www.pouet.net/prod.php?which=10569].
(L) [2003/08/18] [OhadEderPressman] [ohad@visual-i.com]
The PQ-Torus, or PQ-Torus Knot, is a parameterized version of the well-known Torus (A donut-like geometrical shape).
P and Q are two parameters we use to modify the toruse's shape.
The first place I saw a PQ-Torus at was : [LINK http://www.blackpawn.com/texts/pqtorus/default.html], they have some nice screenshots and a downloadable implementation of their PQ-Torus.
There is a small toolbar through which you can control the toruses' parameters, including P, Q, Radiuses and Texturing mechanism.
I used my own approach to generate Normals for my Torus in real-time, which allows real-time wiggling, jiggling and morphing of the torus.
The nicest feature is the ability to shift P/Q values and watch the torus morph from one state to another.
Here's the link: [LINK http://ohad.visual-i.com/exper/exper.htm#pqtorus]
Ohad Eder Pressman
IMR
(L) [2003/08/20] [FireElemental] [felemental@cogeco.ca]
Some of you might know me as Fire Elemental from #flipcode
[irc://irc.enterthegame.com/flipcode] . This is the game I have been working on
this summer so I can make money to buy food. This PocketPC game is called
Zwanzig. Currently I only have an ARM version compiler, but if there is a demand
Ill recompile it.
I built the game using Microsoft eMbedded Visual C++ 3.0, Microsoft eMbedded
Visual Basic 3.0, Visual Basic 6.0, and Paint Shop Pro 7 and 8. The frontend was
done in eVB, and the actual game is all C++. All the GAPI work was done through
[LINK http://pocketfrog.droneship.com/ PocketFrog] which made everything so fricken
easy, fast, and compatible. eVB on the other hand has made my life a fricken
hell.
Zwanzig has over 60 levels, a save/resume feature for on-the-go play, and record
tracking features. You can find more information or post naughty message on my
forum over at [LINK http://www.polycat.net/ElementalArts/ Elemental Arts]. Also, Id
just like to thank [LINK http://www.polycat.net Trent Polack] for hosting my stuff.
(L) [2003/08/23] [lvermeulen] [lvermeulen@shaw.ca]
Here is a shot of Nexuiz, a 3d deathmatch game being developed by [LINK http://alientrap.com Alientrap].
Nexuiz is almost complete, with very advanced technology. It runs on a extremely
advanced version of the quake1 engine, with quake3 maps, realtime lighting and
shadowing, bumpmapping (not featured in that picture although), ragdoll, advanced
model format, and tons of other features.
The nexuiz game is almost complete. It will feature 20 deathmatch levels and 3
capture the flag levels, and over 30 characters to choose from.
We are also looking for help with programming to finish the game. If you interested
e-mail me.
(L) [2003/08/26] [KangHan] [kang@kanghyunhan.com]
This image is from "Little Beasts", a 2 player puzzle game I've been
working on for the past 3 months, from initial concept to the current
alpha version. This single person project was developed using Visual
Studio .NET (C++), DirectX (graphics and audio), 3DS MAX(3d models)
and Photoshop(interface, texturing, etc). Particle/explosion effects,
efficient font engine, and smooth camera tracking are some of the
advanced features for now, and I'm also testing some DirectX shader
effects for shadow and cartoon rendering. My current focus is on
tweaking the gameplay and finding bugs before adding more features,
for I believe the FUN factor should receive the highest priority.
If you'd like to download the demo or find out more, please visit
[LINK http://www.kanghyunhan.com/lb]. I need some guinea pigs, I mean, people
to test the demo for gamplay and compatibility issues, so check it out!
(L) [2003/08/28] [ErikHanspers] [erik.hanspers@abc.se]
This is a small stencil shadow demo I wrote when reading the nVIDIA
paper [LINK http://developer.nvidia.com/object/robust_shadow_volumes.html "Practical and Robust Shadow Volumes"].
The demo features two animating lightsources over a plane with a
triangle floating above it, properly casting shadows using the zfail
stencil shadow volumes approach.
The code weighs in at 800 lines, and still includes some unused
parts. I implemented this in july 2002, and it took perhaps a day to
get done. The nVIDIA paper includes a lot of source, so this was no
great undertaking, but I guess it may still be interesting for other
coders who have not done this to look at.
You will need [LINK http://www.opengl.org/developers/documentation/glut/index.html GLUT]
to compile the code. I have successfully compiled and run the code on
Windows, Linux, OpenBSD and Solaris.
The program may be modified and copied without permission.
Download: [LINK ftp://ftp.flipcode.com/demos/iotd-08-28-2003_stencilshadow.tar.gz iotd-08-28-2003_stencilshadow.tar.gz] (5k)
(L) [2003/08/29] [IsmoHorppu] [ismo.horppu@nic.fi]
I recently converted my old 2D graphic effect 16-bit programs to Java applets. The image
consists of: plasma (top left), motion blur (top right), gray-scale linear bumpmap
(middle left), bumpmap with phong illumination (middle right), fire (bottom left), and
arbitrary edge texture mapper (bottom right).
I think that the Java applets are useful for some (Java) 2D gfx newbies. All the source
codes are available from my www-site: [LINK http://www.jyu.fi/~ishorppu/]
REMARK: the applets are compiled with JRE 1.4.2 (so you may need to install the
runtime in order to run the applets), and have been tested with Internet Explorer 6 SP1.
(L) [2003/09/02] [IñakiAyucar] [iayucar@yahoo.com]
This is a pic of my work.
It shows lightmapping for shadows and some water
simulation including geometry animation via vertex
shaders, dynamic cube-mapped reflections, transparency
and shadows projected on water.
The sun is simulated with a billboard and includes
some secondary flares for the lens effect.
The geometry is composed of about 12k polygons and it
runs at 27fps on a GeForceFx5800.
Thanks a lot.
Iñaki Ayucar.
(L) [2003/09/04] [BrunoLevy] [Bruno.Levy@loria.fr]
This image demonstrates how to achieve dramatic mesh reduction while
preserving the visual appearance of objects using GPU programming.
The first image shows a 500 facets version of the well known Stanford
Bunny.
The second image shows a normal-mapped version. Note that the triangles are
still visible around the silhouette.
The third image shows a normal-mapped version, with Bezier triangles
generated by the GPU, using vertex shaders. Note the smooth silhouette.
The normal-map is generated using our LSCM parameterization method.
The Bezier triangles are generated using Vlachos's approach.
Credits:
Mesh decimation algorithm: Nicolas Ray
Bezier vertex shader: Wan Chiu Li
Biblio:
- Vlachos, Peters, Boyd, Mitchell, Curved PN Triangles,
ACM Symposium on Interactive 3D graphics, 2001
- Levy, Petitjean, Ray, Maillot, Least Squares Conformal Maps,
ACM Transactions on Graphics (SIGGRAPH), 2002
Links:
Publications and more details can be found in my home page:
[LINK http://www.loria.fr/~levy]
(L) [2003/09/05] [BenClayton] [fishface@alien-legion.com]
For the last year I've been building my own engine to research into the new
effects used in the next generation games, i.e. Doom3. One effect I was
interested in was bump-mapping. I decided to give a shot at trying to
reproduce the way that Doom3 calculated it's normal maps from high detailed
models, to then be placed on a much lower resolution model.
My method uses the Object-Orientated normal map approach. Like most
bump-mapping techniques, this approach requires a unique triangle on the
normal map per face, so reusing the UV mapping from any texture mapping
would not always work. So what I needed was to create a separate normal UV
mapping for the model. The normal UV mapping could be created by hand in a
modelling program such as 3DS Max, but I liked the idea of writing an
Unwrapper, so here it is.
Unlike most unwrappers that already exist; the unwrapper does not try to
keep faces that are neighbours on the model as neighbours on the UV map.
Why? Because there's no need to. The UV mapping would only be used
internally, with no need for any human to try and understand which triangle
relates to which face.
So the result is this UV-unwrapper. The method of unwrapping is quite a
complicated one, but is basically an ever growing polygon, which uses a
horrendously complicated edge matching function to find where to place the
next triangle. The white lines you see are the edge of this polygon. By
placing the largest triangles first, any gaps formed in the polygon are
usually pretty well filled by smaller triangles later on, meaning quite an
efficient normal map.
The model in this picture was around 800 polygons, and took about 2 minutes
to unwrap. I feel there is more optimisation to follow!
Thanks for reading.
Ben Clayton.
(L) [2003/09/08] [Dominique Biesmans] [n/a]
[LINK mailto:n/a Dominique Biesmans]
This image shows a Windows simulator of a handheld game called PackMonster.
I tried to be as faithful as possible to the original, as well with the
audio & visuals as with the behaviour of the game. I have played the real
game and the simulator for hours & hours, in order to get every little
animation & transition effect right. I'm pretty happy with the result.
The top image is the simulator, bottom left & right are pictures of the box
& console, the middle is a (blury) close up picture of the playfield of the
console.
The game requires a Windows PC with a soundcard & a display capable of
1024x767 in 16 bits or higher. 800x600 works as well, but with a 'reduced'
console.
You can download it here : [LINK http://dominique.biesmans.com]
(L) [2003/09/10] [DerekBradley] [derek@derekbradley.ca]
I think anyone who is really into 3D graphics programming has made a basic
terrain engine at some point, so I wanted to do something a little different.
For my 4th year honours project at Carleton University I did a research paper
(with implementation) comparing different Terrain Level of Detail techniques.
The algorithms I compared are the Röttger, ROAM and Lindstrom algorithms, and
the comparison was based on an evaluation of polygon counts versus terrain
accuracy. Granted, this is more of a GIS point of view since most game
developers won't give a rat's elbow whether or not their terrain is 100%
accurate as long as it is fast and uses minimal memory...but like I said, I
wanted to do something different.
The paper is available on my site, as well as the source code of the
implementations (which make use of an engine I created called the DK
Engine). Click [LINK http://www.derekbradley.ca/3DGraphicsEngines/DK/TerrainLOD/index.html here]
to go directly to the Terrain Level of Detail project, or browse my entire
site [LINK http://www.derekbradley.ca here].
Derek Bradley
(L) [2003/09/12] [MaciejMatyka] [maq@panoramix.ift.uni.wroc.pl]
Picture which I present today is taken directly from my actual
work for gameversity.com seminar on physics cloth simulation.
Techniques here are based on spring-mass system with inverse dynamics
constraints implementation (Provot). These constraints gives us an
opportunity to use low order numerical schemes (Euler and Mid Point) and
however obtain good behavior of the clothes.
For implementation I used C++ with a glut OpenGL view.
Three examples presented there are not all made with existing
project, rest of them can be found on my web page.
With Regards,
Maciej Matyka
[LINK http://panoramix.ift.uni.wroc.pl/~maq]
(L) [2003/09/14] [YueFei] [yfei@rice.edu]
This is a test shot of 2D desktop (upper) and 3D objects in 'Cube'.
I am working on an independent project: 'Infinite-3D'. The current stage of
'Cube' is able to dynamically capture the GUI output of Win32 windows (no
matter they are overlapped or not) and show them as 3D object, and the mouse
and keyboard inputs in 3D are redirected back to these windows. Cube will be
released in 1 or 2 months.
The long term goal is to build a user-application interaction environment
which provides immersed 3D user experience, smooth support for current 2D
applications, and 3D APIs for new applications. Users are collaborative
through network. It is a scalable and portable system, and designed to
accommodate latest hardware.
More information can be found at [LINK http://www.infinite-3d.com]
For more details and current implementation info, please contact me directly
at yfei at rice.edu
(L) [2003/09/15] [MariusFahlbusch] [Marius.Fahlbusch@gmx.de]
Above you can see my Scriptable Particle System along with its editor.
It uses STL, DirectX 8 and LUA for scripting.
I was in the need of scriptable effects for a little sorcerer's fighting game and every spell 'eye-candy' I thought of is now possible.
Note, that scripts for the emitter and sparks are optional. As you can see on the golden particle bowl in the lower left corner, good looking effects are possible without any scripting as well.
In the lower right corner of the editor you can see the command line, that lets you pass script commands to the system
immediatly and thus experiment with parameters.
Scripts loaded for the effects are buffered and then executed every frame, or at desired intervals.
The ParticleSystem communicates with the script interface via a stack, so scripting the effects is very easy.
Things left to do:
* DLL plugin system for custom export formats (binary format by now)
* extend script functions
[LINK http://www.spunkcode.net]
Hope it inspires,
Marius Fahlbusch
(L) [2003/09/16] [NikolausGebhardt] [niko@nospam_code3d.com]
This image shows 4 shots of a relatively young but powerful 3D engine, which
is called The Irrlicht Engine. It is a completely free, zlib licence based
open source 3d engine, and exists now for about a year, being improved and
extended constantly. It is hosted at sourceforge and its homepage can be
reached at [LINK http://irrlicht.sourceforge.net]. In September, the 6th release of
the Irrlicht Engine SDK has been made, named version 0.4. Since this
version, it is now possible to create high speed state-of-the-art 3d games
and applications with it.
Irrlicht uses a quite different approach than most other 3d engines do. It
tries to be fast, extensible and flexible, but the main aim is to be as easy
to use as possible. In this context, it is for example possible to start up
the engine, load a complete Quake 3 map, display it and let the user move
within this map with only about 6 lines of code. But it is also very
flexible, the programmer is able to change and influence almost everything
in the engine although it is that easy to use. To see how this works, just
take a look at the tutorials on the website.
To keep this text short, I'll list some main features of the engine for an
overview:
- Uses both OpenGL and/or Direct3D for rendering. In addition, there is a
software renderer, and a null device.
It's platform independent. You'll only have to write your code once and it
will run on all supported platforms, which currently are Windows and Linux.
It supports standard 3D special effects like stencil buffer shadows,
particle systems, transparency, lightmaps, texture animation, realistic
water, .
It does not need exporters. For increasing your development speed, the
engine directy reads lots of common file formats like .bmp, .psd, .jpg,
.tga, .3ds, .ms3d, .obj, .bsp, .zip, and .md2
Due to its flexible scene graph, complex things like mixed indoor and
outdoor rendering is possible.
Detailed descriptions can be found on the engines homepage.
(L) [2003/09/18] [NicholasBalke] [nicholas.balke@statevector.com]
The image contains some shots of Hellhog XP, a 3D orbital combat shooter by
StateVector Games,
an independent game developer based in germany.
Hellhog XP is a fast-paced straight arcade-style action game using my
current game engine 'Phoenix'.
Phoenix is an advanced, high-quality generic engine with a full set of
features like:
- hardware abstraction layer for rendering (current renderer based on D3D7)
hardware independent shader/material pipeline
modular architecture (core,objects,gamedll,...)
generic object/unit implementation model for entity classes and
'functions'
terrain subsystem
CSG-based interior (with static and dynamic lightmaps)
portal-based visibility system
scripting subsystem based on LUA
xml-based configuration /campaign scripting /player and ai class
definitions
a complete toolset (opengl based level editor, material/shader editor,
particlefx editor,..)
and of course lots more .. but I don't want to get too boring here.
(BTW.: all implemented in C++ using VC6)
Hellhog XP does not use too many features of the engine as it is a
relatively simple (I prefer the term uncomplicated :)) arcade shooter.
It has got pre-rendered environments made with Povray and Terragen ,
combined with
realtime flare units and particle effects (for nebulas and stuff).
Sound is an important aspect , so music playback is currently done using mp3
via Amp11Lib,
but i consider changing to Ogg Vorbis.
2D/3D sound effect units are implemented using pure DirectSound.
Game weapons / weapon effects (like explosions and firetrails) are based on
a generic multilayer effect system
that groups together various types of components like 2D/3D sound sources ,
D3D light sources, mesh models or particle fx
to build complex effects. As these multilayer effects are defined using xml,
it is now very easy to create new
game effects in a data-centric manner.
Upcoming games will make use of more engine features to implement
ground-based outdoor or indoor scenarios
and multiplayer modes.
There are already 2 more projects in the lab which are about 70-80 % done.(I
know .. it's getting really painfull at 99% :))
If you are interested in more information about my current and upcoming
projects
visit [LINK http://www.statevector.com].
The latest demo for Hellhog XP is also available for download and
the full registered version of the game will soon be available for purchase
online there
(as my games are distributed under the shareware concept).
Contact me at [LINK mailto:nicholas.balke@statevector.com nicholas.balke@statevector.com]
Your feedback is always welcome.
Best Regards,
Nicholas Balke
(L) [2003/09/23] [AlbertoDemichelis] [alberto@ademichelis.com]
Squirrel is a project I've been working on since a while.
It's a scripting language designed to be embedded in a game engine.
My design tries to solve the major problems that I've encountered with the
scripting languages I've used in the past.
I'm also trying to keep the thing as small as possible.
The current release is 0.2 pre-alpha, but for what the people that are using it
told me, there aren't any major bugs.
Squirrel has a wide range of features:
- Open Source zlib/libpng licence
fast register based virtual machine
dynamic typing
delegation
higher order functions
generators
tail recursion
exception handling
automatic memory management (CPU bursts free; mixed approach ref counting/GC)
both compiler and virtual machine fit together in about 6k lines of C++ code.
Squirrel is hosted by sourceforge
[LINK http://squirrel.sourceforge.net]
Alberto Demichelis
(L) [2003/09/24] [GiulioMainardi] [giulio_mainardi@tin.it]
This picture shows four frames of an animation made with a ray tracer I am developing for my personal education.
The shadows on the ground slide as an animated light source follows a circular path above the terrain.
The height field is not converted into a polygonal mesh, but is ray traced directly, with a technique similar to the Grid Tracing(GT) algorithm ["Grid Tracing: Fast Ray Tracing for Height Fields", F. Kenton Musgrave, 1989].
The main differences are in the 2d grid traversal and in the ray-surface interections calculations.
Infact, like GT, to reduce the number of the ray-triangle intersection tests, the algorithm finds the height field cells intersecated by the orthogonal projection of the ray on the ground plane, but while GT uses a modified version of the Bresenham line drawing algorithm to scan these cells, I perform a 2d traversal of the grid like in ["A Fast Voxel Traversal Algorithm for Ray Tracing", J. Amanatides, A. Woo, 1987].
About the second difference: GT first finds the intersection point of the ray with the plane of a triangle and then, if this intersection occours, checks, with a fast test derived from the "regular structure" of a height field, if this point is in the triangle. A big disavantage of this approach is the need of the plane equation for each triangle of the height field. So I simply used the ray-triangle intersection routine described in ["Fast, Minimum Storage Ray-Triangle Intersection", T. Möller, B. Trumbore, 1997].
The vertex normals are computed with finite differences.
For the curious: the alien landscape of the video is rendered from a "unusual " height map...see the bottom link for more details.
The video can be downloaded from [LINK http://risapi.sourceforge.net/index.html#d100903].
Please forgive (and forget) my poor English;)
(L) [2003/09/25] [FrancisXavier] [taskforce_reivax@rediffmail.com]
I'm working on a 3D Engine of my own and I just wanted to show off a few shots
of my 3D Renderer. Nothing that great, it uses BSP trees for calculating the PVS
and for collision detection. Supports static & dynamic lights (point
lights/spotlights). At the moment only static shadows are implemented (the
famous lightmap!) but I'm working on implementing stencil buffer shadows too
(Doom3 style!). The sky is done using a skybox. Some of the textures I made
(Photoshop) and some I downloaded from the net for free. My Renderer uses
Direct3D. I feel really great because this is my first Renderer ever!
The top left image shows a castle being designed in my custom level editor. The
top right image shows the same castle, rendered using my Renderer (it's quite
dark, because it's supposed to be evening). Bottom left/right, are rendered
views of the castle interior.
Hope you like it!
Francis Xavier
(L) [2003/09/29] [LiamChilton] [evilcheese@ninjazone.net]
These screenshots are taken from my current project, Xenos.
This is a technical demonstration project, showcasing a new algorithm allowing
fast visualisation of geometrically complex terrains.
Xenos uses an extremely fast preprocessing stage to allow complex surface
geometry and contours to be visualised using a combination of large polygons,
dynamic normal mapping and layered textures, allowing very large view distances
without the need for fogging or limiting clipping planes.
The screenshots demonstrate how geometric surface detail (down to the level of
individual per-pixel brush strokes from the paint package used to create the
heightmap) can be represented without recourse to large poly counts or custom
shaders.
As view position moves closer, extra geometry is introduced seamlessly, to the
end that the detail visualised from distance can then be freely explored at
close quarters.
The engine also employs LOD in the form of a hybrid approach, mixing elements of
split-only ROAM and Geomipmapping, together with unique variation analysis to
allow important detail elements to be preserved at large viewing distances, as
well as allowing seamless changes of patch LOD without the need for
edge-traversal or vertex rearrangement to prevent mesh tearing.
This demo currently renders a 1024x1024 heixel map at ~200 fps on a 1300 Celeron
system with Geforce-3 Ti-200 without any form of frustrum or occlusion-based
culling mechanism.
If you have any further questions, feel free to mail me.
(L) [2003/10/01] [ArminJahanpanah] [jar@scyence.net]
These are some screenshots of "elastic", a demo for evoke2003 held some
weeks ago
in cologne, germany (it came 4th). On the pictures you can see:
- volume fog
per-pixel NDF shading (see Jan Kautz/Game Programming Gems 3)
mesh deformation/morphing
simple terrain rendering
metaballs (marching cubes algorithm)
We created our own 3d engine "SR" which has the following features:
- highly portable and modular rendering system, very platform independent
full rendering sub-system abstraction (rasterizer, texture units, vertex
unit, lighting, etc...)
importer/exporter system for image formats and 3d scenes
OpenGL rendering "driver" (D3D in the works)
plug-in based vertex- and fragment shader system
DOT3 + DUDV bump mapping
cubic environment mapping
...
The demo and engine were coded using VC6 and doxygen.
For more information go to [LINK http://www.pouet.net/prod.php?which=10748]
Our group "science" ([LINK http://www.scyence.net www.scyence.net]) is still looking for talented 3d/gfx
artists
for future game and demo projects.
(L) [2003/10/03] [MaciejMatyka] [maq@panoramix.ift.uni.wroc.pl]
Picture which I submitted to IOTD gallery contains screen shots of my Soft
Body
Simulator, from the newest version - 2.0 of it. Method which I developed
for Soft
Bodies Behavior simulation is rather new and original. I mean that I did
not find any
similar research work about Soft Bodies.
I work with pressure model of Soft Body. For example a ball with an air
inside of it is
an example of pressure based soft body. What I really had to do in that
simulation was to
calculate a pressure for my body, then distribute it into all finite
elements of the body.
For pressure calculation I used Clausius-Clapeyron equation, which is
known from fundamental
thermodynamics physics.
There were some problems during developming of that simulation. Two of
them are most
important and that are:
- volume of the body calculation
- body - body collision detection & response
For both of them I used simplification. I approximated the soft body by an
bounding
rotated ellipsoid. It gave me possibility to calculate a volume with a
quite resonable
accuracy. I also used them to make collisions of the bodies. Collisions
work very well for
"ball" type of objects only. But volume calculation is quite good for all
objects.
Soft Body Simulator 1.0 - a previous version of that software took 2nd
place on Programming
Contest on Physics Educational Software on my home University of Wroclaw
(Poland). Working
application of Soft Body (both 1.0 and 2.0 versions) for Windows operating
system you can
download on my web page.
Graphics and 3d model of the hand presented here are created by
inz. Marcin Jarosz especially for Soft Body 2 project. Thank you.
Maciej Matyka
[LINK http://panoramix.ift.uni.wroc.pl/~maq]
(L) [2003/10/07] [KennethHurley] [klhurley@signaturedevices.com]
This image is a set of screenshots of an early prototype of a game we are
developing.
We have licensed the CryEngine ([LINK http://www.crytek.de]) and are using it for
the PC and
XBOX version of the game.
We currently are developing a prototype for our game to seek out a
publishing deal with
major game publishers. We currently do not have a publisher. We have the
game design
finished and the project planning in place. So far this has been self
funded.
We are not looking for a lot of money to develop this game, as most of the
work
has already been finished. Physic (Rag Doll, vehicle, etc.), AI, Rendering,
sound
and music has already been implemented.
The team consists of some industry veterans who have worked for companies
like
Electronic Arts, Activision, Epyx, Blue Shift, SSI and others.
We are quickly progressing to a prototype that will show the game.
Some information about the company can be obtained at our website:
[LINK http://www.signaturedevices.com]
If any publishers would like to contact us regarding publishing this game
they may do
so at the above address.
Kenneth Hurley
(L) [2003/10/08] [RichWilson] [rich_wilson@comcast.net]
These are images from a game project I have been working on for the past two
months. The game is called Chaos Chronicle, and it is going to be my submission for the
2004 Independent Games Festival, as well as my final project for my masters degree in
Software Engineering. It's a multiplayer internet game, where two players take the role
of gods, and the rest are adventurers. The gods' duties are to help or hinder the
adventurers, based on the side they choose at the beginning. They then customize the world, placing
dungeons and town pieces, while the heroes make their characters. The idea is to have a
condensed adventure experience, completing a whole quest in one sitting, so the hero
characters are abstracts of the stereotypical hero types. Throughout the game, the gods can
guide the players, dropping helpful items, providing direction, or provide them with
opposition, breeding monsters and crafting labyrinths that guard the treasure they seek.
It's all part of an experiment in what I've come to call Simultaneous Disparate Interaction
Models.
Anyway, the images areas follows:
Header - the icons on the left are the symbols representing the different
available character
classes: Ranger, Warrior, Thief and Wizard. To the right of that is the first
character model I have produced, that of the warrior.
Next row: On the left is a screenshot from my tile editing program. I created
it, and the whole game, in director. The tile editor allowed me to make several map screens,
60 as of this writing, that conform to a certain format. These tiles are then randomly
arranged, so that the facing sides match, into a world map. This map can be seen on the
right. Between these two images are samples from the hero creation screen, with the elemental
alignments and character attributes.
Directly below the tile editor is the dungeon editor screen. This will be close
to what is seen by the gods in-game. The dungeon itself is randomly generated, then the gods
"fill" rooms in by selecting areas bound by corridors. These rooms are then populated by
monsters and treasure, etc.
To the right of this are two sample screens of the weather system in the game,
on the left is snow, and the right one is rain. The hero interface is a 3rd person 3d view.
On the bottom left is a shot of one of the buildings the god can create, the
temple. Characters can go here to revive their dead.
Finally, the bottom right is a screen of game in action, though some interface
elements may change. Each quad that you can see on the unfinished tiles corresponds to one
pixel on the map above, so the world ended up being pretty huge, which may or may not be changed
for the betterment of gameplay. The whole thing is streamed, as well, so a character can
walk from one end of creation to the other without a load screen of any sort.
With 7 weeks remaining, I have a long way to go, but I feel pretty positive
about what I've got so far. Any questions, comments or job offers are welcome.
Rich Wilson
Starving artist, programmer & aspiring game developer
[LINK http://mywebpages.comcast.net/Rich_wilson]
(L) [2003/10/09] [desgraff] [webmaster@desgraff.com]
Here is the official Beta version of the Decoy3D engine v0.5. Still in very early
development, after 3 months of coding on my spare time, you can actually
see it in action. There is still a few bugs with the gravity (fixed in next version).
- I need testers
Can someone make a beautiful 3ds level, with email written permission? (featured on the next Beta release)
Level loading supports 1 load for now (If I get many levels, there will be multiple level loading next release,
with dialog stating the creators, cool!)
Can M2D modelers donate their MD2 RPG model with email written permission ?
Next release will have dynamic interface and menu system.
Ogg level Playlist soon will be functional
visit [LINK http://www.desgraff.com www.desgraff.com] to see this project.
(L) [2003/10/10] [SergeyVorsin] [regmail@hotbox.ru]
This is a project S16 (Sykorsky-16), a flight simulator of the 1st World War.
Here is a brief info about the engine:
Physical engine (developing): --- Aircraft physics engine:
- Based upon rigid body dynamics and aerodynamics.
Collision uses collision convex volumes
Areodynamics uses an active planes for forces computation
Almost any model of aircraft can be simulated
Graphic engine (developing), uses Direct3D:
--- Terrain render engine:
- Maximum terrain sector size: 2048x2048. Final size of sector file up to 1Mb
(100*100 Kilometers of terrain is about 100Mb (with terrain detail 10 Meters))
Terrain block size: up to 32 map pixels
Terrain shaded with lightmaps. Terrain casts shadows.
Bump mapping
Terrain render uses Pixel Shaders, 4 texture stages: 1 - Light map; 2 * User
defined textures; 3 - Generated grass\cliff\snow textures; 4 - User defined bump
mapping
Unlimited count of trees and reasonable framerates (about 100 fps without
water (Forest square is about 10*10 Kilometers)). Rendered with shadow maps. The
size of result file does not depend upon quantity of trees. The engine uses 3
types of render techniques, which depend on optimization factor:
1st - detail trees render (sphere trees technique or tree models), distance
500m
2nd - imposter trees via VertexShader (integrated into VertexShader)+Bump map,
distance 2Km
3rd - planar tree maps+Bump map, distance - unlimited
Dynamical sky lighting (24 hours), background cubemap support also.
Clouds. Use billboards.
Lakes. Uses offset bump mapping for fast computation. Dynamical reflection,
transparency, specular highlights, fresnel effect as well.
--- Model render engine
- Bump mapping with specular highlights
Of course, blended bones for animation
Uses PixelShaders
Shadow volumes computation via VertexShaders
Developed under VC6.0,
Any comments and questions refer to [LINK mailto:regmail@hotbox.ru regmail@hotbox.ru]
(L) [2003/10/13] [JTHooker] [Tubular42@aol.com]
This is the project I've been working on for the last two months, a 3D
shareware pinball game, probably going to be named 3D Pinball Arcade. The idea
was to make a pinball game in the tradition of real-world pinball machines that
was in full, real-time 3D (something that doesn't seem to exist already
anywhere I've looked) where it would be easy to design and build tables quickly.
This way I could afford to build a large number of tables in addition to the free
one, providing a large incentive for players to register.
One thing that should be obvious is my desperate need of a decent artist
for drawing table and back-glass surfaces. What you are looking at is my
Programmer Art, which I'm not proud of. Any good 2D artist with an intuitive sense
of graphic design would be most welcome to join me on this project for royalty
payments. Anyone interested can email me at [LINK mailto:Tubular42@AOL.COM Tubular42@AOL.COM] with some
samples of their work. I would prefer hand-drawn art, but most important is a good
sense of layout and aesthetics.
The game is about 60% done, including physics, sound, animations, a script
parser for programming the table's rules, and most of the 3D graphics basics.
The shot at the top of the picture shows my first table at its current state
of development. The table is named Everest, with a mountain climbing theme.
The shape of the base of the table is built out of transparent textures
generated from the collision data, which is just a bitmap itself showing solid areas
and table items. On top of that, the ramps and the mountain platform are a
single 3D Studio model, and the bumpers, lights, and targets are separate models
and textures referenced by the table's layout file. This cuts down 3D modeling
tasks to just the problem of trying to build the ramp rails without letting
the polygon count get out of hand. Still to come are a decent 3D backdrop to the
playing screen, and a 3D "arcade view" for choosing which table to play.
The bottom right part of the picture shows my original table design, which
I drew before actually beginning coding on the game itself. I think it turned
out fairly close to the original design, which makes me optimistic that it
will be powerful enough to build a wide variety of tables.
The bottom left part of the picture shows a small sample of the script
which controls the table's behavior. The script language is a simplified version
of C, with a few touches from Pascal only added to make the compiler easier to
write. I decided to write my own compiler and virtual machine to make sure
the language had all the features I needed, ran fast enough, and could be easily
integrated with my program. It uses a simple Context Free Grammar of only 110
terms, and an extremely simple first-fit method for parsing. This way I was
able to finish the whole compiler and VM in a little under two weeks using just
over 1000 lines of code, and including features like local functions, switch
statements, and a preprocessor that scans through the code looking for sound
and graphics calls, pre-caching the assets when needed, and replacing their
reference in the code with a handle to the unique copy in memory. The only
drawbacks to my simple compiler are that order of operations doesn't work on some
complex expressions, requiring what would otherwise be unnecessary parentheses,
and syntax error messages are extremely cryptic or misleading. However, due to
the relative simplicity of Pinball rules, I was willing to make these
sacrifices.
Once all of the kinks are worked out, designing additional tables should
be a breeze, and anyone with medium skill in programming and a decent knowledge
of pinball should be able to pull it off. I should stress that this is not
going to be a table-building toolkit, as the tools I've been using aren't
exactly user friendly. It's merely a way of making my work easier in building many
tables. However anyone interested with good skill may contact me if they're
interested in helping me design a table for a small cut of the profit.
Thanks to anyone who read this whole thing for their interest and keep
an eye out for an IOTD or release of the finished version when I'm done!
Hopefully in mid October.
JT Hooker
(L) [2003/10/14] [JohnnySjöberg] [jonnysg@vattnet.com]
This is an image from my Fractal Generator Program (FGP), which I have written, showing a magnification of the Mandelbrot set. It is capable of renderin Julia Sets and Mandelbrot sets and uses one of my own coloring algorithms to get this nifty effect you see in the picture.
this Image was rendered using only the Windows GDI and not DirectDraw, Direct3D or OpenGL.
It works well under WinXP on my computer with 256MB Ram; It uses an AMD Athlon Processor and operates with a speed of 1GHz.
Feedback is greatly appreciated!
- Johnny Sjöberg
(L) [2003/10/16] [MauriceRibble] [mribble@ati.com]
Here are some screen captures using SMARTSHADER effects on Id's Quake 3.
SMARTSHADER effects are a new feature added in ATI's CATALYST 3.8 software
suite. These effects perform post processing on any double buffered OpenGL
or D3D application with the programmable fragment shader hardware found
RADEON 9500 and higher graphics cards (RADEON 8500-9200 have a limited
number of effects exposed in OpenGL).
Internally I refer to these special effects with the more descriptive term
specialSwap. I say more descriptive because these effects apply the special
fragment shaders to the back buffer just as it is swapped to the front
buffer. Since most people here are application/game developers and not
driver developers it's worth noting all of these effects can be done on
graphics cards by using pBuffers and the ARB_fragment_program OpenGL
extension.
The top left picture uses the Classic effect. Here fragment shaders are
used to convert an image into a sepia tone color space. The top right
picture uses is the Stylize effect. This effect uses fragment shaders to
convert low intensity pixels to gray scale. The bottom left picture is the
Sketch effect. This effect uses fragment shaders to perform a Sobel edge
detection algorithm. The last picture is the ASCII effect. To really be
impressed with this effect you need to see it at high resolution and in
motion. The basic idea behind this effect is to find the average value of
block of pixels and then use a texture lookup to access the corresponding
ASCII character for that block's intensity.
SMARTSHADER currently has 10 effects with plans to add more. The fragment
shaders used for the Classic, Sketch, and ASCII effects are described in the
book "ShaderX2 - Shader Tips & Tricks".
Maurice Ribble
(L) [2003/10/18] [Stefano] [steflanz@tin.it]
Typhoon is a 3d engine designed for the realtime visualization of landscapes, by Stefano Lanza. It is written in C++ , uses the DirectX API and runs on the Windows platform. The latest version of the engine utilizes vertex & pixel shaders 2.0 for the rendering of landscapes. Here are the features of the engine:
Terrain technology:
- a.. LOD algorithm for geometry reduction: Typhoon supports huge and highly detailed terrains. It uses a LOD algorithm based on blocks of terrain to reduce geometry in realtime. While older versions of Typhoon performed an additional refinement of terrain blocks, the new version is more hardware friendly and renders the blocks with brute force.
b.. Highly detailed, unique texturing: The terrain is textured blending a set of four base textures according to the slope of the terrain. This job is done by pixel shaders. Also, a multipass technique ensures both a smooth transition between far and near chunks of terrain, and a highly detailed texturing pass of near terrain. This technique allows highly texturing quality from any distance. Traditional techniques are supported: the engine can create unique terrain textures software-blending a set of base textures according to the slope and altitude of each point of the terrain. Traditional detailmapping is avaiaible.
c.. Dynamic lighting with shadows: Terrain lighting is based on horizons. The horizon, or skyline, of all sample points of the terrain is precalculated and then used to calculate the contribution of sun to the lighting of each pixel of terrain. This technique allows mountains to dynamically cast soft shadows on the surrounding land. The sky adds an ambient light to the scene.
d.. Atmospheric light scattering: Typhoon supports atmospheric scattering of light. The Rayleigh and Mie contributions to scattering change the colors and distinctness of distant mountains and affect the perception of their depth. This effect greatly enanches the realism of the scene. The calculations are done in a vertex shader.
Water technology:
- a.. FFT based animation: The water is animated using a statistics based surface wave model. Fast Fourier Transformation (FFT) is the mean to quickly evaluate the model.
b.. LOD algorithm for geometry reduction: Typhoon can render huge water areas. A LOD scheme is employed to simplify the geometry of distant water. A second technique is used to assign normalmaps to patches of water. Pixel shaders use the normalmap to calculate the specular highlights of sun onto water, and to perturbate the reflected and refracted scene.
c.. Reflections & refractions: Both reflections and refractions are simulated. Two additional passes render the reflected and the refracted environment to two target textures, with water being threated as a planar surface. The textures are then mapped onto the water surface through projective texturing. The real non-planar nature of water introduces an amount of perturbation when fetching the textures. The two textures are finally blended according to the Fresnel term computed per pixel.
d.. Underwater scattering and caustics: Light is scattered and absorbed as it travels inside water. Thus the underwater environment appears darker the deeper it is. Also, refractions of light by the water surface create those light patterns called caustics. The engine uses a set of pre-built animated caustics and blend them on the underwater environment.
Dynamic sky colouring: The sky is dynamically coloured according to the position of sun. Sun and moon are rendered.
Milkshape3d models support: Rocks and other natural objects are placed on the terrain, lit and bumpmapped. Skeletal animation is supported.
LUA script system: The engine is initialized through a script system written in LUA.
FMOD sound system: The demo is enanched by a relaxing music player utilizing the FMOD sound system
Demos, additional information are on Typhoon homepage at [LINK http://www.gameprog.it/typhoon www.gameprog.it/typhoon]
For further information please contact the author at [LINK mailto:steflanz@tin.it steflanz@tin.it]
(L) [2003/10/19] [JosephWhite] [joseph@lexaloffle.com]
The first screenshot is a picture of a modeller that I started writing about
2 years ago, and occasionally add to. It's called 'poido', which is short
for 'pointy dough'. It's written in C and uses DirectX 3 but all of the
rendering is done in software.
Apart from polygonal modelling functionality, it also features a built in
ray tracer which can use octree or uniform space subdivision, a keyframable
skeletal animation system, subdivision surfaces, pixel pushing tools, a uv
mapper, and a sound editor. One file can contain many different models,
bitmaps etc, so that it is easy to quickly navigate and edit the resources
for a game. It has a very minimal visual interface. Most operations are
performed with weird keyboard combinations and by typing in strings of text,
so it feels a bit like EMACS.
I wrote poido as a general game development tool, but so far I've mostly
just used it to push pixels. The second screenshot is a game made using
poido, which is called 'Zen Puzzle Garden'. It's a shareware puzzle game,
where the player controls a monk who has to rake Japanese rock gardens. You
can get the demo from my website: [LINK http://www.lexaloffle.com]. It features
simulated ribbon effects (using a simplified 1D spring mass system), Wolf3D
style wall rendering (on a very small scale), and ..er.. lots of sand.. and
rocks.
-J
(L) [2003/10/20] [TuomoHirvonen] [tuohirv@sunpoint.net]
This is one image from my current volumetric raycaster test. My main idea was to create some printable "art" which i could print, and use to replace my current "britney spears"-kind-of wall posters. The program has perlin-kind of noisecloud algorithm and it send rays through it. Each "voxel" is then lit by checking the intensity of material between it and the light source (lights distance matters also of course). The noise algorithm is never sampled. i mean each item is calculted rendertime directly from the algorithm. There is no floats in this software.. everything is done with fixedpoints. (22/10 bits).
The iteration accuracy is VERY high. Original image's size was 7000x7000 pixels. And it took over 8 hours to render with my celeron 400mhz.
The test program itself has been written with c++ and it uses only win32
(no mfc, directx or anything fancy) and it has some trivial things included ... for eg. own xml-parser for world data, and some nice ui things for controlling them.
I rendered a few clouds with this, and now i'm planning to extend some other algorithms as well. Maybe even something sampled, for eg. data from visible human project. Also, i thought adding some coloring data also, 3d textures (algorithms or sampled).
Tuomo Hirvonen
[LINK http://www.sunpoint.net/~tuohirv www.sunpoint.net/~tuohirv]
(L) [2003/10/21] [JoeBob] [tenkingdomsproject@hotmail.com]
These are some shots of a game project Ive been working on for about 6 months
in the bit of spare time Ive had. The top left image is a shot of the built in
animation tool that I designed for the game, a functional tool for doing
animations using the built in skeletal animation system. The skeletal system is
a straightforward 24 joint quaternion based system. The animation tool allows
for output straight to a game readable format to make adding animation quick and
easy.
The top right image is of the inventory and stats system in-game. The game is a
level based RPG combined with a combat system similar to Jedi Knight 2. Levels
and experience will determine stats and stats have an effect on the combat,
however actual combat is played as a 3rd person shooter. The combat action that
a character is doing is based on the direction that the character is moving,
thus a different motion for moving right as opposed to moving forward. The
actions are settable in game by the player by pressing a direction of movement
and the insert key the player is brought to a screen that allows you to set up a
custom movement for that combat action based on a bunch of pre-built actions
that can be strung together in anyway you like. This is possible due to a
morpher built into the skeletal system.
The bottom right image is a shot of the demo map looking from one of the high
points. The terrain engine is LOD optimized using what I refer to as 4
teselation levels. Basically the terrain is generated in strips at different
levels of detail being 1, 1/4, 1/8, and 1/16, these strips are rendered based on
the position of the main character. The current demo map is a distance of
30,0000 but Ive tested the terrain engine for distances of as much as 500,000
without a problem.
The bottom left image is a shot in a forest just to show the current tree
engine, all trees are procedurally generated form a set of parameters and the
tree engine will billboard anything outside of a settable range for
optimization.
Other things of interest, the combat system has 24 hit zones, and the armor
system has 7 possible pieces that can be worn, each of which will protect
respective zones and can only be broken through by a character of sufficient
strength. Id like to think of myself as a better programmer than an artist so
naturally the artwork isnt so good. The full demo is available at
[LINK http://www.cse.buffalo.edu/~jrm29/TenKingdoms/TenKingdoms.htm] , any feedback you
have would be appreciated, please mail me at [LINK mailto:TenKingdomsProject@hotmail.com TenKingdomsProject@hotmail.com] .
~Jim
(L) [2003/10/23] [StephanSchaem] [sschaem@seriousmagic.com]
This IOTD show a ChromaKeyer function handling transparency extraction and color correction.
A ChromaKeyer purpose is to generate an alpha channel based on a colored backing to be used for compositing.
Common backing color are Blue and Green, green being usually preferred for video.
The "Original image" show one frame from an NTSC DV clip.
(DV compression is DCT/Huffman based at a fixed 6:1 ratio)
The "Final Composite" show the source image color corrected and overlaid using the generated
alpha channel over a background image, in this case purple curtains.
On the right, the close-up of a region of interest detail how transparency is extracted even
in a somewhat noisy situation.
In Figure A we see that if we only created transparency information we would endup with a
green colored object. This need to be addressed by a process of color restoration.
Figure B show how the result is color corrected, yet still leave other details like
the orange/pink highlight/reflection in the bottom right of the bowl.
Because their isn't one solution to the problem (and a problem to solve on a per pixel basis),
this process require some level of user interaction by giving some ranges to formula parameters.
In practice, the cleanest the source the less user interaction is required.
Here is a link to watch a promo video that show how a ChromaKeyer can be used in video production:
[LINK http://www.seriousmagic.com/video%20samples/UK-Demo3-750k.wmv]
Any inquiry and comments welcome,
Stephan Schaem
[LINK http://www.seriousmagic.com www.seriousmagic.com]
(L) [2003/10/24] [MaciejMatyka] [maq@panoramix.ift.uni.wroc.pl]
Picture which I send today contains a shots of my "Dream Equation" demo which I made for Floppy demo group. We made it for demoscene Abstract party held in Gliwice (Poland). It took 1st place and shows several physics simulations with music and some scene like graphics.
Physics simulations which I included into that demo:
- Complexive Newton engine (2d and 3d)
Wave Equation solution for two dimensional case (3d visualization)
Two dimensional Navier-Stokes equation solution
Collision Handling and Response for cloth with rigid 3d ball
Shroedinger equation realtime solution and visualization
You can download demo from my home page [LINK http://www.simulation.prv.pl/],
Best Regards,
Maciej Matyka
[LINK http://www.simulation.prv.pl/]
(L) [2003/10/28] [George"Symphonic"Filiotis] [g.filiotis@spforge.com]
These are shots from a very simple heightmap renderer written in C++ using
OpenGL for graphics output.
The terrains are generated using the Diamond-Square fractal algorithm, and
smoothed using Gaussian Blurring.
This is a single texture mapped over colored vertices, the lightmap is
static (and includes shadows).
The upper image shows a small vehicle which behaves like a helicopter (flown
with mouse/keyboard).
Get the program at: [LINK http://www.spforge.com/files/hmap.zip]
Created by George "Symphonic" Filiotis
(L) [2003/10/31] [JariKomppa] [jari@fathammer.com]
It's been a while since I posted an IOTD, so I figured I'd show you some
things we've been doing at work.
[LINK http://www.tapwave.com Tapwave] is soon shipping their first
device, the Zodiac, and we made couple of games for it. Bundled with every
device is Stuntcar Extreme (the pictures on the left), and one of the launch
titles is Spyhunter (pictures on the right).
Stuntcar Extreme is a racing game with fun physics factor and interesting
race tracks, and features a championship mode where you race against
different opponents to unlock cars and tracks.
Spyhunter is not a port from any other platform, but built from scratch to
take advantage of the mobile platform. It features an arcade mode which is
closer to the original Spyhunter games (while still being full 3d), and a
story mode which is closer to the PS2 titles.
Both games also support two-player wireless realtime head-to-head gaming
modes using Bluetooth.
The games are built with [LINK http://www.fathammer.com X-Forge], the
mobile 3d game engine we're making. A "lite" version of X-Forge is also
included in the Tapwave Zodiac SDK, which is available for free from
Tapwave.
X-Forge enables developers to do majority of their development with normal
desktop PC tools, which greatly shortens development cycles. While mobile
device emulators are nice to have, they're still a pain to debug with
(especially if the problem is something application-specific that has pretty
much nothing to do with the underlaying OS).
This also helped our artists and scripters, as they could simply plug their
changes into the desktop versions to see how things look, without having to
upload everything to the actual devices all the time.
The Zodiac itself is a great device, and it has so high-resolution screen
that I actually had to scale the above screenshots down due to Flipcode IOTD
image size limitations =). It also features analog joystick, touchscreen,
greatly expanded version of palm OS, rumbler, dual mmc/sd slots, and more.
(L) [2003/11/08] [ArasPranckevicius] [nearaz@centras.lt]
Screenshots from demo "Shaderey" - a winner of ATi/Beyond3D [LINK http://www.beyond3d.com/articles/shadercomp/results/ DX9 shader
competition].
The demo displays outdoors scene in a non-photorealistic rendering (NPR)
style, plays camera animation, allows manual camera control and has a
fast-forward benchmarking mode. Requires DX9 class hardware to run
(afterall, it's a DX9 shader competition).
Some tech details:
- Image space: edge detection from normal/depth differences (similar ATi's
at SigGraph2002), plus sort of "hatching" in dark areas.
Color quantization and distortion for "painterly" look. This is done on
downsampled image: convert into HSV colorspace, do some funky operations on
it and convert back into RGB. All in single pass with Pixel Shader 2.0.
Atmospheric light scattering (Hoffman et al. at SigGraph2003).
Projected shadows on terrain.
Planar reflections w/ EMBM for lakes.
Brute-force terrain rendering. I planned to do simple GeoMipMapping at
first, but the demo isn't vertex limited even in brute force case
Can use Multiple Render Targets to render color and normals/depth in
single pass.
Demo can be downloaded from:
[LINK http://www.gim.ktu.lt/nesnausk/nearaz/projShaderey.html]
Full source code is included (C++, for MSVC6 with DX9 SDK and Boost 1.30.0).
Aras Pranckevicius aka NeARAZ
[LINK http://www.gim.ktu.lt/nesnausk/nearaz/]
(L) [2003/11/11] [JulienGuertault] [zavie@epita.fr]
Well, as you can see, this is not exactly a demo of some awesome code:
it is not another incredible landscape generator, not even a new 3D
engine, nor a new still-in-development-RPG...
It is just our cat, coding in Java.
In fact we're a group of students organizing a french programming
contest ([LINK http://www.prologin.org Prologin]), and this is our cat and mascot!
You can find this wallpaper in various resolutions at the following
URL:
[LINK http://www.epita.fr/~guerta_j/Prologin]
(L) [2003/11/12] [Jay Ryness ] [n/a]
[LINK mailto:n/a Jay Ryness ]
Yet another terrain-related IOTD. Sorry. However, this isn't a terrain engine. For example, there is no dynamic LOD.
The main feature on display here is deferred shading. In one pass, the scene geometry is rendered into 4 render targets (currently 32 bits each) as normals, diffuse colors, specular colors, emission and gloss values, and depth. D3D9's multiple render targets are used for this. Then, one by one, the lights are rendered to the screen, using these render targets as source textures. The result is per-pixel lighting that doesn't "care" about geometric complexity. Cost is proportional only to the total screen area covered by the lights' spheres of influence.
The terrain itself is a simple implementation of restricted quadtree triangulation (RQT). The neatest thing here is that it generates a single (very long) triangle strip. Starting in one corner, the triangle stripper steps from triangle to adjacent triangle and visits each only once, finally ending right next to where it started. It's quite amazing to watch.
The heightfield and textures are derived from a picture of my kids, which is somewhat discernable in the bottom-right corner image (although please note that in real life their eyes and teeth don't glow in the dark).
Thanks for looking.
Jay Ryness
(L) [2003/11/14] [MaciejMatyka] [maq@panoramix.ift.uni.wroc.pl]
Picture which I send today is taken from the second part of my demoscene "Dream Equation" series. I used some novel techniques for Soft Bodies there and included some of my recent simulation work and the most important are:
- Inverse Constraints on Cloth Dynamics with MidPoint 2nd order scheme
Soft Body - Soft Body multiple collision detection & response
Perlin Noise Corona (bases on Perlin Noise paper & resources)
Demo took 1st place on a "Sympohony'03" party in Poznan/Poland. You can download it from my home page:
[LINK http://panoramix.ift.uni.wroc.pl/~maq]
I am going to continue Dream Equation demo series, but now I am working on a new techniques - an idea is to not repeat effects in new productions. Complete credits for the demo are: code - maq (me), gfx - fame & dzordan, design - fame, dzordan, azzaro, def, maq and lamia, music - revisq. Demo has been made under label of my demoscene group - Floppy.
(L) [2003/11/18] [Dave Baumann] [http]
[LINK mailto:http://www.beyond3d.com Dave Baumann]
Following on from Aras Pranckevicius'
[LINK http://www.flipcode.com/cgi-bin/msg.cgi?showThread=11-08-2003&forum=iotd&id=-1 IOTD submission]
from his Beyond3D Shader competition winning entry, here are images
from a few more notable entries to the competition. From left to right, top
to bottom we have:
- Translucency (Daniel Vollmer)
Frost (Lukasz Wiklendt)
HDR Lighting (Marko Dolenc)
Rollercoaster (Emil Persson)
Retro (Eyal Teler)
2D Scaling (Ryan Nunn)
All demo's utilise PS2.0 Shaders in some form. And, yes, that really is
Frogger generated in shaders!
Descriptions, executables and source are all available at the Beyond3D
Shader competition [LINK http://www.beyond3d.com/articles/shadercomp/results/ results page].
Cheers,
Dave Baumann
Editor-In-Chief
[LINK http://www.beyond3d.com]
(L) [2003/11/19] [Curt J Sovak] [n/a]
[LINK mailto:n/a Curt J Sovak]
This is a collection of images taken over the span of a month of a
project I'm currently working on during my free time from University
entitled "Conquest of the Middle Ages". Actually, these are just
captures from my map editor. This editor was designed from the ground up
to be a WYSIWYG editor, and it actually shares a lot of code with the
core game engine, so you can:
- Move freely about the terrain, inspecting it from any angle and
height
Deform the terrain (raise, lower, or smooth) using various
effect areas (brush sizes)
Add brushes (static entities), dynamic entities, or triggers
(control points), move/rotate them, and edit their parameters
Paint the terrain using any combination of base and detail
textures, using different brush sizes
Calculate lightmaps based on a modifiable sun position
Load/save game maps, and import height maps
Regarding the terrain, its size can be any multiple of 32, but I find it
easiest to restrict it to be 64, 128, 256, 384, 512, or 1024. Terrain
resolution is modifiable when a height map is imported or a new terrain
is created. Y scale is also freely changeable when importing a height
map. Each patch is 32x32 (33x33 vertices), and contains its own light
map. The light map resolution varies with object density if the user so
chooses, so a higher fidelity light map is possible as the object
density increases. Each patch also contains one alpha map (fixed at
64x64) per painted texture. This is how I presently allow a possible
infinite number of textures to be painted onto the terrain. This also
requires one additional pass per patch for each painted texture that
exists in that patch. I am looking into the possibility of combining all
of those paint textures and the alpha maps into one RGBA texture for
actual game maps. If a patch does not contain any painting with a
certain paint texture, or the patch cannot be seen, then that pass/patch
is not rendered. Water has not yet been split up per patch, and is
currently the entire terrain size at a height of -1.0.
Onto the picture: The top image is a cap of the map editor environment.
The toolbar on the right consists of: select object, rotate object, view
wire frame, deform terrain area upwards, deform downwards, smooth area,
change terrain area effect size, add brush, add entity, add trigger,
select brush/entity/trigger list, brush/entity/trigger parameters (w/
apply button!), paint terrain, erase paint, change paint brush size,
paints list, add paint type, remove paint type, and a small status area.
The middle left is an old image of the first light mapping I did with
the terrain. It's polygon intersection based rather than volume, so it
can at least look reasonable realistic.
The middle right is another old image of light mapping in water, with
the darkness of the light map depending on depth of the water.
And the bottom two images are just the latest money shots.
All this work has taken since July (I'm a slow programmer), and the
final result (the game) may not even be realized as I don't have any
modelers in my outfit. But, as it stands, it is to be a 3D RTS set in
medieval times, based off a game I made many years back in high school
comp sci in qbasic. It's not a huge project, even though it is my first
big legitimate stab at a large project. However, as I see that I've gone
this far with good results, I am hopeful for the future if I can secure
non-programming content.
Thanks for your time,
Curtis Sovak
(L) [2003/11/21] [PatrikSvensson] [patrik.svensson@cadcraft.se]
This is from a basic Whitted recursive raytracer I'm writing.
The picture shows six spheres and an infinite plane with different material
properties and two point lights.
The recursive depth is 8 and 8-16 rays per pixel (adaptive rejection
sampling and a box-filter).
The program is written in C++ with Borland Builder 6.
Features so far
- Strauss BRDF shader for the materials
Basic geometry (planes and spheres)
Basic texture mapping
Reflection and refraction
Planned features
- More shaders and more geometry
Improved texture mapping
Distributed shadow rays
Bump mapping
Improved refraction handling
Optimizations
Scene definition scripting
And the main goal of this project is Photon mapping.
Comments are appreciated
Cheers,
Patrik
(L) [2003/11/30] [VorsinS.V.] [regmail@hotbox.ru]
Digital Nature graphic engine by Vorsin S.V., Sikorsky-16 project (Flight Simulator). d-Strict group.
The given engine works under Direct3D. (written in VC++)
Digital Nature graphic engine was developed (and still developing, of course) for the S-16 project of d-Strict group. Digital Nature is only the graphics engine. It works with large terrains and high load environments (with lakes, seas, grass, forest, atmosphere effects etc).
The presented images were rendered with speed at about 7-10 ms on GeForce4-Ti4200, CPU - AMD Athlon XP+1700, 256 Mb RAM.
=== Here is a brief description:
- Terrain render uses PS and VS. Unlimited count of trees and reasonable framerates (about 100 fps without water (Forest square is about 10*10 Kilometers)). Rendered with shadow maps. The size of result file does not depend upon quantity of trees. The engine uses 3 types of render techniques, which depend on optimization factor:
1st - detail trees render (sphere trees technique or tree models), distance 500m
2nd - imposter trees via VertexShader (integrated into VertexShader)+Bump map, distance 2Km
3rd - planar tree maps+Bump map, distance - unlimited
Dynamical sky lighting (24 hours), background cubemap support also.
Clouds. Use billboards.
Lakes. Uses offset bump mapping for fast computation. Dynamical reflection, transparency, specular highlights, fresnel effect as well.
Grass, unlimited squares of grass fields, render speed depends on density of grass.
Any comments refer to [LINK mailto:regmail@hotbox.ru regmail@hotbox.ru],
Also a web page of d-Strict is [LINK http://www.d-strict.com www.d-strict.com],
you can see other screenshots of the engine, and further info on S-16 project (it has been just uploaded).
(L) [2003/12/05] [MiguelA.Osorio] [mao@somniumstudio.com]
My name is Miguel A. Osorio and I'm a member of SomniumStudio, a brazillian game studio. These are some screenshots taken from our techdemo, where we're displaying some of our engine's capabilities. Here are some of it's features:
- Proprietary engine fully developed in-house.
SDL + OpenGL.
Hierarchical collision detection using OBB n-ary trees.
Shaders (currently implemented using only standard OpenGL pipeline, no vertex/fragment programs).
Multiple rendering passes for effects like gloss mapping and emissive texturing.
Advanced and highly flexible particle system.
Multiplatform (developed on a Linux environment).
The rendering subsystem is the only one currently implemented, but there will be support for sound, rigid-body dynamics, networking, GUI, AI, scripting, etc.
The engine has been in development for one year and a half (though I've only worked on my spare time), while the techdemo was assembled in about two months (also on our spare time). We are currently working on a space combat simulator using this technology.
To learn more about our game and about us, check out our site at [LINK http://www.somniumstudio.com]. There are more screenshots available there, plus a movie showing the techdemo in action.
Thanks for the opportunity,
Miguel A. Osorio.
(L) [2003/12/08] [MichaelZeile] [mzeile@primusnetz.de]
on these three screenshots you can see our latest project written in c++ / opengl. The
game is based on the original Thrust game of the year 1986! The game idea was so
great - it must have been rewritten with better graphics and physics
It's fully functional ( Practice, Single Player, Replay etc.. ) and was designed and
written in about 2 months. The objective in single player is to fly through the
tunnels, fetch up a bomb and 'rescue' it by flying above the planet surface.
So feel free to download the game for our homepage ( [LINK http://thrust.primusnetz.de] )
If you have some questions, found some bugs or want further technical information
simply send us an email ( link is on our homepage ). If we get enough positive
feedback we'll think about implementing an multiplayer option
bye bye
michael / martin
(L) [2003/12/10] [Pet] [petru_soroaga@whiteblobs.com]
This is a screenshot of our demo related to snow generation and
rendering.
We worked last days in implementing some fast snow generation in
WhiteEngine.
The process take place in two steps: First snow is generated on objects
based on density and where the snow falls from.
Seccond, particle system are used for animation. We didn't optimize the
system, as each particle is a single snow particle. For faster graphics
and thicker snow, more snow can be represented with one particle.
For the first step of snow generation on objects we are studding now new
ways on doing this.
It runs in DX 8.1 at least.
The demo can be downloaded from:
[LINK http://www.whiteblobs.com/tech.htm]
(L) [2003/12/12] [OliverDoyle] [oliver@gamejig.com]
Below are two images of our recently released game Neomaze.It's a Pacman clone
by design but uses a 3D perspective and psychadelic graphics. It also has a
more traditional 2D overhead view for maze game purists. You can check out more
screenshots and a free 10 level demo at [LINK http://www.gamejig.com www.gamejig.com].
As you can see from the screenshots it doesn't try to re-invent the maze game
genre but is a nice take on it nonetheless.It has ghosts that chase you and a
new enemy, called a blocker, that tries to impede your progress.
The game runs on most versions of Windows. It was written with MS Visual C++
v6.0, the openAL sound library and the
excellent(free) OpenGL application framework GLFW v2.4 ( check it out at
[LINK http://hem.passagen.se/opengl/glfw/] ).
Take it handy,
Oliver.
(L) [2004/01/12] [JoakimWennergren] [joke_dst@yahoo.com]
These are a few images rendered with our program called
"tcp renderer". It was written for fun, but we used it
as basis for a scientific paper we had to write in
school.. Anyway, it renders julia and mandelbrot sets
in quaternion space, using a 4D camera that can be
placed and rotated freely in four (room) dimensions.
It is also capable of rendering 2D subsets, as shown
by the 2D Julia image to the right.
There's a simple homepage you can download the prog
from at [LINK http://www.geocities.com/joke_dst/tcprenderer]
Joakim Wennergren
(L) [2004/01/14] [BrunoCesteiro] [brunomtc@hotmail.com]
Here are two shots of a game we have currently in the works, they both were taken seconds after the mission starts.
The first shot shows the dropship fading away in the horizont after droping us of, while the
second shows a view into the island interior.
We have a demo test available for download, and we would appreciate feedback from the people that test it, on the gameplay.., is it too easy ? to hard ? the level ends to fast ? Doesn´t end to fast., etc.
The demo can be downloaded from here :
[LINK http://www.fysoftware.com www.fysoftware.com]
feedback is welcome at feedback at [LINK http://www.fysoftware.com fysoftware.com] or in our forums..
thanks,
Bruno
(L) [2004/01/16] [Scali] [scali@scali.eu.org]
What you see here is the rather well-known car mesh, using the rather well-known
Blinn-Phong lighting equation. The mesh is low-poly, and a normalmap provides
detailed info for per-pixel lighting.
So far nothing special.
But it is rendered on my trusty GeForce2, not on a modern 3d card (if anyone
wants to donate such a card, feel free though).
And that's the thing I would like to talk about. When I wanted to implement the
pow() for the specular light, I ran into the problem that the alphablend ops are
rather limited, so a conventional multipass technique would not work well.
It would be much better if you could just read back the framebuffer as a
texture, and pass it through the entire shading pipeline again. So this is what
I did. And since I don't think this alternative method of multipass rendering is
very common, I thought I'd write something on it. I think it can be very useful
in general, not just for old hardware like my GeForce2, but perhaps also for
more modern hardware, when you run into the instruction limit for pixelshaders,
for example.
Rendering the screen to a texture is easy, I suppose. The tricky part is getting
the right texture coordinates at each pixel, so you can sample the previous pass
1:1.
I did this by having the card generate texture coordinates from the cameraspace
position automatically, and then using a texturematrix (basically a projection
matrix), and finally projecting the homogenous coordinates to 2d screen
coordinates (in 0..1 range).
You should be careful here, and make sure that you align pixel and texel centers
properly... You should know that both pixels and texels get sampled at their
center... but while the top-left corner of a texture is (0,0), the top-left
corner of the screen is actually (-0.5,-0.5).
In our case we have normalized coordinates, so instead of the screen going from
(0,0) to (width,height), we go from (0,0) to (1,1).
So effectively this means we don't need to map (-0.5,-0.5) to (0,0), but
actually (-0.5/width,-0.5/height).
Another thing is that usually the y axis points up in camera space, while you
want it pointing down in screen/texturespace, so you need to flip that too, when
mapping y to v.
To perform all this, I take my projection matrix, and multiply it by the
following matrix:
| 0.5 0 0 0 |
| 0 -0.5 0 0 |
| 0 0 0 1 |
| 0.5+(0.5/width) 0.5+(0.5/height) 1 0 |
As you see, it scales and translates x and y from the (-1,1) range to the (0,1)
range required for the texture, and it does the translation to align the texel
and pixel centers (note that width and height are the dimensions of the current
rendertarget, not the texture itself!).
I also swap z and w around, because I don't need z, and this way I can pass 3d
homogenous coordinates that get projected to 2d.
So, I then set this matrix, set the states to inform the rasterizer to expect 3d
coordinates, which it should project to 2d, and we're all set. If I now render
my geometry again, I can sample pixels from the previous pass directly from a
texture, and pass them through the entire pipeline... In my case this meant that
I could use 2 modulation operations, which can give me specular4 in one pass.
With 2 passes I get the specular16 that I want.
You can also use smaller rendertargets to speed the operations up, at the cost
of some accuracy, ofcourse... In the case of the specular highlight it actually
works out nicely, because the upsampling eliminates some of the aliasing that
you get from the low precision of 8 bit processing, and it's cheaper than
applying an actual blur-filter ofcourse.
(Note by the way that the mapping is not 100% exact... I tried rendering an
image and subtracting it from itself, and here and there some pixels were not
entirely black, but I'm not sure if that is due to inaccuracy in the hardware,
or if the matrix itself is not accurate enough. However, it was good enough for
my needs, and I think it should work out fine in most cases. Perhaps it can be
completely eliminated if the bilinear filter is disabled (using textures of the
same size as the backbuffer ofcourse), but I forgot to test it at the time).
Anyway, I found this method interesting and useful, I hope that some of you do
aswell.
If you have a PC with Windows and DirectX 9.0b installed, you can see it live here:
[LINK http://scali.eu.org/~bohemiq/PhongCar.zip]
[LINK http://scali.eu.org/~bohemiq/PhongCar2.zip]
You will need a card with dot3 support, 2 textures per pass and cubemap support. Original GeForce/Radeon or higher should work, in general.
Scali
(L) [2004/01/20] [DavidRosen] [david@wolfire.com]
These are screenshots of one of my projects called Soul of Steel, a robot
first-person-shooter. Recently I was bored and decided to add
glass-shattering effects ala Red Faction and the Matrix (helicopter scene)
and found that it was surprisingly easy, and took about a day. All it does
is take a glass model and subdivide it more or less randomly, and then apply
various effects to each shard based on its distance from the impact
point(s). Support for multiple impact points allows the player to interact
with glass shards even after they are falling or lying on the ground. Maybe
this is pointless, but I thought it was interesting :)
(L) [2004/01/21] [lvermeulen] [lvermeulen@shaw.ca]
Here is another shot of nexuiz in action. I sent a iotd to flipcode about 3 months ago,
and got great responses, so I thought I'd send another one.
Nexuiz is a 3d deathmatch game being developed over the net, using highly modified
quake1 technology. It uses Quake3BSP, bumpmapping, realtime shadows (but due
to problems might not make it into the final product).
It is currently in the beta stage, as most of the levels and characters are complete but
they require tweaking.
Nexuiz also runs on Linux, and is completely open source.
The site for nexuiz is here: [LINK http://www.alientrap.com/games/nexuiz]
You can always post on the forums for nexuiz here: [LINK http://www.alientrap.com/board/]
(L) [2004/02/17] [PaulKahler] [phkahler@wowway.com]
This is the first image correctly generated using my photon mapping software.
Long time readers may remember rtChess (google it if you don't) which used my
speedy ray tracer. Well I ripped the RT code out and made a library of it and
sqeezed another 40% performance over the version in rtChess. Over the last year
of my limited spare time, I implemented photon mapping on top of this fantastic
ray tracing code. I am disappointed with the speed of the photon mapped
rendering, and will be working on that soon. I suspect a hidden bug, as the O(n)
doesn't seem to scale properly.
In this image, eye rays are cast into the scene and secondary rays are used for
the reflections. All diffuse illumination is taken from the photon map. There
are about 10000 direct illumination photons plus the indirect ones (don't have a
count) with 511 being used in the radiance estimate. The photon map takes
seconds to build, but the rendering takes 6 minutes or so (this is more than the
10 seconds I'll be shooting for) on my Athlon 700 with no interpolation.
About the library:
Primitives are implemented as subclasses of rtPrimitive and include:
- Triangle
Quad
Quadric - completely general
Sphere (derived from Quadric - hides the complexity)
Torus (with 4 parameters - major & minor radius, and the 2 radii of the cross
section)
CSG (Quadrics only, but more are planned - just need to fill in some functions)
Quadratic Lathe - this was used to easily create most of the rtChess pieces
from sketches.
Textures are procedural - this subsystem is due for an update though.
Very efficient spatial index designed for animated scenes - updates are fast.
Render to memory.
Adaptive interpolation to speed RT
RT can render several million primitives at interactive rates.
Multi-thread ready - we tested it at one time with impressive results, but took
it out.
*NEW* photon mapping to provide global illumination (this is thread safe too).
All library code 100% written from scratch over the last 10 years.
I have always thought the end-game in graphics would be RT, but there was no
good way to do global illumination. I thought RT might form a basis for global
illumination, and that has turned out to be true. I have progressively less time
to work on this project, so it is for sale to the right buyer. Barring that, you
might find it under the GPL some day.
Thanks,
Paul
(L) [2004/02/23] [DavidOlsson] [md9zelc@mdstud.chalmers.se]
These are screenshots of my examination project I'm working on to get my degree in Computer Science at the University of Gothenburg, Sweden.
What you see is basicly an infinitly large implicit surfaces with associated textures. No bumpmap or similar is used. In fact, I
only use gouraud shaded triangles.
The program I wrote will show a very lowres and blurry version when the user move and will start to refine it when the user
stand still and doesn't change any settings. So once you stand still you will get more and more detail but as soon as the
user moves the lowres version kicks in.
Each of these screens (the orginals were in 1024x768 resolution) took between 10 and 25 seconds to generate on my athlon
700, but even after a second or two you get a reasonable good quality.
/David Olsson aka Zelcious
(L) [2004/02/25] [JosephBertolami] [jbertola@uci.edu]
Project Vision is my latest 3D engine developed over a period of eighteen
months. Comprised of over 70,000 lines of technology, the engine is built
upon a strong foundation of file systems, virtual processors, memory
managers, profilers, a custom hardware abstraction layer, math and physics
libraries, graphics and audio subsystems, input accelerators, network
managers, and much more. Unlike my previous two engines, Vision was designed
from the beginning to be a portable 3D game engine, rather than simply a 3D
graphics engine. The design of Vision was carefully created to produce a
powerful game hierarchy in addition to handling graphics, audio, network,
input, and platform abstraction. It also features a powerful resource
manager, a scripting engine, a Cg precompiler, gui and console subsystems,
an integrated scenegraph, a game system, bump mapping, depth shadows,
specular mapping, static shadowmapping, environment mapping, a complex
particle system, and a terrain engine.
The image is a collection of screenshots taken from Vision. The upper left
image shows a large model (~40k polys) loaded and rendered with bump mapping
and specular highlights using Cg. The upper right image shows the particle
system with visible scene hierarchy boundaries that dynamically compensate
for particle motion. The bottom left is simply a surface shot taken after
firing a couple rockets into the horizon. The bottom right image is another
shot of the terrain which uses up to eight texture layers blended in a Cg
shader.
Screenshots, documentation, and binaries can be obtained from
my website at [LINK http://www.bertolami.com]
Thanks for the support!
Sincerely,
Joseph Bertolami
(L) [2004/02/27] [JosephBertolami] [jbertola@uci.edu]
This is a small ray tracer application written for one of my project courses
at my university. It was designed and implemented over a period of eight
weeks by myself and 1 other programmer. It is fully portable, written with
OpenGL and GLUT and contains the following features:
- Diffuse/Ambient/Specular Lighting
Direct Illumination Shadows
Texture Mapping
Octtree Scene and ModelGraph
Photon Mapping
Reflective and Refractive Surfaces
Bump Mapping
Progressive Tracing
Depth Buffer
More information and downloads are available at [LINK Http://www.bertolami.com www.bertolami.com]
Thanks for the support!
-Joseph Bertolami
(L) [2004/03/01] [VictorWidell] [victor_widell@hotmail.com]
I did some experimentation with Fur Shading. Nothing advanced, not even a pixel shader involved.
It is basically just a texture with a noisy alpha channel drawn in sereval layers with diffrent alpha-testing for each layer. To simulate self-shadowing I fade the deeper layers to black.
Also, the lighting needs to use the normal of the induvidual _hairs_, wich is (more or less) perpendicular to the surface normal.
-Victor
(L) [2004/03/02] [JoostvanDongen] [tsgoo@hotmail.com]
This is a render from the raytracer that I am working on, written in C++. It shows some of the features I have implemented so far: triangle-rendering, a skylight, a triangle-light, smooth shading, adaptive anti-aliasing and shadows. Lots of other features have been implemented as well.
My renderer is a monte-carlo renderer: skylights, secondary illumination (though not turned on in this pic), glossy reflections and triangle lights are traced backwards into the scene. It does all sorts of texturing as well, all map-controlled.
One thing I have not yet worked on is real optimalizations. I am doing bounding objects now, but I want to make that better with a hierachy of axis aligned bounding boxes. After that the great thing to do would be adaptive undersampling in object space, but that is still far off.
As some exporter for some modeller has not yet been written, all the renders are kinda boring. I am planning on building an exporter for Blender, when the time comes.
The history, all the features, a to-do-list and lots of other renders can be found here:
[LINK http://home.hccnet.nl/w.vdongen/Raytracer/History.html]
Greetings,
Joost "Oogst" van Dongen
(L) [2004/03/08] [GregSnook] [snookg@msn.com]
Here's a collage of shots from the latest Gaia Engine (version 1.3). The original Gaia engine was included with the book "Real-Time 3D Terrain Engines using C++ and DirectX 9" last year, but it's been receiving steady
updates since then at [LINK http://www.mightystudios.com www.mightystudios.com]. The engine features DirectX 9,
HLSL shaders, ROAM, Chunked Terrain and Tiled Terrain methods. The latest edition to the site includes a PDF
doc which also helps explain some of the memory management and C++ template usage in the engine for new
readers. Feedback is welcome in the forums at [LINK http://www.mightystudios.com www.mightystudios.com] as well.
Thanks!
greg
(L) [2004/03/09] [BrunoLevy] [Bruno.Levy@loria.fr]
The image shows a new Non-Photorealistic Rendering technique, displayed in real-time using the GPU. Strokes are oriented along an estimate of the curvature tensor of the surface. The right half of the image shows tensor line-integral convolution (Hyper LIC) applied to the tensor of curvature. The image is generated in our Open-Source "Graphite" software.
More details are on my web page: [LINK http://www.loria.fr/~levy]
Credits:
- Thanks to Pierre Alliez ([LINK http://www-sop.inria.fr/prisme/personnel/alliez/]) for the Anisotropic Remeshing project.
References:
- Normal Cycle and Restricted Delaunay Triangulations, David Cohen-Steiner and Jean-Marie Morvan, SOCG, 2003
Anisotropic Remeshing, P. Alliez, D. Cohen Steiner, O. Devillers, B. Levy and M. Desbrun, Siggraph 2003
(L) [2004/03/10] [PierreTerdiman] [pierre.terdiman@novodex.com]
We just released our new Physics SDK. You can grab it
there: [LINK http://www.novodex.com/downloads/NovodeX_SDK_Personal_2.02.exe]
The screenshot comes from one of the included demos. This is a stack of... 400 perfectly stable boxes !
We focused on speed for this release, and the results are pretty cool.
The new SDK is a blend of my previous physics engine (if you remember my [LINK http://www.flipcode.com/cgi-bin/msg.cgi?showThread=01-06-2003&forum=iotd&id=-1 last IOTD]), and the Novodex one. We picked up the best parts of both, optimized the hell out of it, and tadaaa! Voila, fastest physics ever! (ok, maybe not, but I love the new solver :)
I invite you to download the personal edition above and check out all those cute demos.
Stay tuned for more demos and more features !
Cheers,
- Pierre
(L) [2004/03/15] [FabianMathews] [supagu@hotmail.com]
This is a racing game I am working on using opengl, SDL and works on linux and windows platforms.
I am fairly happy with my progress, at this stage has taken about 3 weeks, and i have also
developed a 3d max exporter. I have previously used DirectX do create my engines, and decided
to use OGL for this one and it seems much easier/quicker to develop and get decent frame rates.
a demo is also avaialble at my website: [LINK http://www.users.on.net/amathews/siphon/]
also trying to get ODE in but having some issues there, so if your a pro with ODE, gimmie a buz on icq: 70981152,
msn: supagu@hotmail.com
Code by Fabian Mathews [LINK http://www.fabian.2ya.com www.fabian.2ya.com]
Art by Bronson Mathews [LINK http://www.bronson.2ya.com www.bronson.2ya.com]
(L) [2004/03/16] [Ptolemy] [kaysik@iinet.net.au]
This is a 3D action game called knockoff (KO) I've written in C++ using OpenGL. I've been working on it since late June 2003 and its now pretty much complete. I wrote all the code, and did all the art and modeling myself (hence the simple "programmer art" style), but its come together pretty nicely anyway (music was done by a friend of mine). In true cartoon style you have to knock your opponents off the floating platforms any way you can. At the moment its up to 8 players, but only 2 can be human (fitting more than 2 people on a keyboard isn't practical), but I'm working on a networked version so hopefully soon you'll have 8 player deathmatch!
KO runs with over 60fps on my GeForce2 at home and over 200fps on the GeForce4's at my uni. I use no OpenGL extensions (its all done in software), you can turn off almost all features to speed things up, and run it in a mini window if you want so I think it'll run on almost anything with a 3D card (if someone has some old hardware they'd like to test it on I've be interested to see what the minimum specs are).
Current Features include:
- Cell Shading
Stencil Buffer Shadows
FMod game sound including an MP3 player
Demo recording + playback
Screen shots (can be used with demo playback to output at 30fps to make game movies)
AI for up to 8 players
Lens flares (not because they help, just because I was board one night)
full quake style console
6 game types (including Deathmatch, CTF and King of the Hill)
10 maps (some mod specific)
6 characters
5 weapons
4 powerups
KO is open source so for anyone who's interested you can get it from my site [LINK http://www.kaysik.net]. Its cross platform and runs on linux and windows (and theoretically mac, but thats never been tested).
Thanks
Ptolemy
(L) [2004/03/18] [IMAGIRETakashi] [imagire@nifty.com]
This is a screenshot of my real-time global illumination demo written with DirectX 9.0b.A teapot flying in the box is colored by the effect of a color bleeding of the wall which the teapot has in near.
This demo renders a teapot with the following steps:
- The texture on which diffuse radiance transfer was recorded is prepared beforehand(PRT map).
A camera is put on the center of the teapot, and a dual-paraboloid environment map is created.
An environment map is multiplied by SH functions in the local coordinate system of an object.
An environment map is reduced as creating a mip-map, and it derives SH coefficients of the incomming light.
The PRT map is multiplied by SH coefficients calculated from the environment map, and the brightness in each point is derived.
More information and downloads are available at [LINK http://t-pot.com] (Japanese).
(L) [2004/03/22] [WayneMike] [wayne4@blueyonder.co.uk]
I finally got around to updating the water screensaver, the new version can be downloaded from: [LINK http://www.scene.org/file.php?file=%2Fdemos%2Fgroups%2Ffluid%2Ffld_water-gold.zip&fileinfo]
The screensaver features:
- 5 standard backgrounds
An image cycling mode that blends the 5 standard background in and out of each other.
The ability to import custom backgrounds in the form of BMP/DIB files. on the fly anti-aliasing.
a resolution change from the original screensaver that used a mode of 512x384, the new version uses a more friendly mode of 640x480.
Truly random weather states.
About the screen-shot:
the above image of the screenshot shows the screensaver using the image cycling mode. the bottom image of the screenshot shows the screensaver using an imported bitmap. The screensaver also have the ability to scale images up and down on the fly using a simplified version of the bresenham algorithm.
i know some of you are still using the previous version of the screensaver, you will not have to delete it in order to install and run the update, they will happily co-exist with each other.
You can still grab the original version from:
[LINK http://www.scene.org/file.php?file=%2Fdemos%2Fgroups%2Ffluid%2Ffld_water.zip&fileinfo]
i would like to thank everyone from the flipcode community, and the scene community, for sending me ideas regarding the update - thank you.
Wayne "dappa" Mike,
(L) [2004/03/24] [RT] [okmot@shaw.ca]
Behold the screenshots from the addictive little game we've been developing over the past 16 months! Built from scratch using DirectX, the game was inspired by the 2-player mode of lemmings(tm) for the super nintendo. It is a real-time network multiplayer strategy game in which you try to save your own creatures (called 'clones') while trying to stop your opponent from accomplishing the same task by giving actions to your clones such as 'build', 'fly', etc.. It sounds simple, but try playing the 4-player map in which every player is trying to fend off 3 other opponents at once and you'll find out how complex the game can become. We have recently added a singleplayer aspect to the game as well to round it out a bit.
The upper-left pic shows a saved game being played back. We built the gamefrom the ground up with multiplayer in mind, so saving games is as simple assaving the network messages.. very easy, but a nice feature as it allows forpre-recorded solutions to single player levels, and we use save games as the background for the main menu.
The upper-right pic shows a multiplayer match on a level which has anti-gravity traps. Playing this level could possibly break your brain :)In addition to antigrav traps, there are also size traps which double or halve the size of a clone, water traps, electricity traps, slingshot traps,and more.
The big middle pic is of the built-in mapeditor. This was probably the biggest challenge in working on this project. It is a WYSIWYG editor which allows for free scaling, free tinting, free rotation, and alpha blending of the landscape objects. You can see some the levels we've created here ([LINK http://www.tomkorp.com/clones/levels.asp www.tomkorp.com/clones/levels.asp]). The mapeditor still has a ways to go before it will be complete.
The bottom-left pic shows the local-multiplayer mode of the game. The splitscreen was made using DirectX viewports. The grey group is controlled by the mouse, and the green group is controlled with a gamepad. We had planned to support multiple mice, but DirectX doesn't make it easy so we went with the gamepad.
The bottom-right pic shows the new singleplayer interface we've implemented. Originally you would just play the singleplayer levels sequentially from a list.. very boring :) Now there is a 3d model of a brain which you can rotate around to find 'regions', each region is made up of a neuron map like the one shown in the screenshot. Each neuron represents a level, and solving enough levels lets you move on to more brains. All regions on a brain can be played at once, which allows for non-linear play as well as the possibility of 'hidden' regions.
Generating the landscapes built by the mapeditor could involve rotating and scaling several hundred different images, and to be practical, we wanted it to take no more than 4 seconds to load a level. At first we tried using various image manipulation packages (such as imageMagick), but found that none of them offered the speed, robustness, and quality which we desired. So we rolled up our sleeves, boiled some coffee, and coded our own ImageTransformation Engine! Our custom ITE allows for arbitrary scaling, rotation, tinting, and alpha blending while keeping memory overhead to an absolute minimum. We take advantage of dozens of special cases to speedup transformations. It also features an optimal double caching system to eliminate redundant transformations and a custom bilinear filtering routine that renders very smooth, artifact free edges. The final step was to replace a few key functions with inline assembly code which resulted in dramatic speed gains. We also added some specific code to guarantee image transformations will be exactly the same on different processors, so that client and server will always be in sync. Our ITE loads almost any level in under 2 seconds :)
Being a multiplayer game we wanted to make it easy for players to find each other, so we created a world ranking system and an 'ansi c' world server (similar to UT or HL, but on a much smaller scale) which allows players to find active servers from anywhere in the world! The current demo is available from [LINK http://www.tomkorp.com www.tomkorp.com]. We would welcome any feedback you might have!
rt & ttk
(L) [2004/03/30] [NikolayStefanov] [oligopod@yahoo.com]
This is a screenshot of a SH lighting demo I've been
developing on and off for a couple of weeks. At the
moment it supports:
- AABB-accelerated preprocessing of scenes
diffuse shadowed transfer
SH rotation matrices for arbitrary number of bands
HDR probes for ambient lighting
approximation of local lighting
realtime recolouring with an OpenGL vertex shader
(L) [2004/04/01] [FedericoColetto] [ninjacross@yahoo.it]
This is a set of screen shots grabbed from a project I'm working on from the last June.
It's a physics simulation framework that implements a brand new algorithm that i developed to
simulate the motion of highly viscous fluids on various kind of surfaces and that I named "FRF"
(Fluid Redistribution Forecasting).
The FRF algorithm is based on the concept of "hypothetical mass distribution", and makes the
program able to determine the shape and position of a tridimensional fluid mass, calculating the
modification of its original shape (considered in a static condition of forces) in function of the
characteristic of the sliding surface on which it moves.
The algorithm is implemented in C++ in an OOP rendering framework that works using OpenGL to
generate the realtime output.
The theory behind the specific and related concepts is described in a complete PDF tutorial (in
English language) that you can download from my web site.
The tutorial comes with UML documentations of the system architecture, and you also can download
the full C++ source codes that you can compile both with VC++ 6.0 and VC++ on VS.NET.
To download the PDF tutorial and/or the complete C++ sources, you can visit my web site
([LINK http://www.ninjacross.it www.ninjacross.it]) at the following URL:
[LINK http://www.ninjacross.it/pagina75.htm]
For any question or discussion please e-mail to: ninjacross at yahoo.it
(L) [2004/04/05] [ChrisHaarmeijer] [c.haarmeijer@keepitsimple.nl]
The image shows a render of Gray, our programmable Global Illumination
Simulator. This render was made using path-tracing. Gray is currently in a
testing phase. The simulator runs on the GPU if you have PS2.0 and floating
point texture support or on the CPU. You can download the Gray executable
with some test scenes from [LINK http://www.keepitsimple.nl]
Regards,
Chris Haarmeijer
(L) [2004/04/07] [Michael Pote] [michaelpote AT eject.co.za ]
[LINK mailto:michaelpote AT eject.co.za Michael Pote]
Lightmappers seem to be very scarce these days, so I'll push aside the pile of ray tracers and
show you something more primitive :-).
In 2002, after writing my [LINK http://www.gamedev.net/community/contest/4e3/4e3entries.asp Foundry demo] for the gamedev.net contest, I
decided to write a lightmapper of my own since I used the excellent [LINK http://www.fluidstudios.com/fsrad.html FSRad] radiosity lightmapper for the demo.
So after about 6 months of work, this is an alpha version of my lightmapper which integrates all
aspects of the mapping and lighting of any scene.
Features (in chronological order):
- a.. 3DS file loading with intelligent normal generation (Sharp corners stay sharp while
preserving smooth curves)
b.. Planar Mapping
c.. Packing of lightmaps into a large texture using binary space partitioning (From this
[LINK http://www.blackpawn.com/texts/lightmaps/default.html tutorial])
d.. Lambert Shading Model
e.. Shadow Casting with ray-plane intersections.
f.. Lightmap Filtering
g.. Octrees (Used for drawing the scene, and originally helped with shadow casting, but later
was removed)
And there the project stopped for a while. There were still inaccuracies around the edges of
individual lightmaps and the shadow casting routine was very slow, but I was happy enough to play
around with it.
Then when I actually thought about it, I figured that my method of shadow casting needed a
rewrite. It was originally simply iterating through all the triangles in the scene and tested each
one against a ray cast from each light, without any optimisations. So I sat down and sketched out a
design for shadow volumes. I'd never done any sort of research on shadow casting before so it was
my own idea, but quite a simple one.
Instead of testing each triangle, the program precomputes a truncated pyramid for each triangle in
the scene, starting at the triangle and extending out away from the lightsource, then tests if the
point is inside that.
Needless to say, the algorithm was 12 times faster than the original!
The lightmapper still needs some work, especially with smooth objects where seams can be seen, and
I'm also looking for a fast way of computing soft raytraced shadows.
The image shows the main interface for the program along with a few scenes rendered in real time
with lightmaps, and a lightmap which has been packed using the BSP method.
The lightmapper was written completely in Delphi using OpenGL for rendering.
Questions and comments are welcome,
Michael Pote
(L) [2004/04/12] [Francois Beaune] [n/a]
[LINK mailto:n/a Francois Beaune]
A new version of toxic has been released!
The major feature of this release is the new adaptive antialiasing scheme with perception-based
contrast threshold.
Several other improvements have been made since toxic alpha-1: loading of .obj and .ase mesh files
has been greatly improved, a few bugs that were found in alpha-1 have been resolved, and the code
has been cleaned, factorized and optimized.
Post you comments and suggestions or discuss toxic on the new forums ([LINK http://toxicengine.sourceforge.net/forums/index.php]).
toxic is a new open source global illumination renderer aiming to produce photorealistic images
and animations.
toxic's goal is to provide artists with a free and modern rendering tool which is actively
maintained, developed and extended.
This version of toxic is an early alpha version: it still lacks some major features, and it might
contain several bugs. It is released in order to demonstrate toxic's capabilities and to allow
developers to contribute to its development.
For the moment, only a Windows version is available.
[LINK http://toxicengine.sourceforge.net/]
(L) [2004/04/13] [ColinVella] [colinvella@waldonet.net.mt]
This is a screenshot of a game that I am developing together with 3 friends of mine (Keith Bugeja,
Elvio Cauchi and Kevin Debono) in our spare time. It is a shoot-them-up in the style of Starfox and
the classic Space Harrier for any of you old enough to remember it! :) The game is essentially
linear in concept but will contain character dialogue and cut-sceens to enhance player
immersiveness.
The game has been in production for over a year and uses an in-house 3d engine developed by Keith
and features a particle system, light / halo / lens-flare rendering, a custom terrain algorithm,
shadows and several other features. The 3d-engine is intended to support both OpenGL and DirectX
although for now only the OGL driver is implemented. I am working on the game engine code (content
managment, collision detection, AI, algorithms etc), content editor and the game code itself. I am
also dabbling with low-poly models. Keith also doubles as a 2d and texture artist. Elvio is a
talented musician and sound engineer who is building sound and music content for the game while
Kevin is a talented hi-poly model and animation artist working on title screens and cut-scenes.
More screenshots and a short animation are available here:
- [LINK http://colinvella.no-ip.com/perihelion/001.jpg]
[LINK http://colinvella.no-ip.com/perihelion/002.jpg]
[LINK http://colinvella.no-ip.com/perihelion/003.jpg]
[LINK http://colinvella.no-ip.com/perihelion/004.jpg]
[LINK http://colinvella.no-ip.com/perihelion/005.jpg]
[LINK http://colinvella.no-ip.com/perihelion/006.jpg]
[LINK http://colinvella.no-ip.com/perihelion/007.jpg]
[LINK http://colinvella.no-ip.com/perihelion/008.jpg]
[LINK http://colinvella.no-ip.com/perihelion/009.jpg]
[LINK http://colinvella.no-ip.com/perihelion/001.avi]
(L) [2004/04/15] [DylanBanarse] [dylan.banarse@gamewaredevelopment.com]
These are screenshots of the BAMZOOKi Zook Kit - a toolkit to build
virtual creatures, Zooks, using a realtime physics simulation. It was
developed by Gameware Development Limited for the Children's BBC
gameshow, [LINK http://www.bbc.co.uk/cbbc/games/bamzooki BAMZOOKi]; all 24
shows were shown on TV last month in the UK. Kids used this software to
build Zooks which were submitted to the BBC. Teams were selected and
invited into the studio to compete their Zooks in various contests.
The software is still freely available from the BBC site [LINK http://www.bbc.co.uk/cbbc/games/bamzooki/makeazook here] along with the
manual. Although designed to be easy enough to be used by kids, it is
highly flexible and can be quite complex. Zooks are built from the
bottom-up with elemetary component parts that the user shapes and sticks
together. You are not restricted to particular body designs or
topologies, although the control system uses a standard Braitenberg
architecture.
The BBC's Virtual Studio technology was used to enable realtime
composition of the 3D rendered graphics with live camera feeds. Each
studio camera has a dedicated render PC to render the virtual scene from
that camera's perspective. To know what a studio camera's perspective
is, each camera is fitted with a second 'Free-D' camera which points
towards the ceiling. On the ceiling are reflective, circular bar codes.
The Free-D camera data is fed to a computer system that identifies the
targets on the ceiling and calculates that camera's position and
orientation, 50 times a second.
The contest runs in realtime on a networked PC. All the clients receive
contest scene information and render their scene from their studio
camera's point of view. A bank of chromakey boxes then composite the
virtual and the live feed together to provide a realtime composite. This
video stream can be sent to the studio camera monitors so that camera
operators can view the composite and hence follow the action in realtime.
There is a non-childrens user-base establishing itself, using the
toolkit for their own purposes. Take a look at the Gameware Development
[LINK http://www.gamewaredevelopment.co.uk/forums/index.php? forums] if you
want to see what other users are doing with it.
(L) [2004/04/19] [LennartDenninger] [led@beatharness.com]
These are some frame-grabs from my fun-project called BeatHarness.
Basicly when going to (techno/trance) parties, I'm always staring at the VJ-screen thinking there could be
something more than 2 vcr's and a mix-deck :)
So I started working on my own 'automated' VJ-system (read: Winamp plugin :)), just for fun - and to show off the
videobeamer I've bought 1.5 year ago ;-)
For simplicity I've used Winamp as the framework that gives me the audio-data, but it wouldn't be hard to make it
a stand-alone app grabbing some sounds and performing some FFT's.
Since I didn't want to hardcode the effects, I've used [LINK http://www.angelcode.com AngelScript] as
scripting-language to create the effects and transitions.
I can't ever thank Andreas Jonnson enough, without AS BeatHarness wouldn't exist !
Furthermore thanks to Vincent Klop for writing most of the scripts.
BeatHarness is completely script / content driven.
Features at the moment:
- Effect scripts
Transition scripts
Image-textures, Video-textures (Avi, mpg, divx, whatever), Live camera input
feedback-grid-renderer ala Milkdrop / Geiss
enough draw-functions / renderstates / blendmodes that can be used from script - (textured) lines triangles,
quads, sprites, grids, alphablend, add, multiply(2x) etc.
Sound-info variables for the script : basic Bass / midtone / treble, and a GetFrequencyRangeIntensity(float
minFreq, float MaxFreq) function to get any freq-info you want.
Major ToDo 's :
- Loading / rendering 3d-objects. Not that hard, but the script-interface has to be right the first time :)
(Once people have written scripts using it, I can't tell them I've totally changed the interface :))
Plugins (for the plugin :)) so people can code custom effects doing whatever they like with D3D that the script
doesn't. (Pixelshaders anyone ? :))
Once again, all this was actually pretty easy to implement using AS.
I'm going through the last beta-tests now, but I expect to have BH available for download when this hits
flipcode's IOTD :)
Just keep checking [LINK http://www.beatharness.com] :)
Cheers,
Led
(L) [2004/04/21] [Shawn Halayka] [shalayka at sasktel.net]
[LINK mailto:shalayka at sasktel.net Shawn Halayka]
I am currently working on a realtime quaternion fractal generator using C++
and DirectX 9.0b. It currently supports point set generation using a dozen
or so different formulae, and allows the user to rotate and translate the
generated set.
I started working on the project after seeing the beautiful images displayed
on Paul Bourke's website:
[LINK http://astronomy.swin.edu.au/~pbourke/fractals/quatjulia/]
Eventually my goal is to be able to convert the sets to STL (stereo
lithography) format and have them cast into sculpture.
Planned features are to include the capability to generate meshes (with
output to one or more popular 3D file formats) and network distributed set
generation.
The source code is available from [LINK https://sourceforge.net/projects/julia4d]
and a precompiled binary is at [LINK http://taby.rezgeek.com/julia4d/1.0/]
(L) [2004/04/26] [AaronOman] [RadRider@shaw.ca]
My name is Aaron Oman, and attached is an image from a project I'm doing for my computer graphics rendering course
this semester. The topic my partner and I chose was "Real-Time Caustics". Originally we were going to implement
the Wand and StraBer paper on the subject, but we both lacked any experience with pixel shaders and decided to
implement the Daniel Sanchez-Crespo paper at Gamasutra instead. We just implemented the straight OpenGL (no pixel
shaders) version and used the wave-generation algorithm and textures from the paper. The floor texture we're
using, we found on a website that hosts free textures for usage.
Running as-is (which still could use some tweaking, but is definitely serviceable) I get 30 fps on my Radeon 8500
le with an Athlon XP 1700+.
It was a fun project to work on. This was the first time I've ever attempted environment mapping or blending, and
I'm mostly happy with the results.
(L) [2004/04/30] [SeanOConnell] [oconnellseanm@yahoo.com]
This is a screenshot of a level editor I am currently working on for a school game project. The game we are
making is going to be using the [LINK http://irrlicht.sourceforge.net Irrlicht 3D Engine], but the editor is written in
plain old C++ and OpenGL using Borland C++ Builder 6.
As far as features go, you can create terrain, skyboxes, skyplanes, skydomes, waterplanes, generate shadows on the
terrain, add fog, load and place models on the terrain. Currently the only supported format is Obj and 3ds
formats.
When modeling the terrain, you can create texture splats from different textures and specify your own resolution
for the alpha map and then paint directly onto the terrain with a brush. You can even create different types of
layers, they don't have to be texture splats, you can simply blend in a shadow map onto the terrain or a detail map
if you want or just stretch a single texture across. And of course basic Raise, Lower, Flatten, Smooth
capabilities are included for sculpting the terrain.
When loading meshes you simply drag the name of the loaded mesh from the TreeView on the left into the render
window where you want it placed and it gets put there. It kind of works like Battlefield's editor, cause I found
this method so easy to use.
When you save your work, you can export a heightmap bitmap file along with the alpha maps as bitmap files. You
can also export the geometry of each texture splat and only the triangles that were painted on or have some texture
on them are exported instead of the entire terrain over and over for each splat.
Anyway, I hope to finish this soon and perhaps release it for free to download cause I know a lot of people may
like something like this to use for their own games.
(L) [2004/05/03] [JosuaHoenger] [jh@visualight.com]
My name is Josua Hoenger, and attached is an image from a project called
'vLoop' which I'm doing during some nights besides my job as a realtime
graphics programmer. vLoop is a simple but powerful tool to create fancy
or natural looking volumetric textures. it allows flawless editing in
realtime (!) and exports volumetric textures or cubemaps as *.dds files.
this *.dds files can easy be used in DirectX as textures or lookuptables
for all kind of (pixel- and vertex-)shaders. the seemless (in all
directions: x,y,z!) textures allow perfect texturation of any 3d object
or unlimited tricks for pixelshaders if they come in play as lookup
tables... see the screenshots below (simplest 3d mapping + specular
lightning) rendered with ATIs rendermonkey.
more infos at [LINK http://www.visualjockey.ch/aboutme_focus_programming_vloop.htm]
(L) [2004/09/08] [C.S.Brewer] [csbrewer@unearthedgames.com]
In celebration of IOTD being back, I have a picture of a game engine I was working on about a year ago but never finished or submitted a shot of (named Procrastination Factor X) . more info and screenshots can be found here: [LINK http://people.haptek.com/clint/pfx/index.html]
This lovely screenshot was rendered in OpenGL using simple fixed function single texturing and fog. The skybox and terrain texture were generated using Terragen. The fogcolor was carefully selected to match the horizon color of the skybox, so it looks really good in one direction and not so great in the other.
The terrain source data was from a DEM heightmap from somewhere in New Mexico I think. It used the now infamous patch-based, split-only, variance error metric, roam algorithm. Although not shown here, I was also using the Open Dynamics Engine for physics, both the character moving arround on the terrain and a bunch of boulders you could shoot. I used FMOD for sound. I used TinyXML for parsing a simple xml initialization file, terrain "atlas" file, and skybox definition file.
(L) [2004/09/10] [AravindKrishnaswamy] [biospec@aravind.ca]
These images were generated using a new model for the simulation of light
interaction with human skin called BioSpec. BioSpec is both a spectral and
scattering model and was presented last week at Eurographics. The goal of
the BioSpec model is in the predictive simulation of human skin; hence the
input parameters of the model are all biologically oriented. In addition,
the model was validated by comparing the spectral reflectance, transmittance
and BRDF curves with that of actual measured data. The model is based on
standard Monte Carlo methods. It has been incorporated into an open source
renderer called Realistic Image Synthesis Engine (R.I.S.E.).
These particular set of images were generated to highlight the model's
ability to capture the translucency of human skin. The human ear is quite
translucent and if you place a reasonably powerful light behind the ear, you
can see it glow quite a bit. In these four images we increase the amount of
melanin in the epidermal layer, from lightly pigmented (light Caucasian) to
heavily pigmented (dark African). In addition to translucency we have also
generated images highlighting the model's ability to simulate medical
conditions. Details are available on our website.
Due to the model's stochastic nature, these images took several hours to
render. Areas of future work we are investigating include increasing the
speed of the model and its factorization and incorporation into rendering
hardware.
To learn more about BioSpec, visit:
[LINK http://www.aravind.ca/BioSpec]
To learn more about the Realistic Image Synthesis Engine, visit: [LINK http://rise.sf.net]
Thanks,
- Aravind
(L) [2004/09/12] [LambertBrink] [lambert_is_a_very@hotmail.com]
Here are a few screenshots of my first complete game called bl0kz. This was
written as a fun hobby, to prove to myself that I could write a complete game
and to implement a few things I've learned recently about Managed DirectX and
C#. It took about 3 months to complete, 1-2 hours a night when time permitted.
The difficult aspects turned out to be the UI, finding/creating art and sounds
that feels right and fits together, and like all projects, to finish it!
Some tech details:
- Object orientated, written using C# and Managed DirectX 9. DotNET really
makes the mundane programming tasks easy!
Custom 2D engine with sprites represented using quads and all
translations/rotations done as 3D with ortho perspective. This allows full use
of hardware features and should make it easy to create the 3D version of the
game.
DirectInput and DirectSound.
Custom UI described using XML.
Lots of bonus items, special effects, animations and sounds.
If you want to check out the game, look at the source code or for more details
on how it was made, feel free to go my website at
[LINK http://www.diebrinks.com/lambert/bl0kz.htm]
Lambert Brink
(L) [2004/09/13] [William] [edstudios@hotmail.com]
The ShaderStudioMAX is a multipurpose IDE (Integrated Development Environment) for Shader-based 3D Applications, i.e. PC Games, Real time VR-Model visualization or Real time Image Post-Processing, etc.
With its fully support of Microsoft Direct3D(r) 9 graphics hardware, many amazing graphics effects can now be rendered at fairly high frame rate on mainstream desktop PCs. One main purpose of ShaderStudioMAX is to help PC game developers to write and refine their graphics effects in a convenient way.
The Visual C++ project export functionality of ShaderStudioMAX is a power utility to export the ShaderStudioMAX scene directly to a VC++ project. This makes the ShaderStudioMAX a convenient RAD tool for rapid games and graphics applications development.
Along with the rapidity of development in computer graphics (CG) area, the quality of computer generated animation and interactive programs like games have been evolved to life-like.
The most significant change in polygon rasterization graphics pipeline is the implementation of programmable graphics processing units (GPU). The vertices and pixels (together called "primitives") of a 3D model now are not processed by fixed functions inside the graphics processor, but are passed to some sections of short machine code (called "shaders") to be processed in a programmable way. By processing primitives in this way, graphics programmers can gain high flexibility in writing graphics effects.
The ShaderStudioMAX was designed entirely based on programmable graphics pipeline. The primary goals of ShaderStudioMAX are simple: for experienced programmers, it will help them to translate their projects from fixed function pipeline to fully adopt the programmable graphics pipeline and take such advantages to create high quality graphics programs. For graphics programmers who just start to learn writing graphics effects, it will help them to learn the programmable graphics pipeline in a well structured way with the help of examples and templates.
The ShaderStudioMAX IDE is a convenient development environment for graphics programmers to write and fine-tune their graphics effects. Through the sections in user reference, how to use the ShaderStudioMAX IDE will be fully described with the aid of examples and detailed instructions.
The Visual C++ project export functionality of ShaderStudioMAX is a power utility to export the ShaderStudioMAX scene directly to a VC++ project. This makes the ShaderStudioMAX a convenient RAD tool for rapid games and graphics applications development.
Before using the ShaderStudioMAX to create your own virtual world, we hope that you can enjoy using it and learn some useful graphics knowledge.
The website is: [LINK http://www.ndawinteractive.com/shaderstudiomax/]
(L) [2004/09/15] [RichardPhipps] [richard@reflectedgames.com]
Storm is my first shareware game, an arcade style mission based shooter with 50 missions and 24 different weapons to collect.
Storm features a few new game and techincal features:
- 8 way directional thrust and 8 way directional firing for superior control of your ship.
Fly in arcs and circles around enemy ships and mines, firing at them from different directions.
Pixel perfect collision detection for all sprites.
Completely destructable terrain with subtle colour transitions.
Huge scrolling missions with parallax background and starfield effect.
Opposing weapon shots can collide and explode, while explosions damage anything.
Options to use Keys, Mouse, Mouse/Keys combination or Joypad.
3 different firing systems and redefinable keys/buttons (including dual stick joypad support).
Encounter different Enemy mines, ships, guns & lasers as you explore valleys, caverns and Enemy Bases.
Multiple missions to choose from. with 3 Difficulty levels and a continue game option.
Hours of gameplay..
Storm was programmed in C using the open source Allegro Library.
There is a free 9 mission demo of Storm available from the website and the full game is available for $19.99 from my website or BMT Micro.
[LINK http://www.reflectedgames.com]
Richard Phipps
(L) [2004/09/17] [PauliusLIEKIS] [onehalf@interamotion.com]
Syntonic Dentiforms is a demo (non-interactive program that shows realtime
graphics and plays some music). We (Nesnausk! team and a couple of friends)
did it on our spare time for fun and experience. The demo was developed
during Feb-Mar 2004. We took it to [LINK http://breakpoint.untergrund.net/ Breakpoint]'04 demoparty in Germany, it got 6th place (out of 22).
The demo features:
- Graphics effects, with several fallback paths (for pixel shader 2.0, 1.4
and 1.1 hardware):
per-pixel diffuse/specular lighting (without bumpmaps),
realtime shadows with limited self-shadowing ("Robust Object-ID
shadows", S.Dietrich, ShaderX2),
multiple planar reflections,
postprocessing effects (cartoon style via several color
transforms/edge-detection and Bloom for glow).
Animations were actually authored, so there's no realtime physics at all
:)
In code we made heavy use of DirectX9 and some of it's cool features
(notably Effects Framework).
Links:
- Download it from:
[LINK http://nesnausk.org/nearaz/files/SyntonicDentiforms_nesnausk!.zip]
Comments at pouet.net: [LINK http://www.pouet.net/prod.php?which=12057]
Some more info and screenshots:
[LINK http://www.nesnausk.org/project.php?project=11]
Nesnausk! team homepage: [LINK http://www.nesnausk.org/]
Paulius LIEKIS aka OneHalf
(L) [2004/09/21] [DiogodeAndrade] [Diogo.Andrade@spellcasterstudios.com]
This is a screenshot of a Weapons Platform exploding in our upcoming
game [LINK http://shadowstars.spellcasterstudios.com "Shadow Stars: The Ventrui Belt"].
On the technical side, there's not lots going on... Simple particle
system (billboarded particles, CPU calculated, with rotation) ejecting
from a emitter that's the surface of the mesh itself, while some
"light-beams" Star Wars-like spread out from the objects centroid. The
hard part was making the animation not stall the rendering pipeline
(since I'm updating the vertex buffers every frame), but that was solved
interleaving the vertex buffer update with the animation system, before
rendering occurred... If all goes well (in my tests, they go!), the bus
transfer finishes well before all game physics, etc, runs...
Market-speek:
For honor... For kingdom...
A terrible weapon is being built on the Tarwyne-controlled Ventrui
asteroid belt.
A war fleet is sent in, but after a disastrous information leak, it is
utterly destroyed, with the exception of a crippled Mjolnir cruiser and
the Warfyr family´s latest weapon: the Warblade general purpose fighter.
Fast, maneuverable and with enough firepower to challenge even a mighty
Doombringer, the Warblade is all that stands in the way of a Tarwyne new
secret weapon that could shatter the delicate power balance in the
Shadow Stars.
Be Gabriel Warfyr, the 3rd in royal line of the Warfyr family as he
pursues a goal that could ultimately lead to the victory or downfall of
the Warfyr family.
Shadow Stars: The Ventrui Belt is an action game featuring arcade space
combat against hordes of enemies:
- Advanced 3d graphics
Spectacular visual effects
Realistic flight model
Action-oriented gameplay
18 missions, including objectives as convoy strafing, elusion and
cruiser attacks
Pitch the Warblade against several different enemies, with different
tactics and vessels
Navigate treacherous asteroid fields inside nebulae
Destroy installations on asteroids
Play random quick missions of increasing difficulty and beat your own
limits
Adaptable LOD (Level Of Detail) system to suit your computer´s limits
without detracting the game experience
Awesome classic/techno soundtrack to heat you up in battle and relax
you between them
Amazing 3d sound adding to the game immersion
Game website: [LINK http://shadowstars.spellcasterstudios.com shadowstars.spellcasterstudios.com]
Spellcaster Studios website: [LINK http://www.spellcaterstudios.com www.spellcaterstudios.com]
(L) [2004/09/24] [NicolasWeber] [nicolasweber@gmx.net]
What you can see here are some screenshots of an image viewer I'm writing.
It is called ddsview and is specialized in viewing dds files. Not all
internal dds formats are supported, but nearly all that are in common use
and more than in any other image viewer I've seen (for example, read/write
support for ati2n/3dc or Doom3s normal map format) - that's why I wrote this
app. The viewer can view (and write) several formats besides dds - png, jpg,
dds, xpm, gif, hdr (that's Radiance's High Dynamic Range format if you don't
know it), sun, pnm, ...
The topmost shot is showing off ddsview's cubemap view feature for viewing
dds cubemaps (it's also possible to view the different mipmaps in a dds file
and all the different slices of a 3d texture dds file).
The second row shows (in this order) the rgb channels of a png, it's alpha
channel, and the rgb alphablended with a checkerboard background.
The last shot demonstrates the tile view feature, so you can easily see if
the current image is tilable.
Further features:
- fullscreen view
display color below cursor
...
You can get ddsview for free and with source code from
[LINK http://www.amnoid.de/ddsview/ www.amnoid.de/ddsview/]. It's still being developed, so feel free to send
suggestions. And tell me if you are good in GLX 1.3, then you could help me
with some issues I'm having with the linux port ;)
(L) [2004/09/25] [AlexandreBrien] [alexandre.brien@gmail.com]
I started Rift over 2 years ago, and it was an ambitious RTS set in
the future. I eventually started recruiting people to help out, and at
one time we had a team of 3 programmers and 4 artists. While the
project is no longer a team effort, after the team disbanded for real
life obligations, I am still working on it, trying to wrap it up in a
fun mini game.
The engine, music and art were all entirely created by us.
Here are the game/engine features :
Game features
- Typical Lobby system to create games
Extensive Gui System for menu and in game interfaces
Players may create units, move them around, engage in battle, destroy
another player's units, etc...
Graphic Engine
- OpenGL only
Uses VertexBufferObjects and also supports card that don't have this extension
Frustum Culling
Keyframe animation system
Audio Engine
- Uses FMOD sound API
Positional 3d sound
Mp3 for music
Network
- Uses a network library called Libnet which was specifically written for Rift
PeerToPeer network scheme
Uses a "game turn" system so that all clients are always in-sync.
More info on this can be found here :
[LINK http://www.gdconf.com/archives/2001/terrano_1500arch.doc]
Other Engine features
- Resource managers (Texture, Audio, Mesh)
In-game console
Animation system with the ability to "bind" sound effects to keyframes
ActorEditor to quickly create new units, buildings and environnement actors
3dsmax plugin for our own model format
More info and a version history can be found on my website at
[LINK http://gdev.blue-fairy.com]
Alexandre Brien
(L) [2004/10/01] [KurtMiller] [iotd@flipcode.com]
The screenshot above features the submission information for the Image of the Day section. By following the fantabulous instructions before thee, the golden key to fame and fortune may very well be withi... errrr... let me rephrase...
As most of you know, the IOTD is a fun little community feature. The reason for this post is both to remind you to keep on submittin' them thar neato images, but also to remind people that this is a developer feature. While its not frowned upon to submit images of commercial applications as well, be sure to include an adequate description that other developers might learn from! I say this because we received a few submissions recently that were clear advertisements, complete with marketing buzzphrases like "cutting-edge visualization interfaces", "multimedia paradigms", and "twisted spaghetti graph traversal." Ok, so I made that last one up.
But seriously, here are a few things to consider including with your description: what tools were used, how long it took to develop, the basic idea behind any unique features, what you're working on next for the project, why it exists, and when/where to get it.
Enough talk though, [LINK http://www.flipcode.org/iotd/#submit click here to submit an image!]
(L) [2004/10/02] [RoelReijerse] [roel.iotd@xs4all.nl]
Inspired and impressed by the IOTD of Joost's [LINK http://www.flipcode.org/cgi-bin/fcarticles.cgi?show=3&id=63632 raytracer], I started
to write my own (and first) raytracer. As information source I used mainly
the almighty [LINK http://www.realtimerendering.com/ Real-Time Rendering] book,
some intuition and a lot of luck. It resulted in a classical raytracer, with
the usual features:
- planes, spheres and (textured) meshes as primitives
point lights, directional lights and global illumination (monte carlo)
support for (HDR) radiance maps
loose octrees to speedup rendering of high-poly meshes
(fuzzy) reflections
A description of the image:
On the top left you see a scene lit with a home made LDR radiance map. I
made it by photographing a christmas ornament since it was the most round
and reflecting thing I could find in my house. It wasn't quite perfect round
at all and there were some traces of fake-spray-snow on it too, which
resulted in a not so perfect map. I had fun anyway :) (yes, you can see me
laying on the street photographing the thing).
On the top right a standard scene, lit with a HDR map.
On the bottom another scene, lit with the same HDR map.
I used HDR maps from [LINK http://www.debevec.org/Research/HDR/] and used also HDR
Shop you can find there, to convert my christmas-ornament thing to a more
compatible float map.
On my humble page at [LINK http://www.xs4all.nl/~reije081/raytracer/] you can find
a kind of log of my progress during developing it. Joost did something
similar with his raytracer and I really liked that: it showed me that those
impressing renderings you often see as IOTD do not come out of the blue, but
that all raytracers start with some crappy renderings. (like mine did).
As you might see in my development log, it is a project of some time ago, I
was recently busy with some other (real-time graphics) projects. The next
raytracer I'll write will use photonmapping, something that seems very
interesting to me.
Thanks for your time,
Roel Reijerse.
(L) [2004/10/04] [DanRoyer] [droyer@shaw.ca]
Here is an image of the new free demo for Mei's Cube Puzzles, a game that recently became available as shareware.
It uses no shaders, no class factories... in fact, no crumulent buzzwords at all - that way just about every person with a computer less than 6 years old can run it.
It was written by Mei over a period of about 9 months in her spare time using MSVC6, OpenGL, and her wits. It is her first major programming project!
As her sysadmin & marketing lackey I want you to download and play it but I must warn you: There is a chance that you puzzle fiends will fall in love with it and then buy copies for all your friends. :)
More screenshots and a free demo can be downloaded from [LINK http://freakin.no-ip.com/content?content.8 the homepage for Mei's Cube Puzzles].
(L) [2004/10/08] [PauliusLIEKIS] [onehalf@interamotion.com]
The Fly is a demo (non-interactive program that shows realtime graphics and
plays some music). Nesnausk! team (I and my fellow Aras Pranckevicius) made
it for Microsoft's [LINK http://www.imaginecup.com Imagine Cup 2004] and it took second
place in the worldwide finals! The official PR is [LINK http://www.microsoft.com/presspass/press/2004/jul04/07-06Champions04PR.asp here]. Of course, we're really happy about that (but watch out for Imagine Cup
2005 :))
The demo was made during Mar-Apr 2004, reusing lots of our previously
written code.
The demo features graphics effects, with several fallback paths (for pixel
shader 2.0, 1.1 and fixed function hardware):
- tangent space normal mapping, using over-the-edge diffuse lighting;
a mix of above and precomputed lightmaps, using ad-hoc method;
depth-of-field using two blurred versions of the framebuffer;
fur rendering using extruded shells, (L.T,V.T) texture lookup for
anisotropic lighting and some faking of self-shadowing;
simple projected shadows;
multi-layered terrain, with three detailed textures, "texture mix map" and
precomputed lightmap;
water rendering with several scrolling bump-maps for water waves;
translucent and iridescent wings.
Links:
- Download it from: [LINK http://nesnausk.org/nearaz/files/Nesnausk!-TheFly.zip]
Comments at pouet.net: [LINK http://www.pouet.net/prod.php?which=12271]
Some more info and screenshots:
[LINK http://www.nesnausk.org/project.php?project=12]
Nesnausk! team homepage: [LINK http://www.nesnausk.org/]
Paulius LIEKIS a.k.a. OneHalf
(L) [2004/10/10] [garry] [garrynewman@gmail.com]
We have been working on Facewound for about 12 months now. Our idea
was to utilize 3D hardware ina 2D game - which I think we have done.
The engine is a simple 2D tilemap engine - with 'props' that can
either be solid, in the foreground or in the background. It also
features lens flares, lens glows, parallax props, realistic water,
rotating props, additive blending props, particle spawners, elevators
and doors. You can add any of these things to a map in the editor. The
engine itself is based around triggers - basically any entity can
trigger another entity. So you can have a door open when you kill an
enemy, then the door opening could trigger another enemy spawning etc.
Most of the advanced features resolve around using pixel shaders. We
use the pixel shaders to create effects such as fully reflective
water, huge explosion shockwaves, bullettime bullet trails(yes, like
the matrix), water drops on the screen (when it's raining) and a fire
heat shimmer effect.
Each map can have it's own post-processing pixel shader too. This is
usully used to give the water a unique colour or a unique reflection
size - or to just make the screen darker/brighter. It can also be used
to add some weird effects (as seen in the shader tutorial [LINK http://www.facewound.com/tutorials/shader1/ here]).
We're hoping to have the game finished within the next few months -
after which we will be releasing an SDK for people to make their own
games using the engine.
We have quickly thrown together a pixel shader example movie - which is
shown here : [LINK http://www.facewound.com/img/pixelshaders.avi]
The official Facewound site is [LINK http://www.facewound.com/]
(L) [2004/10/19] [Peter & Alex] [n/a]
[LINK mailto:n/a Peter & Alex]
This image of the day may be interesting for modeling software developers
especially for Java/Java3D based applications.
The upper image demonstrates the appearance of the "X-MT" 3D editor, which is a fully
platform independet modelling tool based on Java/Java 3D Virtual Machine technology.
The use of dynamic plugin loading offers the ability to use this editor as a
visualization platform for any 3D-editing tasks.
Some features:
- platform independence by the use of Java-Technology
four independent views (virtual scene camera)
exclusive or split screen
orthogonal and perspective projection
360 degrees of freedom camera
...
The lower images show the available plugins in action:
1) Character Animation Modelling (left):
- Keyframe Animation
Realtime Mesh Skinning
Animation Player and Skeleton Editor (Bone Manager)
low level Influence Editor (Vertex Bone Weight)
CAL3D Support
...
2) Terrain Modelling (right):
- Modelling in 2D and 3D
Free shapeable brush tool
Import: DEM, JPG, BMP, PNG, TIFF, GIF
Export: JPG, BMP, PNG, TIFF, GIF
Procedural texture generation
Light texture generation: "slope lighting"
...
For detailed information and downloads contact us:
[LINK http://www.phenomatics.com/opensource/]
regards,
Peter & Alex
(L) [2004/10/23] [SylvainLefebvre] [Sylvain.Lefebvre@inria.fr]
Etees: The Nut is Nut Enough. This is the first game project I worked on with my friend Alexis Angelidis. We actually started the project in 1999. After working on it during our spare time for almost two years, the project got lost in the deep unexplored undergrounds of my computer's hard drive.
Recently, after a frog suddenly jumped through my apartment window directly into my overclocked GPU fan, I suddenly remembered about Etees and thought it may be great to put the project online. And here it is.
The Story:
Small but unfriendly creatures, the Etees, have just invaded the Earth, enslaved the Frogs and destroyed Humanity. And why? Just to create a huge devastated land where they can play their favorite game: fighting for nuts.
So, have fun, and do not forget that this was a first project, so it is absolutely far from perfect and contains (lots of) bugs.
The Game:
The goal of the game is to take small nuts (enclosed in red capsules) that are at some random places on the ground. Once you have taken one you must bring it back in the middle of the terrain, under the tree. Be careful, your opponents are not friendly people. If you are hit by an explosion, you will lose your nuts.
The game can be downloaded from [LINK http://www.aracknea.net/etees/index.html this page]. Two players can play simultaneously in split screen mode. Comments are welcome !
Behind the scenes: Lots of visual debug information can be displayed. Simply hit [TAB] (the console appears), enter map (a map appears), then enter debug. Do not forget to close the console ([TAB]) since it takes the keyboard focus.
You will see all the forces applied to the cars, the targets of the opponent's AI (well, Etees are actually rather stupid creatures ;-), and other stuff that I forgot about. The physics of the vehicles is simple: the car is considered as a solid and the dampers are springs with a straightforward (and unstable) Euler integration. By hitting [z] you will be able to change all the car physics parameters through a small settings window.
The terrain rendering is very simple (grid of display lists (OpenGL) selected by a frustum culling), and quite slow since it is not stored as triangle strips and there is no lod (remember: first project, back to 1999 - at the time, the terrain was using 8 times less triangles). The first implementation was using ROAM lod. Due to the CPU workload (and I must admit poor implementation), this was actually taking more time than feeding the GPU with all the triangles and doing per tiles frustum culling !
The smoke effect of the main menu is done with the [LINK http://lefebvre.sylvain.free.fr/gltut/diffusion/ following technique].
The most difficult thing with this project was to create a game with all the required elements: nice menus, bonuses, some random physics and a windowing system (hmmm, not trully essential) - oh and well, I almost forgot - exploding frogs.
(L) [2004/10/24] [KurtMiller] [kurt@flipcode.com]
These are some screenshots of an unannounced [LINK http://www.gradientstudios.com Gradient Studios] game
I was working on.
Its a futuristic combat racing game which sort of attempts to merge the simplicity of
Super Mario Karts with the looks of F-Zero. Oh, and there are guns. Huge guns.
There are quite a few maps, weapons, and racers complete, but there's still a lot of stuff left unfinished.
Most of the development took place late last year through early spring of this year. Unfortunately, a bunch of
"real life" stuff eventually popped up and kept me from finishing it. Yeah yeah, excuses excuses,
but in any case I hope to pick it up again when
the timing is right (or if a publisher wants to fund the rest :) Its got a pretty solid code base,
a basic working playtest, accompanying tools, and some great art assets behind it. The
programming was done by myself, and the artwork was done by the ever-talented [LINK http://www.3drt.com Max Shelekhov] (who
I had worked with on a [LINK http://www.gradientstudios.com/strayfire/ previous game].)
Here are some details regarding the tech which may or may not interest you:
- The tracks are imported as arbitrary polygonal data, with one addition: there are two splines defining the
'left' and 'right' boundaries of the driveable track area. To stick the racers to the track, something I call a
"track shell" is generated from those splines-- basically a tunnel made of boxes. You can see segments
of this rendered in the middle/left screenshot, but there are invisible left and right segments as well.
Racers generally never actually touch the
track polygons themselves, they're just checked for collisions against those shell walls.
The face normals pointing up from the segments are used
for basic orientation and "height" of the racers, which helps them follow the track and naturally
allows stuff like corkscrews, loops and upside-down driving.
I'm not really sure how other racing games accomplish this sort of stuff, but the approach I described
above is simple and works quite well in practice.
The main limitation is that you can't really get the racer off the track. This is worked around
by just having certain areas designated 'trackless', where collisions occur against the world itself.
In those cases its up to the artist to ensure that the track data will bind the player so he doesn't fall off the universe.
This same workaround is used for the 'arena' maps.
- The general collision detection in the engine is done using swept ellipsoids. I found Jorrit Rouwé's
[LINK http://www.three14.demon.nl/ paper] on the subject to be particularly useful.
- The rendering engine uses DirectX9 and Cg for shaders. There are some basic shader effects in the version shown,
but the screenshots can't really show them off. There's a primitive OpenGL renderer for the engine too, but
I never had time to fully develop it. I'm looking forward
to eventually jazzing everything up with far more snazzy shader effects though. I guess that's one of the 'benefits' of taking
a break from a project -- the hardware keeps getting better and better while you sleep :P
- The game uses a client/server architecture throughout. Everything (like the bots in the picture) are simulated like any other
client connecting to a server. Things like movement and attacking are done through messaging, just as they would be
over a network. The actual multiplayer component of the game isn't implemented yet, but all the groundwork is there.
- The toolset is reasonably solid, but in particular the special effects editor (shown in the screenshot) is kind of interesting.
The system works like this: A single effect is composed of N different particle emitters.
Each type of emitter is defined once in code (in a DLL), and has a bunch of properties.
Most of the properties for any given emitter are controlled via splines, allowing for quite a bit of flexibility throughout a given
particle's lifetime. You pick the start and end range of a property, and then configure the curve to define how it moves between those values over time. For instance you can make a particle speed up or slow down, grow or shrink, fade in or out, etc. You can even control 'how random' to make the behaviour in the same way-- whatever the emitter supports. The result is a (non-technical) special effects interface that offers quite a bit of control. From the core implementation I had going, it
turned out to be a rather flexible system that's actually a lot of fun to play with. I don't like to think about how much time I wasted making goofy explosion effects.
Anyway, there's a bunch of other stuff going on behind the scenes, but this description is already turning into a monster blob of
text. Me shut up. Me shut up right now.
(L) [2004/10/26] [WalterO.Krawec] [wkrawec@waltsgames.com]
Here are a few screenshots of SPACE an action/adventure game currently under development. In SPACE (that's just a temporary name until I come up with something else), you play as a freelance starship captain around the year 2314. I'm not going into details about the story line because, a.) most of it's still a closely guarded secret, and b.) the basic theme of the game can be seen at my website.
So anyway, the SPACE engine uses OpenGL to render both 2D and 3D objects. The engine is actually a 2D/3D hybrid meaning that the terrain and units are all 2D (well, actually a 3D quad, but still flat), while other objects such as the tall buildings and the trees are all 3D. The engine is capable of rendering very large worlds (right now the largest area is about 7*7 screens, but the engine can handle a lot more) giving the player an incredible amount of freedom to wander around and blow stuff up.
SPACE gives the player a ton of freedom while playing. There are two types of combat in this game: space (outer-space), and land combat, and the player will be doing a lot of both. In space combat, the player pilots their ship, usually to another planet, however there are many times throughout the game where a major fleet battle will take place. There are also several enemy ships flying around, so you'll run into them soon enough. The player can also purchase newer, and better ships whenever the player has enough money.
When fighting on land, the player can choose from a variety of weapons to use... anything from assault rifles, to rocket launchers, to energy pistols. Also, there are many drivable vehicles in the game that the player can grab and drive around in. These vehicles include four wheel drive Light Attack Vehicles, and even hover ships.
SPACE also uses OpenAL for it's 3D sound engine. I was actually amazed at how simple it was to incorporate OpenAL into this project, and doing so allows the game to play several sound effects at once and even position these sounds in 3D. So if, for example, an enemy shoots to the right of your screen, it will actually sound like it came from the right of you.
In addition to all of this, SPACE also has a custom made scripting engine which allows me (or the end user) to easily create and incorporate story lines and more dynamic maps very easily. But I'm not going into what a scripting engine is, since you all know this anyway.
Like I mentioned above, more information about the game itself can be found at my website (URL below).
Walter O. Krawec
[LINK http://www.waltsgames.com]
SPACE info: [LINK http://www.waltsgames.com/Space.html]
(L) [2004/10/29] [KurtMiller] [kurt@flipcode.com]
The Image of the Day queue was empty, so instead of featuring another kickass developer shot submitted by one of our readers, I've clearly been left with no choice but to display this delicious pie photograph that I found on the internet. After all, everyone likes pie! Discuss :).
Update: As someone pointed out it mightn't be the best idea to link to the former pie. The image now features an equally delicious one.
(L) [2004/10/31] [JohnathanSkinner] [johnathan@veggiegames.com]
Steer Madness is an independently developed fully-featured 3D action
adventure game. Best described as "Grand Theft Auto" meets "Chicken Run",
you play the game as Bryce the Steer on a mission to save all the animals.
The game is still in development but nearly complete with an expected
release date of December 1st, 2004. The team consists of myself, one
texture artist, and occasionally an intern or two from a local 3D art
school. I am self-publishing by getting the CDs made and packaged at a
local CD manufacturer and then selling wholesale to retailers. This is
affordable as an independent developer because I can do a small initial
manufacture run and then get more made as I need them. Finding retailers
will be a challenge, but because of the animal rights theme of the game I
am getting a lot of support from animal rights groups, including being
featured in the winter catalogs for PETA in the USA and Viva in the UK.
The focus in developing this game was on the storyline and message of the
game and not the technology or graphics quality. This was beneficial in
many ways:
- Compatible with a wider range of machines due to lower system
requirements
- Lower detail world means less artwork so it's managable by a small team
- More time can be spent developing the characters and storyline, and
getting players to care about the characters which is what really gets them
hooked on the game
It would be nice to have better graphics and more spectacular special
effects, but as a team consisting of only 2 people I must succumb to the
fact that it's impossible to compete in that regards with all the big
budget games with their 20+ artists. So instead I focus on what is unique
about my game which is what makes it stand out from the rest: A steer,
riding on a bike, trying to rescue all the animals!
More about the game can be found on the website, as well as a trailer
video. Check out:[LINK http://www.SteerMadness.com]
- Johnathan
(L) [2004/11/02] [JariKomppa] [jari.komppa@gmail.com]
Yep, it's that time of year again. Text mode demo competition 7.
Deadline 12.12.04.
More info on the contest (such as rules, etc) can be found at
[LINK http://tAAt.fi/tmdc/]
The invitation demo uses FMOD for audio, LibCaCa for the console
'graphics'' output, and CFL3 to contain the data files.
Due to the fact that I've been even more busy than usual (having
started studying in the evenings), the demo was made in a hurry
(basically 2-3 days), including improvements on my textmode rendering
engine. Most of the improvements were prompted by LibCaCa's output
quality, which is surprisingly good.
All 3d in the demo is rendered with gouraud filler and blur filter;
the scenes have surprisingly huge polygon counts =). As a neat
technical detail, the blur filter uses a 2-pass "any sized box blur
filter" trick - the blur effect takes exactly as much cpu time
regardless of the blurring strength.
Cheers,
Sol
(L) [2004/11/04] [RichardPhipps] [richard@reflectedgames.com]
Chaos Funk is a faithful remake of the classic spectrum game 'Chaos' by Julian Gollop. Chaos is a multi player, turn based, fantasy war game. Each player takes on the role of a wizard and attempts to kill the other wizards by casting spells or summoning creatures to attack them. Featuring up to 8 human or computer players Chaos is still a lot of fun to play with friends and each game is unique! Julian Gollop went on to create the X-Com series of games and also Laser Squad: Nemesis.
Chaos was placed into the Public Domain by Julian Gollop, and when this project was started there were no faithful and complete remakes available for the PC. Apart from a few bugs Chaos Funk is complete and very faithful. It features all the original spells and creatures from the spectrum version, as well as adding the extra spells from the Atari ST remake by Martin Brownlow. To ensure that the internal logic was accurate, relevant z80 code was analyzed by Chaos fans and equivalent C code was used to make routines such as spell casting, combat and the spread of growths faithful to the original game. The AI system was however built from scratch and plays a good game with a few quirks.
In developing Chaos Funk I wanted to be faithful to the original graphic style rather than having textured backgrounds or detailed creature graphic. However I also wanted to make things a bit more interesting, and so I used some neat scaling routines I had developed which were ideal for the graphic style of this game.
Every graphic in the game is either a recoloured 16 x 16 sprite from the original game, or a new 16 x 16 image I created. These images are then smoothly scaled in real time to create the display without pixelation or blurring. The bottom part of the image shows the standard view in which every graphic you can see is being stretched to 32 x 32 so the game runs nicely in a 640 x 480 screen mode (fullscreen or windowed). By clicking on a creature with the right mouse button you can literally zoom in on the sprite and see the relevant statistics for that creature (see the top part of the image for an example of this). The image scaling is very fast, enough that on a 300mhz PC the frame rate only starts to drop when most of the board is filled with sprites.
Chaos Funk also features a very flexible sound system so that players can implement different sound sets which can be made up of hundreds of different weighted sound samples.
The game is free and can be found at [LINK http://www.reflectedgames.com] under the free games section. If you like the game, why not try my first shareware game Storm or some of the other shareware games on my site? Your support will help me develop cool new freeware and shareware games. :)
(L) [2004/11/06] [RyanGaule] [rgaule@gmail.com]
G-Spot Tornado is a top-down arcade style shooter developed by myself
and two classmates; Jeremy Hardy and Graem Clark, while studying at
Arts Institute of Burnaby-Vancouver. We developed this small game from
start to finish in just under a month and a half, using DirectX 9.0b.
The name comes from a Frank Zappa song that inspired us to create the
frenzied gameplay. Technically there are no new techniques for
rendering, and no vertex/pixel shaders to speak of. Gameplay consists
of you controlling a little spaceship that is bound to stay within the
borders of each level, and must fend off the hordes of enemy space
aliens that wander into your vicinity. Lots of blasting, particles and
a killer retro soundtrack make the game fun to sit down, play and
finish in 5 minutes. I don't have a website to post the game up on,
however if you email me I'll be happy to send you the 3.5 meg zip.
Update: You can download a copy of the game here: [LINK http://www.flipcode.com/files/demos/GSpotTornado.rar GSpotTornado.rar] (2.8mb)
-Ryan Gaule
(L) [2004/11/08] [BramdeGreve] [BRAM.DEGREVE@GMAIL.COM]
The poem, it was the poem... and the cheddar. It left me no choice but to also submit an IOTD, so here I am...
Let's see... more than three years have passed since my previous [LINK http://www.flipcode.com/cgi-bin/msg.cgi?showThread=04-16-2001&forum=iotd&id=-1 Image Of The Day], too long to remember! A lot of things have happened, too... except working on said raytracer. Then Jacco Bikker (aka The Phantom) started his [LINK http://www.flipcode.com/articles/article_raytrace01.shtml raytracing column] - an excellent opportunity to get back on track myself, I thought. So, I wrote a little [LINK http://www.flipcode.com/articles/article_reflectrefract.shtml tutorial] and started coding again. The result is displayed above (pure raytracing, no global illumination yet). What you see are reflective/refractive spheres, walls and floor. Particularly noteworthy are the transparent spheres and the bumpmapped water... Our three gentlemen, Mr. Snell, Fresnel and Beer explain what's so special about them:
- [LINK http://scienceworld.wolfram.com/physics/SnellsLaw.html Mr. Snell]: "Both the sphere and the water are not only transparent, but also have an index of refraction (n = 1.5 and n = 1.33 respectively). Thus, the rays of light must be refracted by my law." That's done here (well, at least for primary rays, shadow rays don't obey this). Observe the lens effect in the sphere and the distorted floor through the water; this is what my tutorial [LINK http://www.flipcode.com/articles/article_reflectrefract.shtml "Reflections and Refraction in Raytracing"] is about.
[LINK http://scienceworld.wolfram.com/physics/FresnelEquations.html Mr. Fresnel]: "In most ray tracers, reflectance and transmittance (reflection and transmission coefficients) are given by hand. And maybe that works fine for you, but I don't like it because it's not natural. Here I have equations that calculate the reflectance and transmittance on interfaces between two materials with different indices of refraction, and for every angle of incidence. You should use them." And that's exactly what I've done for the glass sphere and the water. Well, not really, because I didn't like the idea of simulating polarised light, so I cheated with a simplified equation proposed by Schlick (if you like French, you'll find it as equation 3.24 in his [LINK http://dept-info.labri.u-bordeaux.fr/%7eschlick/DOC/these.html Ph.D thesis]). Anyway, notice the reflections on the water and on the sphere.
[LINK http://scienceworld.wolfram.com/physics/BeersLaw.html Mr. Beer]: "In many ray tracers, the colour of transparent objects is totally determined by the surface material. In case of transparent solid, rays are tinted twice (on incident and exitant transmission). Of course, that's not correct: It's not the *surface* that determines the sphere's color, but the material *inside* the sphere. This is also true for water: it's not the water's surface that tints the light, but the water itself. You should alter the light intensity based on the distance traveled through the medium. That's only obvious: if you travel through a thick plate of glass, light will be tinted more than it would through a thin plate." So, I've implemented that as well: if light travels through a medium, its intensity is affected by Beer's law. The surface of a material can still affect transmitted light (e.g. for a coloured coat layer), but in the above scene this surface colour is set to white (this is also explained in [LINK http://www.flipcode.com/articles/article_raytrace03.shtml part 3] of Jacco's column).
To illustrate the effect of Beer's law, I rendered the same scene with more dense glass and water (higher extinction rate in the exponential decay term). In particular, notice how the three coloured spheres quickly disappear in the water, and how you can see the reflections better in this rendering. That's not because the sphere and the water have become more reflective, but simply because the background on which they're displayed has become darker.
So, what's next? Global Illumination I suppose... I've been hacking a photon mapper today, but it's too early to show any results yet... but that's only an excuse to post an IOTD later :)
Anyway, that's it for today. Happy coding, folks.
Bram de Greve
P.S. Oh, I almost forgot: I've spotted an error in my tutorial, can you find it too? :) I'll send the corrected version to flipCode later, with a special mention for anyone who finds the mistake.
P.P.S. Thanks Thomas ;)
(L) [2004/11/10] [SimonHowes] [Simon_Howes@moldflow.com]
We work for a CAE simulation company and have done some work for our next
release adding support for pixel and vertex shaders. :)
We used OpenGL Shader Language for this, as it seemed a better option than
the proprietary CG/etc languages that are out there. It seems this is
likely to stay around longer (who remembers Voodoo II) than the custom
stuff vendors are putting out...
Top left: simple chrome effect. Top right: 3 point-light phong-shaded with
cubic reflection map. It's amazing to see realtime phong rendering at
1600x1200 res, when you used to remember how long 3D studio DOS would take
to render a scanline! :) The middle image is a fake-phong: which uses a
specular map to lookup based on the surface normal: it runs really fast
and sometimes looks even better than the real-phong! At the bottom is the
X-ray shader (don't ask... maybe nostalgia, or maybe too much Syndicate
Wars..)
Cons/Pros?
Man. Earlier ATI cards are pants! During our testing these were the
suffering, with tiny instruction limits, lots of crashes and not a very
friendly Shader Language Compiler. nVidia really kicks butt! Though, I can
see why there is no option in the display properties to "render gouraud
triangles as phong", as it's still just a little bit too slow for that yet
(we get only about 3 frames per second on our most complex shaders: but
then, these are HUGE programs.) It's amazing the computer power that is
packed into a GPU in addition most of our models are around 20,000+
polies. The main taker of time is not Tris but pixels..
It was surprising to find out how many cards did support OpenGL 2.0 when
we installed the latest reference drivers from nVidia and *cough* ATI.
There's been no fanfar about it however: nothing on the webpages like when
some redundant feature is added (ie full-page advert about a better
cooling-fan and how this will make your life better.) Of course, the
reason for this may be that both nVidia and ATI support is still not
100%... (no noise operator for nVidia, and no variables indexing arrays
and poor compiler support for ATI!)
(L) [2004/11/12] [JulienGuertault] [virtual.zavie@gmail.com]
This is a screenshot of the visual system developed by Alsim for its
flight trainers. I worked in this company eight months and one of the
tasks was to design and implement some realistic volumetric clouds.
The method used is inspired from the Mark Harris and Niniane Wang
papers. It consists of dividing a cloud into metaballs and represent
them by billboards. In order to reduce the number of metaballs
required to give the cloud a realistic appearance, the billboards are
textured. A set of textures is generated thanks to Perlin Noise
functions.
Also, to reduce the overdraw due to all those transparent billboards
(125 per cloud), each cloud is rendered by an imposter (which itself
uses a texture manager to avoid video memory fragmentation). On each
frame, imposter's accuracy is tested in order to update it if
needed. The number of imposters to update by frame rules the tolerance
used in the test to keep this number low enough.
The color is computed by hardware light functions. Normal vectors
depend both on the position of the metaball inside the cloud, the
observer, the cloud, and the sun.
Finally, we can manage more than 200 clouds in real-time (at least 30
fps, on an Ati Radeon 9800 Pro powered PC). The user can fly around,
and get in the clouds, resulting in realistic effects.
You can find more information on the Alsim website ([LINK http://www.alsim.com])
and on my personnal webpage ([LINK http://zavie.free.fr/alsim]).
Best regards,
Julien Guertault
(L) [2004/11/14] [WillThimbleby] [will@thimbleby.net]
This is a screen shot of my game BitRacer. A fast paced 3D retro racing game. BitRacer was created in the past 3 months for [LINK http://www.udevgames.com uDevGames 2004], a Mac game programming competition. All the game's source code will be available and many post-mortems will be written.
Since the contest's inception in 2001, uDevGames has encouraged game creation for the Macintosh platform by featuring the best developers in the community. Every year, the contest invites budding and independent programmers to design, create, and polish new and innovative games within a three month period, whose playable files and source code are offered up free to the public.
In return, a public vote is tallied, in which games are judged by the quality of their Gameplay, Graphics, and Audio. The games are also subjected to an Originality and Story peer vote by the registered members of the contest, and a panel of experts vote for the Polish category - the level of professionalism displayed in a title. Over $34,000 in prizes, donated by over sixty generous companies in the Mac community, are awarded to the developers of the top three entries in each category, as well as the special categories of Best Overall Game, Best Newcomer, and an Editor's Choice Prize.
This year's contest features 32 official entries, from crossword puzzles to a 1-on-1 hockey title, all of which are available at the contest's official website, whose link is provided below. The contest's public voting ends Monday, November 23rd, and winners will be announced on the December 6th edition of The Gamesome Mac.
Download BitRacer at [LINK http://www.udevgames.com/downloads/?dlid=19]
Vote for BitRacer at [LINK http://www.udevgames.com uDevGames], download all the other great games, and enjoy.
(L) [2004/11/17] [RomanPfneudl] [roman@vertex4.com]
Hi guys! This is a screenshot of our current project SunAge and the IDE of its scripting-engine below.
We're working on that title for, well, yes, for quite a while...
Its a scifi - rts title with a different handling approach what we call: tactical-squad-based-static-warfare - game.
Well, this name is not very mnemonic, I guess, but it comes as near as possible to the gameplay itself.
The graphics engine is a 2.5D - isometric - tilebased engine, with all sorts of fake-3d-effects for all those
glows, explosions, but also to give certain areas of the map a different theme. And guys: let me tell you, I
would never make a 2D game of this size again, there are a thousand of things a 3D - game hasn't
approximately to take care of. (When I'm thinking of that fake line-of-sight-algorithm with simulated plateaus
of different heights I'm still getting goosebumps).
The pathfinding is done by some sort of weighted flooding algorithm, which results in an ugly pathline
which is then bezier-splined to make up for smooth movement of the units.
the ai is completely coded in our scripting language i said, for it supports all fancy things you need to
get this job done (like software-threads, own class-definitions, aso.). And the really good thing about
it is the debugging environment, which is blended over the game itself, and you're able to set
breakpoints and the like.
Well, there's some more info about us and SunAge on our site [LINK http://www.vertex4.com www.vertex4.com]
thanks,
Roman
(L) [2004/11/23] [SimonEschbach] [s.eschbach@gmail.com]
Well, this really is nothing compared to most of the awesome work I
have seen on this site, but this is a remake of asteroids I made using
DirectX 8 called "Spacerocks_UC".
Being a newbie, probably the hardest part of this for me was getting
the circular collision response with kinetic preservation working,
whilst factoring in the different masses of the individual objects.
Also, when it comes to the rendering part, it was a real challenge to
get the wrap around environment working.
I made all of the graphics myself using Rhino 3D for the modeling
and Bryce for the rendering. Bryce didn't seem
to rotate the textures with the mesh and this is why the rocks kind of
roll without the textures...
The game is available free for download at
[LINK http://www.skullbonez.com/spacerocks www.skullbonez.com/spacerocks] and features 5 different types of
weapons, 2 different enemies with basic but sometimes challenging AI,
and 54 levels (good luck getting through them all, the final ones are
actually quite hard!)
As this is the first game I have made, I was surprised at how much of
my high school maths I used to actually get it working! My advice to
all of the other newbies out there is to stick to it - some of the
routines in this simple game took me hours to get working, but when
you see it work for the first time it is just so rewarding!
Anyway, that's it for now, thanks for checking it out!
-Simon Eschbach
(L) [2004/11/27] [JohnStyes] [jstyes@metrocitystudios.com]
After the fall of Acclaim, I had a bit of free time
and whipped up this game for some fun. The game is
called CaveIn. It is based on an idea I had a while
back when I was coding demos for the GBA and I decided
to take it "3D". It is a puzzle game where the player
pushes around rocks placed in the level or that have
fallen during a panic mode to make three or more rocks
of the same color touch causing them to crumble and
score points. Besides for pushing the rocks, the
player can also give the rocks a kick sending them
flying.
The rendering uses a fairly simple set of wrapper
classes for Direct3D and the world is constructed
using 3D tiles. The 3D tiles were created in 3Dmax
and converted to the X format. Planar shadows are
using a simple method of constructing a world matrix
that flattens and skews the mesh across a plane.
Currently, the objects use their own mesh as a shadow
mesh and I am not using the stencil buffer yet to get
rid of the noticeable z-fighting. Lastly, I am doing
half of the toon rendering trick (scale and front face
culling) to give objects the outline.
John Styes
[LINK http://www.metrocitystudios.com www.metrocitystudios.com]
(L) [2004/12/02] [MidnightSynergy] [infos@midnightsynergy.com]
Wonderland and Return To Wonderland is a series of games published by us
between 2002 and 2004. We recently released an update to Return To
Wonderland with many new features.
Both games were written in Blitz 3D. 3D Graphics were done with Milkshape3D,
2D Textures in ArtGem. Additional programming (Loaders, etc) in Visual C++.
Info, demos, etc. can be found at [LINK http://www.midnightsynergy.com]
We're also running a little competition right now, which the creative folk
among you (and who isn't!) might wish to check out:
[LINK http://www.midnightsynergy.com/comp/0401]
(L) [2004/12/08] [LaurenceBourn] [laurence.bourn@3mensio.com]
The images displayed here were created by 3viseon new medical imaging
software produced by 3mensio based in Holland ([LINK http://www.3mensio.com www.3mensio.com]). This
little company aims to use GPU technology for realtime volume
visualization of medical scans.
All of these images are from a variety of CT scans.
- The background image slices show a collection of 2D CT images as
aquired by a scanner.
The central figure is from the company logo using a rather large pixel
shader to achieve blending between a variety of rendering techniques.
The figures on the right show some different rendering techniques
applied to the same dataset.
The top left image shows a cut away of a chest scan revealing arteries
inside the lung.
The software is implemented in C# using managed DirectX. We currently
use Ati X800s with 256mb but are really waiting for 512mb cards.
Typical data sets contain 512x512x200 voxels. Our central volume
rendering algorithm is fairly optimized taking advantage of empty space
skipping, early-ray termination and at the same time maximizing polygon
size. The rendering performance largely depends on the data set size,
visible voxel coherency and of course transparency settings. Most of the
images above render at 5-30fps with a screen res of 1024x1024.
You can read more at our website and note we're hiring!
Cheers,
Laurence Bourn
(L) [2004/12/09] [HelgeFoerster] [info@jpct.net]
The shot shows a work-in-progress version of Paradroid (a CBM64 classic) in
3D. I'm currently calling it Paradroid3D, but that won't be its final name.
Maybe Parathreed or something like this. I'm open to suggestions.
In the current version, you can do almost everything that you could do in
the classic game, i.e. move around, shot and bump into enemy robots, control
enemy robots and switch levels at any time using elevators between them.
What's still missing is the transfer sub-game (played to control an enemy
robot) itself and some other stuff like the data consoles the classic game
had. Anyway, the game is written in Java using the jPCT engine
([LINK http://www.jpct.net]) and should run on almost everything that has Java
installed (1.3 or higher). It supports OpenGL and OpenAL where available
(currently under Windows and Linux) and falls back to software rendering and
Javasound where it isn't.
If you have webstart installed, you can play the current version here:
[LINK http://www.jpct.net/para3d2/test.jnlp]
Some words about the controls:
Move with the mouse and CRSR-keys, shot with the left mousebutton, enable
transfer-mode by holding the right mousebutton (bump into an enemy in this
mode to gain control), press and hold both buttons (or space) on top of
elevators to access them (and use CRSR and "enter" to select a level once
you've entered an elevator)
Additional keys:
'C' changes from 3D view to pseudo-2D and back (the controls are slightly
different in that mode...you'll notice that)
'L' switches levels without using the elevators (a debugging shortcut)
'N' revives the player (for debugging too)
'W' shows a wireframe of the scene
'ESC' exit!
Any feedback is greatly appreciated. Especially from those who played the
classic game 20 years ago...i'm trying to mimic the feel of this game, but
i'm not sure if i'm succeeding.
Regards,
Helge
(L) [2004/12/10] [PhilipBuchanan] [surrealix@hotmail.com]
You don't see that much 2D on flipcode, so I thought I'd submit some images from a small game I'm writing, Radia.
It's really just another version of arkanoid, with a few differences I thought would be quite fun. You control a circular paddle, and instead of bricks, destroy the level 'worms' style, taking chunks out of it.
To start with, it uses only API functions, which are, unfortunately, quite slow, but allow me to target people who are not avid gamers, and who are unlikely to have a recent version of DirectX. It was a real headache getting around some of the major slow-downs, and the fact it was written in VB didn't do much to help. The biggest problem was that flipping the entire backbuffer to the screen is far too slow, yet often a large ammount of the level needs updating, usually in the case of the water.
The backbuffer is divided into sections, which get smaller according to the ammount of activity on screen. Water is divided into strips, about 20 pixels wide, with sub-strips of 2 pixels. Each large strip is moved vertically every frame, while smaller strips are moved every 'x' frames according to the speed of the computer.
This is drawn directly to the screen.
Fire is done with a pre-renderd mask, which is coloured, then animated in the same way as the water. It turned out a lot better than I expected.
The levels are all pre-rendered images, and the masks are calculated on startup. The paddle is made from sections, which are rotated on startup with a small algorithm I wrote.
There's nothing really fancy in it, but it ended up quite nicely. Some information, and a small demo can be found here:
[LINK http://www.freewebs.com/surrealixproductions/softwareradia.htm]
(L) [2004/12/12] [Shane] [codejoy@yahoo.com]
Here is our little game, the first commercial one.
ScreenShot1 shows the game in action mode. This game
was created to run on the tapwave zodiac
([LINK http://www.tapwave.com www.tapwave.com]) from the ground up using tricks i
learned in various programming books. The code uses
standard bitblts to draw the backgrounds and menus, it
uses color sourced blits to draw the sprites of
course, and in this screen shot we can see it doing a
graphics blit using a alpha mask(the shooting image)
and then it also uses the particular graphics api to
draw the cool explosion (pixels that have trails and
fade).
Background: You move your little piece around a
specific area to destroy pieces of like color that
entrench on your area...if they make it into your safe
square (the greyarea) its game over man. To destroy
other colors, you swap colors by shooting unlike
colors.
Technically the game isnt impressive, but the device
it was made on was. It was easy to port directdraw
code over to the device (cause they both use the same
concepts: blitters, and surfaces) and the device
itself is a cool pda for gaming: 480x320, 16bit color,
analog stick built in , touch screen and rumbler. The
api tapwave provides is pretty slick, and this game's
core was up and running in a weekend (took us 6 months
to polish the game).
So technical break down:
480x320 16 bit graphics
uses most the blitting options the device's api
offers.
Uses the rumbler effects
Though it being a 2d game, it doesnt really utilize
the analog stick.
Oh it should be noted, all the graphics are loaded
into the video ram, cause the device comes with a 8mb
2d accelerated video card!!! :) (making those
transparent blits nice :) ) its a smooth device, and
runs PalmOS. Though, we built the game from the
ground up for the specific device so it wont run on
other palm devices, but it means it doesnt "feel" like
a palmOS game, which is good... (though I didnt have
to learn all the intricacies of the palmOS)
The last screen shot is just a shot from the puzzle
mode, where u try to clear the board with only so many
shots. In retro spect we should of developed a PC
side client to let u make new puzzles and copy them to
the device, or better yet write a module in the game
lets u make ur own puzzles, and share them wirelessly
(the device has bluetooth) via infared, or load off an
SD card that may be present in one of its two slots.
I can say creating for this device was fun, especially
since using the API was so close to the directX api,
that made the learning curve to get a game up and
running a lot smaller than I previously anticipated.
Thanks,
Shane
[LINK http://www.viciousbytes.com www.viciousbytes.com]
(L) [2004/12/13] [NicholasChapman] [nickamy@paradise.net.nz]
These are some renders from my Monte-carlo ray tracer.
The top image took 886 secs to render and uses 3200 primary rays per pixel.
The bottom image took 883 secs to render and uses 1600 primary rays per pixel.
In the top image you can see sphere and plane geometry, depth of field, perfect specular reflection, diffuse reflection, and refraction with internal transmission.
Specular reflectivity is modulated by a Fresnel term in the red and green spheres.
Monte-carlo ray tracing is a very elegant technique which can handle all GI phenomena, such as specular reflections, caustics etc..
I use russian-roulette ray termination for unbiased estimation of the result of an infinite number of bounces :)
In the bottom image you can see the Stanford Happy Buddha (see [LINK http://graphics.stanford.edu/data/3Dscanrep/]) rendered with image-based lighting. The model itself is 1,087,716 triangles. Ray/mesh intersection is accelerated with a kd-tree, something that took a good week of coding and tweaking to get working decently :)
The env-map used for the image-based lighting is the beach light probe from [LINK http://www.debevec.org/Probes/]
The env-map is a HDR image, meaning it contains a larger range of intensities than normal 24 bit colour images.
A little bit more info and some more pics are available on my page [LINK http://homepages.paradise.net.nz/nickamy/]
Nick Chapman aka Ono-Sendai
(L) [2004/12/15] [Simon Couture] [nouse at gibbering dot net]
[LINK mailto:nouse at gibbering dot net Simon Couture]
Here are some screenshots from my custom heightmap editor. It is written in Delphi 6 and has a pretty good feature list. It uses a simple quadtree for culling. The texture is just a generated image stretched on the map.
The top image shows the main window with an island map, with a bunch of entities with bounding boxes loaded. You can see the toolbar with 6 tools (raise, dig, equalize, smooth, get and set height) to edit in realtime the heightmap and import/export options for the heightmap and the main texture. There's also a property window to edit entities.
Entities are defined by a simple script (middle left) to allow a great integration with the game engine. You can link your data to the position, orientation, boundingbox and model used in the editor. Data types supported are int, float, string and choice (a kind of combobox). All data is stored as binary (choice is stored as an index).
The editor has a lot a subwindows to manage different things like memory usage (middle center), configuration (middle center, bottom left) for everything in the editor (repertories used, clipping distance, quadtree's leaf size, texture filter, color, etc), lightmap generation with self-shadowing (bottom center), texture generation based on slope (bottom right), texture blending with alpha layer or separated alphamap, entity report with filter for fast finding, map properties and many more. All expensive operations are in a seperated thread and have a progress bar for better response.
It obviously has all common file operations: new, open, save, export. A single map is divided into 3 files (heightmap, texture and entities) to be able, for example, to use the same heightmap and same entities with a different texture (summer/winter theme) or different entities on the same heightmap.
If someone is interested to use this editor in their project feel free to contact me:
nouse at gibbering dot net
[LINK http://legion.gibbering.net/nouse]
Simon Couture
(L) [2004/12/17] [JariKomppa] [jari.komppa@gmail.com]
When I was starting on graphics programming, and programming in
general, the learning curve was somewhat easier than it is these days.
Windows APIs, messages, threads, triangles and stuff - you need to
know tons and tons more stuff than in the old days. On a 286 DOS
system, all you needed was a couple lines of (granted, rather cryptic)
assembler, and you were set.
So, to make things slightly easier, I decided to write a tutorial on
how to play with pixels. The tutorial is based on SDL, as that's the
easiest way (IMHO) to put some pixels these days. My goal was to try
to make the person who is reading the tutorial interested in playing
with the computer, and to find that programming can, after all, be
fun. The tutorial consists of short, understandable functions that
make interesting things happen, and there's hints on additional stuff
that the student can try to play around with the code.
The 6-part tutorial is suitable for people who are learning
programming by themselves, or who know programming but don't know
anything about graphics. Programming students may also use it as
additional material for programming courses. Bored of those dry
programming assignments? Maybe it's time to try something fun.
The IOTD picture consists of screenshots from the five applications
that the tutorial goes through.
Top left - x2+y2 pattern, basically just to show how pixels can be drawn.
Top right - simple sprites.
Middle left - simple snow fall effect. Reading and writing pixels.
Middle right - feedback effect. Blending.
Bottom left - primitives; drawing filled circles.
Bottom right - well, I ran out of screenshots, so here's a screenshot
of one tutorial page. =)
Oh, the tutorial is available at [LINK http://iki.fi/sol/gp/].
If you have a friend who's borderline interested in programming, this
might be the thing to push him/her over. =)
Cheers,
Jari
(L) [2004/12/18] [XycsoscyX] [xycsoscyx@hotmail.com]
Just for some of the same old stuff, I opted to post new screenshots of my engine. I recently decided to look into deferred lighting, and this is the result. Overall, the performance is about equal to the standard lighting methods (rendering all the geometry per light pass), but it really shines with more light sources at once. I can zoom out of the stage and still get a constant frame rate, even with 17 lights showing at once. The frame rate is fixed (as is the logic/input update steps), I'm using 20 FPS currently because it provides a smooth rate of motion, without missing any user input. I also support a "pluggable" post processing step (though the steps themselves are currently fixed, I simply have to derive a new filter from my base class, and add it to the list manually). Here are some specs:
- Plugable (insert system here), I use plugins for many things, including input, audio, logic, world data, mesh data, effects, etc.
Cross platform compatible base code, currently only supporting Win32, but versatile enough to support other OS's.
Plugable rendering system, using Direct3D v9.0 currently, with and OpenGL plugin in the works (it doesn't crash anymore, but still doesn't render anything yet).
Uses vertex/pixel programs for rendering, including a custom fragment parser/combiner:
I use the parser for the mesh/world plugins, they store a fragment to transform the vertex positions into world space, and to retrieve the texture coordinates, normals, etc. The core engine then uses that base and works from there to perform transformations, per pixel lighting, etc. The only downside is that the transformations get split into two steps, instead of a single transformation. Deferred lighting reduces the waste greatly, by only requiring the geometry to be rendered once, but I am still working on optimizing this (I know I can easly just transform by the final transformation matrix, but it doesn't fit well into my implementation so far).
3D Studio Max export plugins for everything, including static meshes, skinned actors (and animations), and the world data.
World data currently supports a portal visibility system, using author defined sectors for the world data.
Static meshes are meshes that aren't animated, like crates, chairs, etc.
Skinned actors use 3DMax's built in bone system.
Almost completely programmed from scratch. All my core libraries, math, file loading, error handling, UI, etc, are programmed by myself. Only a few 3rd party libraries are used currently, DevIL for image loading/saving, ZLib for ZIP archive support, OggVorbis for OGG audio file streaming, and TinyXML for loading UI elements (okay, maybe a handful, not just a few).
So far everything is working fine, without falling under my desired frame rate. Next step is the physical aspect, which is why I'm currently trying to implement a 3rd party physics library into my engine. I'm looking into ODE or Tokamak at the moment. I've implemented both before, just with unsatisfactory results, so now I am going to work on fine tuning either to see if I can get it working like I want (or at least close too). I'm also looking into HDR as a post processing effect, just for that added splash.
(L) [2004/12/20] [CiaranMcCormack] [ciaran_mccormack@yahoo.co.uk]
Here are a couple of screenshots from Crazy Pool, a 3D
Physics training exercise that I have been working on
for a few weeks. Whats Crazy about the game? It allows
the user to specify the number of sides of the table
and the number of pockets. This may result in you
playing on a near round table with 17 pockets or a
triangle table with 0 pockets! :S Who would win that
game??
Some features:
- Graphics/Input use DirectX 8.1
Table Mesh Dynamically Built to allow custom tables
to be Created
Physics for interaction with Objects eg, Collision
Detection and Response, Friction, Conservation of
Momentum (angular physics still in development so no
spinning balls yet)
Intelligent Camera which watches the action
Shot Assistance. Similar to Ghost Cars in alot of
new Driving Game Time Trials, watch the shot unfold
without affecting the table
Pool Referee
This is a very early version of the game. Alot of work
still needs to be done. Table mesh/Physics needs to be
Optimised. Game AI/Online MultiPlayer to be added so
if someone at PC on their own they can still play
against a competitor.
Visit [LINK http://www.ciaranmccormack.tk/] to download the
game.
Ciaran
(L) [2004/12/22] [LoïcBaumann] [loic@elixys.com]
Yep, another Terrain Engine...
I know, I know, at least one hundred IOTDs were about that.
So what is special about this one? Well youre the judges...
Hardware rendering of the terrain's heightmap:
That allows real-time deformations of the terrain by modifying directly the
height map.
You can also use this engine for animated water (sea/lake) rendering.
Very scalable:
The terrain is made of A*B elements, each element is made of C*D tiles, each
Tile is made of E*E vertices (E power of 2).
- Elements can be loaded on the fly from disc, allowing worlds as big as
you want.
- Only visible Elements have rendering buffers committed and just before
being used for render (you can setup how many elements are to be kept in
memory).
- Tweaking the A,B,C,D,E factors enables different policies (speed vs
memory).
Adaptive rendering:
- You can choose the LOD count of the heightmap.
- A quadtree routine determines which LOD level to use for the rendering of
each part of the terrain.
- The LOD is then hardware interpolated per vertex.
- The tiles LOD always match their neighbours at the edges to avoid cracks
(no need to fill holes later, and its still progressive LOD).
- You can of course set the Maximum Screen Error for the surface rendering.
Clipping:
- Quad-Tree parsing for clipping and rendering.
- Fragment rendering of tiles for Frustum clipping, to avoid rendering a
whole tile when only a small subset is visible.
Memory:
- 4bytes per height of the map.
- Additional vertex buffers of 4*C*D*E*E bytes (for each LOD, with E, then
E/2, E/4, and so on).
About speed, on a GeForce 6800, this is 2.2 times faster than rendering
using the highest level with the same clipping.
About the pictures:
The top one is from the camera used for the terrain rendering, the bottom
one is an external view of the terrain being rendered from the top cameras
point of view.
- Each box represents a tile (the bigger the tile is, the lower the LOD).
- For the bottom picture, the shade from black to white represents the LOD
fraction between two levels.
- You can see that fragments of tiles are rendered (instead of the whole
one) on the borders of the frustum to save some rendering.
- The little picture at the bottom left demonstrates what happens when
therere two tiles of a different LOD stick together. The LOD fraction is
clipped to 0 (for a higher level) or 1 (for a lower level) at the edge to
make the junction perfect.
I Hope you enjoy, you can email me if you have questions.
I may write an article about the technique and release the demo in the
future.
(L) [2004/12/23] [DavidGrassi] [viperg@gmail.com]
This is 4 screenshots from the game Black Sky, which is currently
under development. Black Sky is a top-down 2d space game, that will be
when done, a full blown action RPG. Right now it's being developed by
me and only me, but people are starting to sign up on our forums and
provide feedback.
The purpose of this project is for me to reach a life long goal of
making a computer game, as well as making a great game in the sci-fi
genre that seems to be suffering. I hope to re-kindle the magic that
Star Control 2 and the Star Flight series had. If all else fails, at
least I sure am learning alot!
Currently I'm using windows for key inputs, and OpenGL for my graphics
API. It will run on any computer just about featuring a compatible
OpenGL card.
Here are some features:
- Fully functional particle engine.
Multi-texturing, with parallax textures and objects.
Partially complete 2d physics engine.
First of it's kind to be able to simultaniously track 2 targets, and
fire on them indepently.
Future Features:
- Dynamic event system, that can respond to ANY player input level,
allowing the player massive amounts of options.
Massive galaxy of life and aliens, the player will be able to make
relationships with these beings, or fight against them. The AI will be
integrated to this, your relationships and the other NPC's responses
will be extremly authentic and life like.
For the Official website of Black Sky, visit [LINK http://www.blackskygame.com]
(L) [2004/12/26] [JoseLucioGama] [slotman@uol.com.br]
First, let me introduce myself: My name is José Lucio Gama (a.k.a. SLotman)
I am one of the few graduated developers from Brazil in "game developing" -
I finished last year one of the first Brazilian courses to create
professional game developers, created by "Universidade Pontifica Catolica
of Rio de Janeiro (PUC-RJ)". As the final project for this course, I've
developed a "demo", entitled "Penguin Racer".
As the name suggests, the game is a racing game with Penguins - The story:
"Princess Marina decided to get married, and since she has now boyfriend,
she asked her father King Rico to help her finding a husband. The king then
created a series of tracks with obstacles, and the Penguin that can win all
the races will be entitled to the hand of Princess Marina, and also will
become the prince of Penguin Kingdom"
The game demo is currently available in Brazilian portuguese and in
English. You can see the web-page I made for the game, and download the
demo itself right here: [LINK http://www.icongames.com.br]. The site has more
pictures, a low resolution video of the demo and even an wallpaper =)
(please if you encounter any problem downloading the demo from the site,
use a brazilian proxy and everything should work fine)
The game uses openGL and the brazilian 3D engine [LINK http://www.fly3D.com.br Fly3D] on it's core, and thanks to that, the game does
not require a very powerfull computer: a CPU with 500mhz, 64mb of RAM and a
3D card (geforce 1 or higher) is enought to run the game.
I am now looking for publishers, and I have a team ready to finish this
game. I think the game can be finished in 5 or 6 months, having at the end
a total of 10 racing tracks in several locations (including underwater) -
plus the locked character of the princess, which are not in the demo, but
will be unlocked when the player wins the game, so he can race with her.
Also, the game contains no violence at all, so it can be played by all
kinds of audience, from children to grown ups without any problems.
Thanks in advanced,
Jose Lucio Gama
ICON Games
(L) [2004/12/29] [JeromeHugues] [jeromefabioc@hotmail.com]
Hi my name is Jerome Hugues. I am the Lead and only Programmer thus far for Naturallaw Studio. We started developing this game in march of 2004 and as you can see it has come a long way. The engine is done in house using D3D8 at is core.The game is a mixture of Resident Evil and Metroid. It is like Resident Evil meet Metroid. The game starts inside the ship, where you have to unconver what took place. The game is not two players. One of the characters is basically the AI. The Ai behaves in a very smart manner. I am using a Combination of Pathfinding and some sort of neural network, where the Ai learns from you and is mistakes. The game is half 3D and half 2D or should i say 2D in 3D. Right now we are in the beta testing mode to release a playable version to the public until then, post your comment and let me know what you think of the screen shot thus far.
(L) [2004/12/31] [ArasPranckevicius] [nearaz@gmail.com]
"Xplodar" is tiny demo of deformation simulation using Finite Element
Modeling (FEM) technique. Done for similarly-named university course.
Nothing fancy, just simulates some deforming model and lets you
interact with it.
Basically, it's direct implementation of pretty standard stuff:
tetrahedral elements, linear shape functions, Green's tensor, explicit
integration. All this and more is nicely described in papers like [LINK http://www.cs.berkeley.edu/b-cam/Papers/obrien-1999-GMA/ Graphical
Modeling and Animation of Brittle Fracture], some nice real-time
tailored optimizations are in [LINK http://graphics.csail.mit.edu/simulation/ Real-Time Simulation
of Deformation and Fracture of Stiff Materials].
You can see that the papers are on fracture, but Xplodar doesn't have
one. Oh well, the eternal reason named "lack of time" :)
The demo can be downloaded from [LINK http://nesnausk.org/nearaz/projXplodar.html]
Aras 'NeARAZ' Pranckevicius
(L) [2005/01/04] [PaulHolverda] [paulholverda@hotmail.com]
My first submittance to this great site, my engine has reach it's adult stage so
i should give it a go :)
This image is from a game called Java Is DooMeD 2, a thank you to one of the
greatest games of all time: DooM. My inspiration for a new engine came from my
former programming work on a game called javaisdoomed. which can be found here:
[LINK http://javaisdoomed.sourceforge.net]
Some technical stuff.
- The engine has both a hardware-( via JOGL ) and a software renderer, although
the latter isn't
touched for months.
The Compiler takes a .map file( for now it is just Q3 maps, but with some
modification, it can
also be DooM III, Wolfenstein etc.etc. map )
Brushes are created from the raw map file, along with surface properties for
each surface
With this brushes a BSP tree is created, which main purpose is collision detection.
Surfaces never seen in the final, compiled level are automatically discarded-
With the remaining surfaces a portal-based rendering system is build, the
portals are placed by the level designers, which give great flexibilty to the
rendering pipeline.
After all this is done, lightmaps are created for each surface. And since each
surface can have
it's own properties, the detail of the lightmaps can also be adjusted.
The engine and compiler are totally written in JAVA, hence the name Java is
Doomed;)
Basic physic are applied to every item in the level(gravity, water, flying)
furthermore, there is
collision detection and response( sliding along walls!! ).
Future things of expansion are, adding an outdoor 'renderer' as well, since the
engine is portal based it could be achievable. And of course adding realtime
lighting.
Cheers Paul
(L) [2005/01/05] [JaccoBikker] [jacco.bikker@overloaded.com]
These are some images from my latest (yet unnamed) ray tracer. Everyone has
seen the bunny a thousand times now so I'm throwing in a real time demo as
well. :-) As you can see, so far I have been focussing on raw performance.
The ray tracer now fully implements Ingo Wald's packet tracing: Whenever
possible, four rays are cast simultaneously and traversed through a kd-tree.
By using packets, the ray tracer becomes very suitable for vectorization
using sse/sse2 instructions. Despite some overhead this approach doubles the
speed of a regular raytracer.
About the images: The top left image shows the famous Stanford Bunny model,
69k triangles. There are two (dynamic) light sources in this scene, and the
animation is rendered at 512x384 pixels. On my 1.7Ghz Pentium-M laptop this
runs at about 5 frames per second. To the right of this image a dump of the
matching kd-tree is shown.
The two lower images show the Happy Buddha model and the matching kd-tree,
which consists of no less than 1089k triangles. This model renders slightly
slower; on my system it runs at about 4 frames per second.
This brings up a very interesting characteristic of ray tracing: The
technology scales very well. Switching from 69k to 1089k triangles only
means that some extra levels are added to the kd-tree; the speed decrease is
therefore not linear at all. Besides that, ray tracing performance scales
virtually linearly with processing power and the number of available
processors. This means that, given a sufficiently complex scene, it's
possible to outperform high-end graphics cards using commodity hardware.
Also interesting is the fact that the ray tracing algorithm is very simple.
750 lines of code get me 'z-buffering' with virtually unlimited accuracy,
visibility determination, self-shadowing, recursive reflections and
refractions, hard and / or soft shadows, per-pixel lighting, HDR effects and
so on.
I'm currently working with Thierry Berger-Perrin to produce a more
interesting demo, perhaps similar to the famous RealStorm benchmark. In the
meantime, you can download the [LINK http://www.flipcode.com/files/demos/bunny.zip bunny demo] (3.8MB).
Greets
Jacco Bikker
(L) [2005/01/07] [MaciejMatyka] [maq@panoramix.ift.uni.wroc.pl]
The PSB (Pressure Soft Body) Model has been developed and published first on the SIGRAD conference in Umea (Sweden), and has been described in details in following paper:
Matyka, M. and Ollila, M. "A pressure model for soft body simulation", Proc. of Sigrad, UMEA, November 2003
So far I am back in Poland and found time to make some improvements in the model. Pictures I am showing there are taken directly from my article:
Matyka, M. "Practical Animation of Soft Bodies for Game Development. The PSB Model.", Game Programming Gems 5 (available in March 2005)
The main reason for developming the PSB model was to create fast and flexible soft body model which allow to simulate deformable bodies at interactive rates (for purposes of some medical/virtual reality/games applications.
The main idea behind the model is to incorporate one (!) additional force, into simple cloth-dynamics engine. This force is based on difference of pressure between inside and outside of the body. For details and physics background behind the model please read those two articles, first of them is available on my web site:
[LINK http://panoramix.ift.uni.wroc.pl/~maq/eng/]
You can also find here some additional materials on my Soft Body model (i.e. Soft Body 3.0 program which is a straighforward implementation of the PSB model). The source code is not available, but technique is quite easy to follow and implement. The source code will be available in March 2005, when Game Programming Gems 5 will be finished. As a bonus, please take a look at new results of my MSc thesis which cover some CFD techniques interesting for graphics community (available on my home page).
(L) [2005/01/13] [NicolasCapens] [nicolas_capens@hotmail.com]
It's been quite a while since I showed anything new here so I'll tease you with this cryptic development image of my project; swShader. The reason why I have been this quiet lately is not because I'm phasing things out, on the contrary, I'm too busy turning it into a finished product!
The image is a screenshot of the WHQL DCT, which is a free Direct3D conformance test suite from Microsoft. I've only recently started using it, but I expect it will be quite useful to test swShader's capabilities. The screenshot shows the simplest test of all, which checks whether pixels are filled correctly by comparing it to the reference rasterizer. Even with this simple test I detected a bug in the swShader render core and several in my Direct3D interface implementation. The good news is that things -can- now become practically bugfree.
Ironically, I was able to run a popular game before being able to run DCT tests! Of course most of you would rather see a screenshot of the game, but I'm keeping that for later to have a bigger impact. And let's face it, passing DCT tests is a more important breakthrough. ;-) I'm also in close contact with a company willing to invest in it so I can finally make some good money with it. That's probably bad news for anyone who wished to work with it for free, but I promise I'll keep contributing to the community as much as I can!
If you haven't already, please visit my new homepage for some more information: [LINK http://sw-shader.sourceforge.net]
Best regards,
Nicolas "Nick" Capens
(L) [2005/01/15] [Jean-FrançoisDubé] [deks@sympatico.ca]
Here are some shots of my sky system. The clouds are 100% generated and
lighted on the GPU. I use 8 octaves Perlin noise, and the lighting is
integrated on the GPU using a ray-tracing technique that I described in
details in the upcoming Game Programming Gems 5 [LINK http://www.charlesriver.com/titles/gamegems5.html book] available in March
2005. The clouds are fully dynamic, I can control the speed of
deformation, the speed and direction of the wind, the density over the
entire sky, etc.
Heres some other shots and videos, all rendered on a GeForce6800:
- [LINK http://www3.sympatico.ca/deks/CloudsShot01.jpg]
[LINK http://www3.sympatico.ca/deks/CloudsShot02.jpg]
[LINK http://www3.sympatico.ca/deks/TestSky01.avi]
[LINK http://www3.sympatico.ca/deks/TestSky02.avi]
[LINK http://www3.sympatico.ca/deks/TestSky03.avi]
Thanks!
Jean-François Dubé
(L) [2005/01/18] [NicolasWeber] [nicolasweber@gmx.de]
This is a screenshot of a little program I wrote a while back to test
the shell method to render fur/grass. You can set various parameters at
runtime (number of shells, fur density and fur length) and there are two
different models to look at.
You can download the program along with complete sourcecode from
[LINK http://www.amnoid.de/iotdfur.zip].
Note that this IOTD was only posted to keep the IOTD queue full. Instead
of commenting this IOTD, comment this one: [LINK http://www.flipcode.com/cgi-bin/fcarticles.cgi?show=63738] (I posted it
before IOTD feedback was implemented). The latter is way more important
to me :-)
(L) [2005/01/20] [NickPlatts] [nick@invisiblecow.com]
These are a few images from projects which make use of my cross-platform (Flash/Java/J2ME so far) networking engine.
This was created to power multi-user Flash-based web games. Including 'twitch' style action games.
The bottom image shows a Mac web browser running one of the first tests which used the system : a simple action game which comes across a bit like a top down BF1942 and supports many players driving different types of vehicle around a scrolling map and shooting each other!
The other images show my J2ME chat room for mobile phones. This uses 90% of the same server code and the J2ME client library to provide a scrolling map which players can walk around with their friends and chat to each other.
To demonstrate the cross-platform nature of the system, the right-middle image shows a Flash port of the chat room running in Firefox. Users on mobile phones and the web can interact with each other and neither they nor the server know/care which client others are using.
Features :
- Bespoke Java server
Flash/Java/J2ME client libraries
Easily extensible
Robust client-server protocol
Both client and server-side movement prediction
Supports scripted entities
(L) [2005/01/21] [IanSnyder] [ian@naixela.com]
Red: Space Trucker was developed using the OpenGL, OpenAL, and ogg vorbis
libraries in C/C++.
Our game is designed to run on pretty much any computer with a graphics
card that supports OpenGL 1.1.
Red is all in 3d (except the backgrounds) with a fixed top-down view. We
make heavy use of particle systems to add a variety of effects to the
game, as well as randomly generating the levels as you play, which allows
for an endless number of levels or playtime. All the rendering is done
about as fast as can be managed under opengl 1.1, mostly sorting by state
and draw order combined with display lists. For most computers, the
limiting factor will be fill rate, due to the particle systems and
blending done on some models. The game will try to dynamically adjust the
density and duration of these when framerate is suffering.
The backgrounds and planets were generated using combinations of perlin
noise and other functions. We can generate quite a variety of backdrops
and planets, and 99% of them look good enough for use in game. We decided
to generate the backdrops in advance because the time required to create
them on slower computers would probably be a bit long (10 seconds or so
per backdrop). It could easily be done by generating them after installing
the game, but we wanted to avoid introducing any delays between getting
the game and being able to play.
Thank you for your time and consideration!
Sincerely,
Ian Snyder
[LINK http://www.naixela.com]
(L) [2005/01/24] [IftimeVali] [iftime@gmail.com]
Here are some images from the first public release of my game
project. It is a side-scroller space shooter i'm developing for my
school exams.
The 3D models are vertex shaded and the background has parallax
scrolling for a realistic speed effect. There are health-bars for the
player and for the enemy and 6 weapons to choose from (plasma,
3way-plasma, fire, tesla, rocket and laser beam) and also an
old-school hiscore table (3 letter names).
I'm using OpenGL for the rendering, FMod for sound and DevIL for
textures/screenshots and my own particle engine that's easy to use and
modify.
A gamepad/joystick can also be used for playing and it's by far
better than a keyboard!
The game can be downloaded from: [LINK http://www.shoot.dap.ro/download.php www.shoot.dap.ro/download.php]
(L) [2005/01/26] [ThomasMølhave] [thomasm@daimi.au.dk]
I have just finished the construction of a ray tracer running almost
completely on the GPU of my GeForce GX 5650 with a NV3X GPU (That is, no
shader model 3.0). OpenGL along with RenderTexture[1] is used to
interface with the graphics card. Cg is used to control the GPU.
To make a ray tracer on the GPU it needs to fit into the computational
model used by the GPU. This can be done by mapping the algorithm to the
stream programming model. The mapping used was described and also
implemented by Timothy Purcell in his Ph.d. dissertation[2].
The ray tracer reads scenes in my own format, usually exported from 3D
Studio MAX using a custom exporter, and builds a uniform grid on the
CPU. The grid is then uploaded to the graphics card as textures along
with other geometry information and processing is handed over to the
graphics processor.
The GPU generate eye rays which are traversed through the grid until
they hit a triangle or leave the grid. When a triangle is hit, the hit
point is shaded according to material and normal parameters. To keep
track on how far each ray is in the pipeline, state vectors are kept for
each ray. The state vector, among other things, indicates whether the
ray is traversing the grid or is ray to be shaded of checked for
intersection with triangles.
The ray tracer was written in a span of two weeks and are therefore
simpler than it could have been, but it nevertheless demonstrates the
technique explained by Purcell. It would be simple to add levels of
recursion, producing a path tracer and it could also be extended with a
photon mapper[3].
It is also very slow compared to what the CPU would manage, this is
partly due to the lack of multi render targets on my GPU (causing me to
make _many_ context switches between texture render targets) and partly
due to the fact that no early-z culling technique is used. Speed was
never really achieved and the implementation should be looked as
something interesting to play with rather than something new (after all
I just implemented what was described in [2], which has been done
before) and exiting.
The document at [LINK http://www.moelhave.dk/index.php?site=projects www.moelhave.dk/index.php?site=projects] gives an
extensive overview of the implementation. For others thinking about
implementing the algorithm, it might prove useful (or a complete waste
of time, what do I know? :) )
\Thomas Mølhave ([LINK http://www.moelhave.dk])
[1] [LINK http://gpgpu.sourceforge.net/]
[2] [LINK http://graphics.stanford.edu/~tpurcell/]
[3] [LINK http://graphics.stanford.edu/papers/photongfx/]
(L) [2005/01/28] [BojanSernek] [bojan.sernek@tehnotek.si]
This screenshot represents a technique I came up with to perform high
dynamic range rendering and spherical harmonics lighting on pixel shader 1.3
hardware. The high dynamic range rendering effect was done with help from P.
Debevec's paper on [LINK http://www.debevec.org/Research/HDRTM/ HDRTMs] and the
spherical harmonics lighting with help from R. Green's [LINK http://www.research.scea.com/gdc2003/spherical-harmonic-lighting.html paper].
Since both effects operate on a light probe, we've decided to combine them,
and the results look promising.
The spherical harmonics lighting has been done per-vertex with 2
radiosity iterations and is PCA compressed.
The HDR rendering is done by transforming the 16-bit per component light
probe into two 8-bit cube maps (retaining full precision). The geometry is
rendered with both cubemaps (just vertex transform and cubemap sample) and
the resulting render targets are then added together with the result from
the SH lighting, and the high 8-bit render target is bloomed (horizontally
and vertically). We intend to add support for a user defined rotated grid
for blooming.
The whole combination can be done on any PS 1.3 compatible hardware
(we've done it on a GeForce4 4200).
More interesting screenshots:
- [LINK http://freeweb.siol.net/baadc0de/fdri5.jpg]
[LINK http://freeweb.siol.net/baadc0de/fdri7-1.jpg]
[LINK http://freeweb.siol.net/baadc0de/fdri7-2.jpg]
[LINK http://freeweb.siol.net/baadc0de/fdri7-3.jpg]
[LINK http://freeweb.siol.net/baadc0de/fdri7-4.jpg]
This and more will be part of my first commercial 3d/game engine.
There's also more demos there (visit [LINK http://www.narniax.com] and see for
yourself). Of course the real engine is not done on the directx framework,
like most of the samples found on the site )
Thanks, Bojan Sernek.
(L) [2005/01/31] [WillMcGugan] [will@willmcgugan.com]
After Chess Commander ([LINK http://www.chesscommander.com]), which took me 2 years to develop, I wanted to work on a game that could be completed within a year with just spare-time work. The game idea I settled on is inspired by an old Spectrum game called A Whole New Ball Game by Pete Cooke. Its been authentically remade a few times, but as far as I know the idea hasnt been taken any further something very rare in computer games!
Its a beautifully simple idea for a game, IMHO. You have a little ball on the screen that can move left, right, up or down. You cant alter the balls direction directly, but you can drop angled mirrors in the balls path to deflect it by 90 degrees. The object of the game is to collect all the energy pills on the screen by colliding a ball with them. There are a variety of tile types (its completely grid based) that have different effects on the ball, and must be navigated to get to all the pills on a level and complete the game.
Ping Ball was created with SDL, which is a very nice API I highly recommend it. I didnt use SDLs blitters to do the rendering since I already had a library of blitting routines I wanted to use. The sprites are run-length encoded (RLE), so my blitters ignore transparent parts of images and can distinguish between translucent and opaque pixels, which is a great optimisation since most pixels in a sprite are opaque and the image data can be simply copied. SDL does support RLE surfaces, but I like the extra control that doing it from scratch gives me, and I wanted to use additive sprites which I dont think SDL supports. The sprite engine supports 32 bit alpha channel images and 8 bit alpha images which I use for text and glow effects.
The sprites were created with POVRay ([LINK http://www.povray.org]) and Moray ([LINK http://www.stmuc.com/moray/]). Im not very adept at using 3D editors, but I was familiar with these tools from years ago. POVRay outputs 32bit alpha channel PNGs - which very conveniently is exactly the format needed for my sprite engine. Im no artist, but the sprites turned out well enough since they are quite small (just 20x20 pixels) and mostly composed of primitives! And being so small I can afford a large number of frames of animation, around 50 per second. Any of the images not rendered by myself came from a royalty free stock image site ([LINK http://www.istockphoto.com]). The sound effects I got from Sounddogs ([LINK http://www.sounddogs.com]), and the music from various royalty free music sites. In total I spend around £300 for resources.
I also created a level editor ([LINK http://www.pingball.com/editor.htm]) in order to produce the 30 levels in the game. Its remarkably simple and came together in a single weekend. I polished it a bit in order to bundle it with the full version of the game, so players can create and distribute their own levels. The level editor was build with wxWidgets ([LINK http://www.wxwidgets.com]).
I kept a rudimentary blog for a while that shows progress in the game from the first screenshot, it is still available at [LINK http://www.pingball.com/blog.htm]. The shareware version of the game can be downloaded from [LINK http://www.pingball.com/]. It doesnt have any trial period because I think it puts people off if they are just downloading an advert. There are a few nag screens though, but I hope even these are entertaining!
(L) [2005/02/03] [MalDuffin] [mal@candointeractive.com]
These are screenshots from an app I'm currently working on. It is aimed
at courses who are teaching 3D modelling to new students, especially
creative ( non-techie ) students.
The main goal of the app is to allow students to learn basic 3D
modelling skills, and to be able to easily export their environments
into a game-style app. The other aim was to support as many different
3D modelling packages as possible.
The solution has a number of unique features...
- The user levels can be played ( and peer reviewed ) online, via a
single web link
The engine uses Shockwave 3D, and Havok physics, to create a realistic
gaming environment
The physical drive model is similar to a number of car racing games
currently online
The game logic is set up entirely within the 3D modelling application
A simple export process ensures ease of use
Student levels can be linked to each other online, by naming the
object as a URL
The top 5 screenhots show the tech level that ships with the app, and
that you can edit.
The next three show a level created by a fellow Shockwave 3D artist and
good friend, Psychic Parrot, in under an hour.
The last two screenshots show some of the new features I've been adding
to the engine, such as particle effects and driving models with large
wheels.
Some other non-visual features are that the app's interface ( title
screen, music ) can all be quickly customised simply by placing the
files beside the app ( either the .EXE, or if online, beside the .HTM
file ). A .SWF flash file can even be used to create an interactive
front end for the game.
One of the non-obvious, but really difficult to get going, features of
the app is the automatic support for various 3D modelling packages.
Most of them export to Shockwave 3D with little quirks, which I had to
discover and write code to detect the app. Then, depending on the app,
the co-ordinate system might have to be transformed, de-crypt
hierarchies, or normals of models might have to be inverted etc. It
wasn't a lot of fun, but it was very satisfying to get it working!
If you have basic 3D modelling skills, and would like to try to create
your own level, you can get more information and download the
pre-release version of the application for free at
[LINK http://www.candointeractive.com/gamedesign/car]. The site also contains
a forum for feedback or posting your levels etc.
Feel free to send this link to your 3D artist friends and colleagues for
them to try out!
Mal Duffin
CanDo Interactive
(L) [2005/02/04] [DavidRosen] [david20321@gmail.com]
These are two screenshots from my new mac combat game [LINK http://www.wolfire.com/lugaru.html Lugaru]. I programmed the engine using
C++ in Codewarrior 8 for Mac, and I used OpenGL for graphics and FMOD
for sound and music. I am working on a PC version, but for now the Mac
demo is up at [LINK http://www.wolfiles.com/Lugaru.sit].
I could not use new hardware technology such as pixel and vertex
shaders because when I was writing the engine they did not exist for
Mac yet, but I did use some interesting graphics techniques:
A) Full and partial ragdoll impacts
I know that ragdoll physics are becoming just another checklist
feature in modern games, but Lugaru uses them in an unusual way.
Whenever a character is knocked off his feet he blends into a
physics-based fall, and takes damage based on how he lands. I.e. if
you kick an enemy into a snow drift, he takes much less damage than if
you throw him and he smashes his head on the corner of a stone block.
Characters can recover seamlessly from physics-based falls, even while
in the air.
B) Dynamic blood effects
If a character is hit in the head exceptionally hard and loses some
teeth, then blood will drip from his mouth down his body, and stay
there for the rest of the level. For example,
[LINK http://wolfire.com/Blood.jpg here] the main character has been clawed
in the face and stomach, and the blood has dripped down to other
areas. Also blood spreads using a changing alpha mask cutoff, allowing
it to expand in an organic way rather than as a uniformly-scaling
decal.
C) Transparent fog
I have a skybox of pre-rendered distant terrain, and the local terrain
becomes more transparent as it approaches the far clipping plain. This
makes the real-time terrain blend into the skybox, allowing smooth
gameplay without decreasing the apparent view distance too
significantly.
In addition, the context-sensitive combat system is unlike any other
game that I have seen. If you press attack while running you use your
momentum to perform a powerful spin kick, and then if the opponent
crouches under your kick and stands up, he will catch your leg and
kick you away.
Check out the Lugaru gameplay movies and free mac demo at
[LINK http://www.wolfire.com/lugaru.html]
(L) [2005/02/18] [PeterHoneder] [peter.honeder@hlw.co.at]
This is a screenshot of a game we are developing, currently called Buggy Speed
Championship 2005. The game uses our game engine called the [LINK http://engine.hlw.co.at Gryps Engine]
and is a racing game
designed to be as addictive as possible.
Basically you have to race around the track through the yellow goals in the
right order to complete a lap. One race consists only of a single lap which sets
a racing cycle to typical 50-70 seconds. Our testers had already a lot of fun
playing the game even though it is not yet finished.
Technically all races are recorded either online (within a highscore server +
database) or offline (e.g. if you do not have internet connection) and can be
either used as ghostdriver or be replayed again at any time. Using other players
as ghostdriver is very important for gameplay to optimize your line on the
track. One of those replays will in the end be uncompressed at around 20 kB and
stores everything necessary to produce exactly the same result as during the
original race. The replay data primarily consists of keyframes of the car parts
as well as values for steering position, when the goals have been hit and which
gear was active.
The physics is done using the open source dynamics engine [LINK http://ode.org ODE] and our own collision library. We have fully integrated ODE
into our engine to be very efficient to use and together with our collision
library it runs very, very stable and fast. We currently use the quickstep
algorithm of ODE for solving the physics. All obstacles within the game (like
the fences in the screenshots above) can be realistically hit and moved around.
We use a well-tuned autodisable to make sure even hundreds of objects do not
cause performance hits. Sounds for colliding against obstacles or when drifting
or blocking the wheels are generated proportionally to physics values (e.g.
during contact generation with obstacles or by taking the sideward velocities of
the wheels).
Our physical driving model is already quite complex, we use 4 sphere wheels
which actually slide across the ground and are mounted to a body box. Previously
we had sphere wheels on hinge joints connected to the body which rotated on the
ground like real wheels do, but this was quite unstable at low framerates and
high buggy speeds (e.g. 30 fps and 130 km/h). Having sliding wheels makes it
also very good to define all kinds of friction in different directions (e.g.
side friction is different than forward friction) and tune everything very easy
and stable. All the buggy configuration is of course stored in xml configuration
files to make it easy to extend and modify during testing.
We do not record physics within replays due to memory limitations when uploading
such a replay to the highscoreserver but instead simulate the physics again with
the replayed buggy moving around the map, which works realistic enough for
nearly all races (our testers have not noticed the difference yet :-) ).
Currently we have implemented a semi-automatic gear version of our buggy which
allows the player to override gears on-demand.
All models where done with 3DS MAX and have directly been exported with the
export plugin of our engine. We done load the models and the level description
files with our editor framework to e.g. set all the obstacles and the goals and
optimize the meshes (vertex cache optimization and triangle stripping as well as
seperating large meshes for better frustum culling). You can see the level
editor in the screenshot above. All the work is done with in-game graphics
quality and some extra debugging information.
For debugging the driving model we have an overlay gui which shows the forces
and velocities of each wheel which makes it very comfortable for testing the
breaks, acceleration, stability in curves and everything related. The screenshot
above shows this overlay in the second image from top on the left side. In this
case the left front wheel had no ground contact which is shown with the red
rectangle.
For debugging the engine and other buggy related stuff we use the debugshader
framework of the engine. This framework can visualize any interesting
information in-game and in real-time. E.g. you could render all objects colored
in a way reflecting your material assignments or you could render objects with
different color depending on texture stretch (which is very important for
artists to achive good quality) or you could render everything colored
corresponding to batch size, material count,... This feature is so versatile for
debugging and is directly supported with our engine for any application using
the engine. The screenshot to the top right shows this feature. There you can
see the buggy and the shadow volume in per-material color mode and wireframe.
One of the graphical features is motion blur which is done blending different
textures of the last screens together with the current screen to create blurred
images (on the screenshot this is the image in the bottom right corner). The
images which are used for blending are created using a 256x256 texture and an
additional render to texture pass for each frame (which is really fast). We can
blend any number of motion blur frames together but a number of 4 produces the
best quality.
Sound and music is currently done using FMOD or alternatively OpenAL and ffmpeg.
The game currently runs on Windows, Linux and Mac.
(L) [2005/02/20] [MichaelPiepgras] [contact@realstorm.de]
This picture shows the latest version of the RealStorm Realtime Raytracing
engine. Actually we are working on the RealStorm Global Illumination Bench
2005, which should be released in summer 2005.
The house part shows the actual engine at 640x360 (16:9) with a house scene
created with CSG objects. It uses 8 volume lightsources. (You may notice the
soft shadows). (The actual framerate of 6.52 fps was taken on my Athlon64
3400+, 512MB-333Mhz.)
The second part (bottom) of the picture shows our actual version of the
realtime global illumination renderer. We have chosen a Cornell Box
variation which is with global illumination on the left and without global
illumination on the right.
In all scenes any object and any lightsource is movable/resizeable without
losing performance (no precalculated tables, any table is calculated per
frame to keep it realtime and flexible). The engine actually uses Monte
Carlo raytracing to do the global illumination parts. We hope to get a
little more performance soon -)
If you like, you may check [LINK http://www.realstorm.com] where we just released a
15MB movie preview, of what will be in the benchmark.
Greetings,
Michael Piepgras (TTS)
Engine Programming
[LINK http://www.realstorm.com www.realstorm.com]
(L) [2005/02/21] [MorganMcGuire] [matrix@graphics3d.com]
Several objects rendered using the method from [LINK http://graphics.cs.brown.edu/games/FeatureEdges/index.html
Hardware Determined Edge Features] by Morgan McGuire and John F. Hughes,
presented at NPAR 2004.
Using a new data structure, we can find edge features-- silhouettes, contour
edges, creases, ridges, and boundaries-- entirely on the GPU, and then draw
them with brush stroke textures. The textures are reasonably coherent even
under animation, creating the appearance of continuous strokes. The method can
be extended to shadows, suggestive contours, and matrix-skinned models so that
all rendering tasks are offloaded from the CPU.
The large NPR charcoal teapot and smaller figures were all rendered using
variations on the same shader and zero CPU cycles. For the teapot, the shader
finds the silhouette edges and strokes them in a charcoal style with thick
lines. Creases and other features are detected and stroked with thin lines.
The small mechanical part (left) has hidden contours detected and rendered as
dashed lines. The realistic furry bunny (2nd from left) is rendered with
Lengyel's Shell & Fin method. Fins are placed at contour edges by the shader
and shells are also extruded on the GPU. For the torus knot, the shadow volume
contours are detected on the GPU and extruded. The cartoon bunny has internal
ridges rendered with one style and external contours rendered with another. As
in other cases, all edge features are detected on the GPU.
Morgan McGuire
(L) [2005/02/22] [SamuelHornus] [Samuel.Hornus@inria.fr]
Hi everyone,
This image demonstrates ZP+ which, as the name implies ;-), improves on Z-pass, the good-old method for real-time stencil shadows.
As you all know, I'm sure, Z-pass fails when the near rectangle (the visible part of the near plane) is (partly) shadowed, as holes are created on the near plane that locally break the counting argument that makes stencil shadows work.
This new method, dubbed ZP+ for "Z-Pass Plus", simply corrects this defect of Z-pass. Using a skewed frustum with the light source as apex, we are able to fill these holes exactly. The positioning of this frustum is depicted on the bottom-right figure.
As a result, we obtain a robust version of the Z-pass method, that can take advantage of triangle-strips and VBO since the mesh need not be cut into a light-cap and a dark-cap anymore. Thus, we get frame-rates faster than Z-fail in most cases. And stencil shadows become more applicable to large meshes.
There are some subtle problems to deal with when implementing ZP+ but they are all adressed in details in our [LINK http://artis.inrialpes.fr/Publications/2005/HHLH05/ paper].
If you are interested, please take a look at it!
If you implement the method into your application, I'd be happy to hear from you. Thanks for reading!
Samuel Hornus
(L) [2005/02/24] [GerdGroßmann] [gerd.grossmann@s1999.tu-chemnitz.de]
These are two images of my diploma-thesis project. In advance: i ask for your
pardon concerning my poor english.
On the left you can see a triangular mesh with many defects, such as holes,
complex edges/vertices and intersections. The right picture shows the same mesh
after a mesh repair process. Since this is hot topic nowadays and there are some
publications out there: what's so special about this one?
The whole mesh repair process is based on the surface of the object, which leads
to some important advances in comparsion to volumetric methods. First of all the
points of the pointcloud upon which the triangle mesh is constructed are kept -
while volumetric methods tend to double, triple the point count. Second, the
quality of the repaired mesh is often higher. And third many problems related to
thin meshes are avoided - volumetric methods need a high sampling rate to
process such meshes.
The downside of the algoritm is that it's significantly slower (ca. 5 min. for a
mesh with 200000 triangles), consumes more memory (90 MB for a mesh with 200000
triangles) and is more difficult to implement.
The repair process is based on the method propossed by [LINK http://theorie3.physik.uni-erlangen.de/~mcwagner/SimAnnIJSM.ps.gz M. Wagner] combined
with the work of [LINK http://portal.acm.org/ft_gateway.cfm?id=882397&type=pdf&coll=GUIDE&dl=GUIDE&CFID=38097966&CFTOKEN=72845362 P. Liepa].
Even though somewhat modified to avoid complex vertices in the output, and other
heuristics in the pre-/postprocessing steps to get a better shaped output mesh.
The whole system is implemented upon the OpenMesh library, which was extended
with a new mesh kernel, that can handle non-manifold meshes. The source and the
program are going to be public when i finished my thesis.
Greets,
Gerd Großmann
(L) [2005/02/25] [LynnDuke] [soularsouls@yahoo.com]
This is a screenshot of XVP skinning and lighting 160 skin meshes in hardware via a 2.0 CG vertex shader. Here are the specs:
1. Each mesh has 36 bones.
2. Each mesh has a little over 2100 faces
3. No more that 5 bone influences per vertex
4. Each mesh is playing its own 45 second skeletal animation (performed by CPU)
5. Each mesh is lit, per-vertex, by a blue point light.
Right now the screenshot shows 30 FPS at 160 meshes, but I had to put it in windowed mode to snap the screenshot (ALT-PRINTSCREEN). The code can actually get closer to 250 skin meshes on the screen before dropping to the 30 FPS mark. THAT'S what I wanted to take a screen shot of, but this will have to do.
Actually, I'd be very interested in knowing performance stats on other people's hardware. If you have the time, you can download the demo along with a whole slew of other XVP demos at [LINK http://www.soularsouls.com/demos.html]. There are other demos there like cel shading, per-pixel lighting, cubic environment mapping, animation blending, etc...
Thanks for the viewing time!!
(L) [2005/02/26] [AdamBryant] [adamb@cyberone.com.au]
GLoadX is a 3DS model viewer that was developed over several months as the core
of my CV (my demo). It is comprised of two identical windows that
simultaneously render in OpenGL and DirectX. It should give artists a good idea
of what their models will look like when rendered in-game without needing to
export to and load from an arbitrary format.
You can download GLoadX at [LINK http://www.skullbonez.com/gloadx/downloads.htm]
Features:
- Handles many of the intricacies in the 3DS model format resulting in a
high success rate loading models.
Supports keyframe animation.
Supports smoothing groups.
Simultaneously displays models in OpenGL and DirectX.
Simple uncluttered resizable user interface.
Supports multisampling (for cards that support it).
Support single pass texturing with BMP, JPEG and TGA images.
Menu options to change light mode, primitive, show normal vectors,
display model and loading information.
Performs many optimisations during load time (removing duplicate
vertices, animation nodes and materials, removing superfluous keys
from the keyframe hierarchy, splitting complex facelists etc).
Can render with or with out keyframes to support 3DS models without
animation that contain key frames but do not use them to locate
model elements (these models will look wrong in 3D Studio Max but
correct in Bryce).
I have put a lot of work into trying get GLoadX models to match 3D Studio Max.
I've tested 354 models and about 95% of these are correct. Of the 5% of models
that don't match, most of the problems are minor^ eg smoothing group errors or
material differences. I will be investigating these problems further over the
next few weeks.
Beyond that, I am planning on adding support for bump-mapped models (assuming I
can find any) and adding stencil shadow volumes.
I am keen to hear any feedback, particularly from those that have battled with
the insides of the 3ds format before. As this is also my 'demo' I would also
welcome any comments regarding its appropriateness for the task (keep in mind I
am aiming for an entry level programming position).
Adam Bryant
(L) [2005/02/28] [Sam] [jewasaurus@yahoo.com]
This is a screenshot from the game I'm programming for PC using MSVC++, using OpenGL and DirectX.
As I am primarily responsible for the engine, I will talk about that. I'm particularly interested in the use of fractals and random seeds to create compelling worlds. The engine consists of two main parts: the city and the character.
The city is represented as an mxn array of quadtrees that stores objects, textures and neighbors. Each quadtree is made of subtrees that store smaller levels of detail from city blocks, to buildings, to sidewalk tiles. The idea was to write a script to do a fractalized-"Conway's Game of Life" thing to create a believable, randomly-generated city. I'm looking into Python and Lua to help me do that.
Like the city, the character is also built on fractals. The GameCharacter class supports stats like health and strength and manages control and animation. It is built on top of a Stickman class that stores the appearance and animation. The Animation class stores various poses and interpolates to fill in the blanks using either slow-in or slow-out animation. There's also a tool that allows animators to create these files. The animation pose system is built on fractals: the Body class contains 5 Limbs, (torso being a Limb) and each Limb contians 3 Joints. The plan was to apply this idea to animate hands so that each hand could be represented as an instance of the Body class.
(L) [2005/03/02] [TravisBaldree] [travis@buildingworlds.com]
Fate is an action-rpg I have been working on that incorporates some of the highly randomized 'bite-sized' play of classic games like Telengard and Hack with the streamlined UI and improvements of Diablo and other more recent RPGs.
Unlike Diablo, it is fully 3D from an isometric perspective, and allows you to 'look around' walls.
The entire gameworld is randomly generated, except for the town, which was prebuilt and lit in 3dsMax.
Quests, items, and dungeon geometry are all randomly created based upon a root number seed which is different for each game created. Each level type has a template, which defines rules for the generation of the level itself (deadendedness, sparseness, room size ranges, pit ranges, etc. ) and prop placement ( torches, tables, boxes, chests, etc. ). Templates are distributed randomly throughout the depth of the dungeon.
Pathfinding is a modified A*, and the passability map is generated based upon a collision pass, so that it works on any arbitrary geometry set.
Difficulty automatically scales based upon depth, so you can in theory, play forever, continually going deeper and deeper, while monsters automatically 'level up' to meet the challenge.
Monsters can wield and wear the same items you can, which keeps them from feeling too cookie cutter - they can also have unique and superunique items, the same spells you can cast, etc.
I wanted to make an action RPG that I could sit down and play for 15 minutes at a time, and then come back to a week later without having to pick up any threads - but I still wanted it to have the depth of bigger, retail-store RPGs. The random generation allows me to build and test a vast quantity of content, and as long as I keep on top of the rules system, I can make a big game with a lot less time. Quests are randomly generated as well, to give the game some 'focus' - although they are obviously not character driven quests.
Development started in October of 2004, and I should be shipping in roughly 2 months. Overall development time will have been about 5 months total, not counting QA.
I use projective texture shadowing for all objects and creatures in the game, combined with a 'glow' pass for illuminated objects that is factored into the shadow pass. Characters are skinned or tweened, depending upon the demands of their monster type, and can have arbitrary attachments and particles/glow systems.
Other gameplay features include a pet ( cat or dog ) that fights with you and has its own inventory, and can take your loot back to town. The pet can be transformed into more powerful monsters for varying durations by feeding it fish that you can catch in fishing holes.
This uses a save-anywhere system, so you can come back and start playing right where you left off. If you die, Fate approaches you and provides you with 3 choices to resurrect your character...
This is probably going to sell for 19.95 online as a downloadable game
The website is at [LINK http://www.fatethegame.com] if you'd like to check it out...
thanks!
Travis Baldree
(L) [2005/03/04] [KevinBruner] [kbruner@telltalegames.com]
Here's a screen shot from Telltale's first game! It's a simple "casual" game
that tries to emulate TV style poker.
Most of the technical effort was put into getting the 1800+ lines of dialog
and animation into the game while keeping the download size small (20 megs).
Though it doesn't have a physics engine, a terrain renderer or any fancy
rendering, we think it's a great simulation of a bunch of friends sitting
around playing poker, and a great example of what a bringing good characters
to a "casual" game can do.
Technically the game uses a number of Open Source projects. The audio is
OggVorbis compressed. The data is compressed using Zlib and the game logic
and AI is scripted using Lua. There a very nice integrated Lua debugger
built into the engine that uses Scintilla. The debug build also use Paul
Nettles excellent memory manager (available right here on flipcode!). The
game was created in about 12 weeks by 7 people, though many old friends
stopped by to lend a hand from time to time!
Telltale itself is a bunch of ex-LucasArts people who have decided to go the
"independent developer" route. Most of us worked on the ill-fated Sam & Max
2 project. We're trying to make smaller games that are focused on characters
and story, so hopefully you can look forward to much more than "Texas
Hold'em" from us in the future!
Download the free demo at [LINK http://www.telltalegames.com www.telltalegames.com]!
(L) [2005/03/08] [nDAWInteractive] [edstudios@hotmail.com]
The ShaderStudioMAX is a multipurpose IDE (Integrated Development Environment) for Shader-based 3D Applications, i.e. PC Games, Real time VR-Model visualization or Real time Image Post-Processing, etc.
With its fully support of Microsoft Direct3D(r) 9 graphics hardware, many amazing graphics effects can now be rendered at fairly high frame rate on mainstream desktop PCs. One main purpose of ShaderStudioMAX is to help PC game developers to write and refine their graphics effects in a convenient way.
The Visual C++ project export functionality of ShaderStudioMAX is a power utility to export the ShaderStudioMAX scene directly to a VC++ project. This makes the ShaderStudioMAX a convenient RAD tool for rapid games and graphics applications development.
This is the second release of the ShaderStudioMAX IDE software package. It is built using the latest Microsoft(r) DirectX 9.0c, hence supports Shader Model 3.0, Geometry Instancing, ATI's Pixel Shader 2.0b, 3Dc compressed normal texture format and GeForce FX Multi-Element Texture (MET).
* Note that the Microsoft(r) DirectX 9.0c runtime must be installed in order to run the ShaderStudioMAX DX9c Rebuild. You can download it from the DirectX official website:
[LINK http://www.microsoft.com/directx/]
Finally, we are very happy that more users can have a try to the powerful ShaderStudioMAX to learn and refine their graphics techniques. The revisions of ShaderStudioMAX will continue to upgrade, incorporating more leading technology functions. At this stage, the ShaderStudioMAX is treated as a freeware, and this website a non-commerical technology website. Anyone can go and download the latest revision from the download page.
The latest version can be downloaded from the official website:
[LINK http://www.ndawinteractive.com/shaderstudiomax/]
Regards,
nDAW,Interactive. 2005
(L) [2005/03/10] [Alex Babkin] [ababkinATgmailDOTcom]
[LINK mailto:ababkinATgmailDOTcom Alex Babkin]
Statement: This is a sailboat simulator, which is a model of how a sailboat would behave in real life in response to actions of the user controlling it and changing weather conditions. In addition, the "god mode controls" would be available that would allow a user to change the wind behavior. The simulation is set in an environment consisting of limited area of terrain with multiple water bodies in it (rivers, lakes, etc.) For enhanced realism, sky would be rendered above the setting and ripples on the water.
The project will involve completing the following subtasks: modeling the boat and the terrain; drawing and implementing a sky-cube; implementing reflections and procedurally generated bump-mapping for the water plane; physical simulation of floating body dynamics, interaction of cloth with the wind (sails and a flag); implementing a reasonable UI that will allow a user to control the boat with steering (rudders) and changing the orientation of the sail planes. Also it will allow to change viewing angles of the camera, to be able to observe the boat from all reasonable angles.
The uniqueness and how elaborate this project is, is what makes it interesting and challenging.
Goals:
All of the physical phenomena in the dynamics simulation should be visualized as physically plausible, at least to the "naked eye". (i.e. if the user will not analyze it too much) The environment should be made looking reasonably realistic, which will be achieved by using techniques that were described in the Statement paragraph. In general, the user should feel that the visual feedback of the simulator is natural and would resemble that of how a real sailboat would look in real life.
Technical outline:
Cloth physics simulation is based on the works of Xavier Provot 1995. In essence, it suggests using a network of springs to model a piece of cloth, updating each 'node' every time step by performing Euler integration of all the internal and external forces that act upon each node in the model.
Floating solid body physics is calculated straightforwardly using Euler integration on the standard physics formulas.
Terrain is a standard gray-scale image based heightmap mesh. For improved realism it is textured and lit.
Waterplane reflection effect is achieved through first rendering from underneath of the waterplane, and then appropriately texture-mapping the result onto the waterplane while performing the main rendering pass, procedurally perturbing the texture coordinates to create a ripple effect.
A standard skybox (textured 3d box around the camera) is used to create the sky and an illusion of 'infinite' environment.
The boat was modeled in an external 3d modeler and imported into the simulator through an *.obj importer.
A convenient UI for controlling the boat is the use of mouse and keyboard buttons and moving the mouse while holding down appropriate buttons to perform desired actions. A compass control will be used to show the current orientation of the camera relative to the orientation of the terrain.
Bibliography: "Deformation Constraints in a Mass-Spring Model to Describe Rigid Cloth Behavior", Xavier Provot, 1995
More screenshots:
[LINK http://www.geocities.com/ababkin/sailsim/sailsim.html]
(L) [2005/03/14] [XycsoscyX] [xycsoscyx@hotmail.com]
Here are, finally, some screens from my engine. The engine is still coming
along nicely, for a hobby project. The first three rows show off the mods
that I have put together for the engine. Yes, they are actually mods; they
are zip files in the MODS folder in the engines data path. The engine loads
the logic DLL from the mod (thanks to Joachim Bauch for his wonderful DLL
loader code, so that I can load DLL's from memory), then searched for all
data in the mod archive first, then the default data path after. It also
loads a config file for the mod to know what level to start at. The screens
of the mods have three pictures each, first showing normal rendering, then a
glare post process filter, then an ASCII text post process filter. The
engine can actually support many different post process filters, as I have
it implemented in a modular way, I can derive my post process interface
class, and add it to my screen list. As for the mods themselves, here is
some info:
- First, this shows off a simple shapes game I put together. Pickup
the shapes and shoot them in their corresponding homes.
Second, this shows off a maze game I put together. Follow the maze
to the end, and if you fall through a hole, you reappear back at the
beginning.
Third, this shows of a tile game I recreated. Click tiles to clear
out sections that have multiple touching tiles. More tiles cleared at once
means more points.
The last four pictures are to show off some higher quality pictures, through
Doom3 data. I have a Doom3 level format plug-in for the engine, so that I
can load Doom3 levels, including plug-ins for LWO, ASE, and MD5 models, so
that things can be loaded correctly in the level. Overall, performance is
decent, though I only have a Raedon9600, so it really lags at higher
resolutions. Also, the fours pics are glare, normal rendering, ASCII, and
depth of field, though you can't see the depth of field as well in this
smaller screen shot.
As for the engine, it uses deferred lighting, with support for diffuse and
specular bump mapping. I also support an array of post processing filters,
which is great since I also already have position information for each pixel
on the screen (thanks to deferred lighting), so that I can support things
like Depth of Field. Currently, I have a glare, depth of field, gamma
correction, sepia/grayscale toner, and ASCII conversion filters. I also
support dynamic shadow mapping, though I am working on a quick have for
static light mapping in real time. Basically, I want to render the shadow
maps for static lights when I load the level, without rendering dynamic
objects. Then I'll have static shadow maps that I can use through out the
level, they just won't include dynamic objects in the shadows, but I won't
have to render the shadow information in real time anymore, which will speed
things up considerably. Most of the engine is my own doing, though I do use
zlib for ZIP archive support, DevIL for image decoding, Audiere for audio
file decoding, and Newton for physics.
Lastly, I finally have a web site again, so I have the engine and mods
available for download.
[LINK http://www.hourglassdesign.net]
(L) [2005/03/16] [PacomeDanhiez] [pacome.danhiez@free.fr]
EaseWrapper library allows using DirectX 9.0 and OpenGL in a same way, with
a clean and easy-to-use interface.
The library is very easy to include in a project.
EaseWrapper fully supports :
- All the renderstates : matrices, texture stages, blending, alpha, zbuffer,
stencil, etc
Static and dynamic vertex-buffers, with an internal memory management
Index buffers with automatic face stripping
Window management, fullscreen / windowed / border configuration
Callbacks on system events : mouse, keyboard, etc
Shader programmation, with an unified interface for HLSL and Cg
Materials, textures and lights are encapsulated in efficient and
comprehensive classes
All these features are optimized for the API you choose.
You can switch between OpenGL and DirectX with a single flag, without
changing anything in the code.
Download here : [LINK http://www.ease-production.com]
And have fun !
(L) [2005/03/17] [VictorPalmer] [victor@strangebunny.com]
These are screenshots from an open-source fluid simulator I've been working on.
The simulator uses smoothed particle hydrodynamics to perform the fluid simulation, and then constructs an approximate isosurface by using a series of image-space filters. The entire thing runs on the graphics card and as such the demo requires floating point textures and pixel shader 2.0.
The demo and source can be downloaded at
[LINK http://www.strangebunny.com/techdemo_sph.php]
- Enjoy
Victor Palmer
(L) [2005/03/18] [IñigoQuilez] [iquilezles@hotmail.com]
Hi all!
Well, another raytracer. Something special on this one?? Not really, may be the ability to display big models. Up to 104 million models have been tested, running at several frames per second (with shadows) using 4 CPUs, in small windows :( . The raytracers works on Win32, Win64, Linux64 and MsDos 6.2/Vesa2.0 (32bit).
The image above is a render of a medium-small model (half million polys, from [LINK http://www.deespona.com www.deespona.com]). The ship moves at 0.6 fps on 1280x960 resolution, using a 3.4 Ghz Opteron. I hope I can reach two times that performance soon (still lot of work to do - ...do I need to say this?).
There is support for textures (only bilinear right know) and some rudimentary shaders, as the ocean shader shown on the screenshot. That one uses 2 rays (additional to the primary one) for shadow and reflection. The shader of the ship is wrong right now, but you can maybe see some shadows on it.
(L) [2005/03/20] [MikaelTillander] [mikael.tillander@akatora.se]
Here's a few shots of my one year old 2D game creator/editor, which I use to create mobile phone games with.
I've used it for 13 games this past year, including platform games and vertical and horizontal shmups.
I'm writing this because a version 2 of the editor package, and the engine for it, is being designed at the moment, and I'd like some suggestions and comments on parts of it.
As you can see in these shots, the editors were made before I knew exactly how to use the Layouts in Java. :)
Apart from what is shown in these shots, there is editors for creating maps, doing text boxes, for converting between different screen sizes and a general game properties editor.
The top picture is of the Object Editor. This is where you set the properties for all of the objects that should be in the game, objects like enemies, main bullets, enemy bullets, pickups etc.
Properties include object type, collision type, what image and animations to use, background collision types and gravity settings.
The new version of it will be a bit more complex than this and some parts of it will get their own editors.
The middle picture is of the Script Editor (scripts for object behaviour to be exact).
Here you design (or rather implement) the object movement and behaviour using a few predefined commands together with a value, 8-bit assembler syntax. :)
The last picture is of the Adder Editor. And here's where I need your help with the new version of it.
As it is now the engine can add (activate) objects into the world in three different ways:
- Chart Based: When the screen (camera) reaches the start-position of the object.
Time Based: When the elapsed game time matches that of the object-appearing time.
Event Based: If a object script or the camera script activates a event, objects appears at their start positions.
For each object to be added you specify what object, what behaviour script to use, the direction of the object and its position.
There is a fourth way an object can get activated and that is by another object (depending on what happens to the object, if it gets killed for instance).
But this is handled by the object editor.
So, my question for you all is, is there another way of adding objects into the world?
Something really clever that everyone else is using except for me?
Thanks!
(L) [2005/03/23] [FredrikMäkeläinen&OskarHolmstrand] [fredrik.makelainen@home.se]
Shades of Divinity was developed by two students at gsCEPT ([LINK http://www.gscept.com]) during a 30 week
half-time period. The project consisted of 3 separate parts each spanning
7.5 ECTS - planning, research and execution.
The goal was to test what can be accomplished in realtime graphics
utilizing the newest hardware and try to learn as much as possible in the process.
It's coded in c++ using D3D9 and HLSL for the shaders and some shaders makes use
of ps 3.0 because of their length and branching requirements.
The models and animation is done in Maya and a custom exporter was programmed to aquire the data.
Features:
- Smooth skinning
Per pixel lightning and normalmapping
Parallaxmapping
Shadowmapping
Projected lights
Environment reflections
Volumetric light and fog with shadows
shading parameters are sampled fromt textures to give the artist detailed control
Ambient lightning as in half-life 2 using an "ambient cube"
The morph affect all textures (no geometry morph)
Fog is generated using 3 octaves of 3d noise
The top 3 screenshots show the "slider based" morphing in progress and it affects the whole angel.
The 4:th screenshot shows lightbased morphing in progress, the angel is "good" where the red light hits her
and "evil" in the blue light.
The large screenshot show the volumetric lightning and fog with shadows cast through it.
Credits:
Programming, Fredrik Mäkeläinen
Graphics, Oskar Holmstrand
More info about the project, executable, video etc, can be found at [LINK http://www.oskarholmstrand.com/sod]
It currently only runs on nVidia 6x00 cards beacuse of ps 3.0 and depth texture requirements.
(L) [2005/03/25] [SebastianoMandalà] [nig@7th-sense.net]
Starting from the Willmott's original Face Cluster Radiosity theory
I developed my global illumination system. Even though the system works quite
well, it's still in a early stage. Actually I would do much more
research, if have the time. You can read a fast introduction on
this site:
[LINK http://www.7th-sense.net/blogger/radiosity/]
there you can find a gallery and an article with some technical
explanation. Thank you for your attention!
(L) [2005/03/29] [CarstenDachsbacher] [carsten@dachsbacher.de]
These screenshots show our 4k-intro released at the Breakpoint 2005 demoparty. The executable size (in fact it's a cabinet file which can be executed as batch file) is exactly 4096 bytes containing all code, graphics and music data. To get the intro running you need DirectX 9.0c (february release with D3DX included as a DLL).
Some technical stuff:
- The rendering is done using one vertex shader (computing lighting, colors and transformations) and 3 pixel shaders (ps2.0) for planets (with coloring and fake bump-mapping), atmospheres (empirical light scattering model) and planet rings (with shadows)
The planet textures are created using a modified subdivision fractal, the background nebula-like textures are generated using fractal methods.
The sound is generated using General Midi instruments from the gm.dls file (part of DirectX) and additional sound post-processing.
You can find it at: [LINK http://www.pouet.net/prod.php?which=16373]
(L) [2005/03/30] [LynnDuke] [lowelllynnduke@hotmail.com]
The development screenshot above is one of the tutorials we've been working on for X-VP's initial release on April 15th, 2005. It's a sampling of the different types of user interface elements that are supported from within X-VP's User Interface Framework. The user interface above shows the following control examples...
- Pushbuttons
Toggle buttons
Text Boxes (with left,right and center justifciation as well as word wrap, text cursor and keyboard input)
Progress Bars
Sliders
Movies
Sprites
Animated Sprites
All controls are 100% graphically customizable and the nice part is that X-VP handles are scaling issues for various screen resolutions. This means that you pick a screen resolution, and define all coordinates relative for that res. When the user changes resolution, your interface is adjusted appropriately.
Also, audio samples can be binded to various events like "over", "up", "down" for all controls. Controls can receive the focus by being clicked on with the mouse. Z ordering is supported not only between controls on the same interface, but between seperate interfaces as well.
Also, the user can derive from various objects to create their own custom controls and custom events for existing controls very easily.
This tutorial will be part of the 50 or so that accompany X-VP's beta release. If you're interested, the main site is at [LINK http://www.soularsouls.com www.soularsouls.com]. As a side note, we are looking for more beta testers to sign up and receive the initial version of the SDK. We're trying to build a good base of initial testers and compensate them with a free pre-release commercial license for their efforts. Then we'll release the SDK publicly.
Thanks for the viewing time!
(L) [2005/04/05] [MorganMcGuire] [morgan@cs.brown.edu]
Steep Parallax Mapping is a straightforward change to a pixel shader that
allows a game to render existing parallax maps with increased detail. The new
effects possible include 1-pass fur and grass, bumps with vertical edges, bump
self-shadowing, and a general correction to the texture-swim problems of
parallax mapping.
The left image shows a flat wall with all detail rendered via Steep Parallax
Map. The image is rendered at 1024x768 with 4x FSAA at 30fps on GeForce6800.
The right image shows fur rendered using the method at the same frame rate.
Details, images, and a discussion of similar methods recently proposed are
posted on our website,
[LINK http://graphics.cs.brown.edu/games/SteepParallax/index.html].
Morgan McGuire and Max McGuire ([LINK http://www.ironlore.com/ Iron Lore Entertainment])
(L) [2005/04/11] [LennoxAntoine] [lxnyce@gmail.com]
On Wednesday, April 6th, I found out about [LINK http://maps.google.com/ googles new beta mapping
service] from this [LINK http://biz.yahoo.com/ap/050406/google_maps.html?.v=1 Yahoo] news article. I loved this tool, but thought I
could improve on a few things. With that, I present to you my version
of a 2D GIS ortho viewer over the internet. Its my first program in
Java (started learning it Wednesday), but I think its relatively
feature complete. Everything was written from scratch, and its a brand
new algorithm I developed during my sleepless nights. Here it is for
your viewing pleasure : [LINK http://www.xl3d.com/]
As for technology details :
It uses a dynamically growing quadtree to house the near infinite
resolutions. This means that you can throw in a very low resolution
image with an extremely high resolution image and not lose any pixel
accuracy when you zoom into the high resolution subset. There is still
a little shakyness when you zoom into the low resolution imagery, but
this wasn't an issue to me so I never bothered to fix it. Its only
there because I don't have the disk space to upload bigger imagery.
The quad tree automatically adjusts and frees itself to your viewing
position, such that you're never wasting unncessary memory.
Each raster is treated separately. This method is specific to 2D only,
but it works pretty nicely. Because each one is separate, we can
toggle them on/off as well as apply blending/swiping between the
different layers to give true GIS functionality. It should scale very
well for thousands of images as well.
The loaded raster resolutions in pixels are :
16,252 x 18,362
7,964 x 11,258
4,320 x 2160
Big by todays graphics card standards, but small by GIS standards. I
wish I could upload more higher resolution imagery, but I am limited
by my webhost. The current scene takes up a little over 130Mb
compressed on the website as it is.
More info is available in the write up on the applet page.
-Lennox
(L) [2005/04/14] [JohnLoehrlein] [john.loehrlein@gmail.com]
"Mexican Motor Mafia" is the first game I've programmed. I've done art
for a number of commercial titles. The engine was built from scratch
while I learned game programming. There is one other artist working on
it doing all the character illustration.
It's sort of an updated version of the old Autoduel game and borrows a
lot of elements from Pirates! The goal was to make a fun and simple
yet complete game with the resources I had at hand. It's 2d and it
takes advantage of that.
The weapon system is unusual. All the guns shoot out the sides from
the windows. This keeps the game from turning into "ram and shoot" and
rewards the player for driving around the map without needing to add
racing elements.
The two pieces of preexisting tech I used are Lua and Fmod. Lua has
been invaluable in setting up the higher level game functions and one
could just modify the game's Lua scripts to make an entirely different
game.
I'm not sure if the title "Mexican Motor Mafia" is offensive, I was
just going for edgy. If you have an opinion by all means speak up.
I've just created a website at for the game at [LINK http://www.mexicanmotormafia.com/]
The illustrator's website is [LINK http://www.michaelgeiger.net/]
I'm not planning on putting out a demo until the game comes out, but I
have made an old test version available at
[LINK http://www.scienceoftomorrow.com/public/]
This version is very old and a lot has changed since then, but I
really wanted to share something playable with the flipcode crowd. The
project has been code complete for a while now, except for the copy
protection so I can't share that.
-John Loehrlein
(L) [2005/04/15] [DanRoyer] [droyer@shaw.ca]
Every tuesday morning I go to downtown Vancouver and I teach people how to program video games. Recently I demonstrated how to create an SDL window with OpenGL, and then began showing how to quickly get lots and lots of objects moving around the screen.
Funny thing, though, was that as I started to work it up in class I found the pointless little demo quite entertaining. It's good for... oh... 5 minutes, tops. Perfect for a quick work break to clear you head. Just do your best to survive as long as possible.
You can read more about it [LINK http://www.marginallyclever.com on the official Surrounded page].
(L) [2005/04/22] [ForrestBriggs] [fbriggs@hmc.edu]
I had a lot of cool (imho) stuff that lost its home during a web site relocation. Now it is available again. The old stuff includes
- Fractogroovalicious iTunes Visualizer 2.0, now as freeware (top right).
Fractalicious, a realtime julia fractal explorer (bottom right).
My old ray tracing tutorial series with example code for Mac OS X, Windows and SDL (top middle).
I have also added some new programs with source code. These include
- A realtime plant growth simulator. The shape of the plant is determined by its genes (top left).
A procedural world generator (middle left).
An OpenGL warping / feedback effect by rendering to a texture (bottom left).
The source code for two new ray tracers that do file loading, hierarchical transformations and ray-metasurface intersection.
All of this is available at
[LINK http://www.groovyvis.com/other/index.html www.groovyvis.com/other/index.html]
(yes this is a shameless attempt to draw more traffic to my visulizer ; P)
(L) [2005/04/29] [JaccoBikker] [jacco.bikker@overloaded.com]
A while back I sent in an ray tracing IOTD showing the Stanford bunny,
rendered at high speed. I've been busy since I made that demo, and these
shots show the current state of the art. The top shot represents the maximum
image quality: There are textures, adaptive super sampling (for edge anti
aliasing), a bloom filter causing a subtle glow and of course the
reflections. Sadly all this eye candy comes at a cost. The lower shot shows
a very good performing model: The number of rays per second is no less than
3 million on a 1.7 Pentium-M - on a P4 @ 3.2Ghz this would be about 6
million rays per second, which is better than the SaarCOR FPGA ray tracing
chip.
Over the past months, many things have improved: The overall speed of the
ray tracer has been improved considerably due to some stiff competition from
tbp (the odd french dude), there's a complete tool chain now to get from
downloaded content to ray traced images (via the .obj file format), and the
functionality has been extended considerably (textures, reflections, HDRI,
networked rendering etc.).
There will be more good stuff, I'll keep you all informed. Greets - Jacco.
(L) [2005/05/10] [DominiqueLouis] [Dominique@SavageSoftware.com.au]
Above is a collage image of the winners of this year's PGD Game programming competition. The inaugural competition was held between January 1st 2005 and March 15th and this year's theme was "Dog Fight", but rather than
force entrants to adhere to the traditional idea of 2 plane combatants,
we extended this to allow any 2 fighting entities from bacteria to solar
systems, as long as the fighting was intense. The other main
stipulations were that the main code for the game had to be written in
Pascal and that it had to be Open Source, so that others could learn
from the code. Prizes ( generously donated by Borland, Caligari, 3impact and NexusDB ) were handed out to the first 3 place getters and 3 entries were given honorary mentions.
The games and their features/tools used, going from left to right, are
as follows...
Top Row 2 images : AirBlast
3D Air combat simulation with SU37s. This game was the
the most polished/complete of all the entries.
Developer : Eric Grange
Download :
[LINK http://prdownloads.sourceforge.net/glscene/AirBlast_1.0_Setup.exe?download]
Features :
- Flight Tutorial mode
Duel with SU37 aircraft
Large detailed terrains
Several modes of game play
Tools :
- OpenGL via the excellent GLScene components ( [LINK http://www.glscene.org]
).
All voice samples were made with AT&T Natural Voices -
[LINK http://www.naturalvoices.att.com/]
AARAM, AIM9, Gate and Spanner models were made by Eric
Second row left : JagdGeschwader
3D World War II air combat simulation.
Developer : Sascha Willems
Download : [LINK http://www.delphigl.de/eng_index.html]
Features :
- 4 different WW2 aircrafts to choose from
4 different scenarios
Stunning graphics using OpenGL (huge terrains, foliage, water
reflections, explosions and more)
Arcade-like aircraft physics using the Newton Game Dynamics engine
Two players on one PC using splitscreen or two players over
LAN/Internet
Tools :
- Used Freeware models, with the permission of their maker changed
some stuff on them using 3D Studio MAX
Used his own TerrTexGen and T2 (depending on which one gave a better
looking terrain texture) for the terrain textures
The trees were made using TreeMAGIK (which is Freeware).
Used Corel's Bryce for the skyspheres, Photoshop for some
afterwork/manipulation of textures and Adobe's Photoshop for the whole
GUI.
Second row right : Sodoma - Lite
This is an action shooter ( similar to decent ) multiplayer-only game,
with great music and UI.
Developer : Mind Never Team
Download : [LINK http://sodoma.mindnever.org]
Features :
- 2.5D game (full 3D view, 2D game-logic)
created using our own powerful Grom(tm) realtime multimedia engine
3 different ships (fast, balanced, heavy), each concepted for
different playing styles
3 different maps for up to 8 players per map (maximum players number
map defined; real number virtually unlimited)
user-defined color for ship
inertial movement (configurable through setup files)
smooth network gameplay; automatic search for server
radar view
secondary weapons for enhanced in-game action
original musics & sound effects
automatic detection of tables, ships, weapons & music
configurable number and types of gameplay view(s)
powerful in-game console which allows full control over complete
game
Tools :
- FreePascal, Lazarus (originally Borland Delphi 7),
Euphoria
modelling and animated content created with LightWave3D v8
original graphics created with Photoshop CS
Third row left : Run-A-War
Run-A-War is a fast, action packed, fantasy 2D isometric combat game
Developer : William Cairns
Download :
[LINK http://www.cairnsgames.co.za/public.asp?inc=Articles&ArtID=3]
Features :
- 6 Different Fantasy Characters
2 Different Scenario Maps
8 different Weapons
Various Armor, Pickups and Potions
Single Player against the Computer or 2 player networking
Various Expansion packs can be added
Create AI done using Delhi Web Scripting
Tools :
- Used JEDI-SDL ( Pascal headers for SDL )
Graphics from Reiner Prokien ( trueSpace ), landscapes done
using Vue Esprit 3 Lite.
Third row right : Dragon Duel
Air Combat simulation using Dragons.
Developer : DGDev Team
Download :
[LINK http://pgd.vadertrophy.com/Dogfight_15_March_05/dgdev_team/dragonduel_101.zip]
Features :
- Basilisk 3D Engine - Supports OpenGL and Software rendering
Two players on one PC using splitscreen or two players over
LAN/Internet
Tools :
- Unspecified
Forth left : Space Cadett
Space Shooter with extremely accurate enemy.
Developer : MSX
Download :
[LINK http://pgd.vadertrophy.com/Dogfight_15_March_05/msx/SpaceCadett.zip]
Features :
- Cross platform: works on Linux and Windows
OpenGL 3D engine
Challanging AI enemy
Easy dogfight gameplay
Simple and funny cartoon style rendering
Tools :
- Compiles with FreePascal, Delphi, Kylix
Blender
Gimp
Debian
JEDI-SDL ( Pascal headers for SDL )
OpenAl for sound
Forth row right : Area 52
First Person Death-match game against lethal Computer AI.
Download :
[LINK http://www.plasmacode.com/modules.php?name=Downloads&d_op=viewdownload&cid=7]
Features :
- A Quake3/UT single player dogfight against an evil Alien Mech
DOT3 bump mapping
Tools :
- OpenGL via the excellent GLScene components ( [LINK http://www.glscene.org]
).
Q3 model "Dragoon" by Sgt. Science,Firestarter,Crash
Physics are powered by ODE
More information about the entries and what the judjes said about each
entry can be found @ [LINK http://www.pascalgamedevelopment.com/competitions/PGDCompetition2005.html the competition page].
I am sure more Pascal developers will join us next January for our next
Game Competition and hopefully more great prizes. In the mean time watch
out for a demo competition being launched this July.
Dominique Louis.
(L) [2005/05/12] [RichardPhipps] [richard@reflectedgames.com]
This IOTD consists of several screenshots of my latest shareware game Sunny Ball. It is a picture based breakout game combining 60 picture boards with 60 more traditional breakout style levels. These 120 boards are split over 5 board packs that can be played in any order.
The image above shows 3 picture boards and 2 traditional boards as well as some of the powerups in action.
The game features all the normal breakout powerups as well as several bonus systems such as combination hits, lightable stars and matching crystals for a points bonus. Sunny Ball also contains several alpha particle effects as well as a nice reflection effect in the sides bars around each board.
The game is built around a very compact graphics format I have developed which combines simple and quite complex pictures with additional colouring information. Each board is made up of a foreground and a background picture and backgrounds can be reused between boards. The final graphics can be displayed at different resolutions in a truecolour mode (although they are not actually in a vector format) and the game can be played at resolutions ranging from 640 x 480 to 1280 x 1024 all with anti-aliasing and bilinear filtering where necessary. The higher the resolution the better the graphics look and the result is a beautiful, colourful and cute look that works well for the gfx style used.
The very compact size of the boards means that the full game with 120 boards (60 picture boards and 60 traditional boards) with 7 pieces of music is only 2.25 megabytes in size. In fact I estimate that after all the compression used the average size of a picture board is probably around 4k. This small size enables me to use a lot of art without an overly large file size. In fact the demo and full game are smaller than many other breakout games despite the picture boards I use.
You can visit the website to see more screenshots and read more information about the game.
A free 8 board demo is available to play, and the full game can be purchased for $19.99:
[LINK http://www.reflectedgames.com]
Richard Phipps
(L) [2005/05/16] [JamesClayton] [james_clayton@giraffe.gotadsl.co.uk]
What you are seeing is a collection of screen shots from my latest terrain
demo. Nothing really new here, but it does show off quite a few shader
effects.
The terrain is made up of 4 different textures (a sand texture, 2 grass
textures and a rock texture) all blended with a texture blends map. This
blends map can be altered in real time using a 'texture paint' tool in a GUI
form.
The water has animated reflections and refractions, and as you can see in
the screen shots, there is blooming on the sun specular. There is no
interaction with the water (yet).
The sky is dynamic, using the perlin-noise approach. The noise is generated
in shaders, and the number of octaves can be altered in real time
(re-compiling the noise shader). A GUI form allows you to alter the cloud
cover and density.
My favourite feature of the demo is the time-of-day form. This GUI form
provides you with full control over the time. You are provided with a clock
that by default shows the current system time. You can drag the clock hands
around with the cursor to change the time. Alternatively you can change the
speed-of-time slider, causing time to stop, run very fast, or even go
backwards.
To have a play with this demo, please download the demo from [LINK http://www.headless.nildram.co.uk/planet/ here].
James Clayton.
(L) [2005/05/23] [JimmyMagnusson] [vim@duds.org]
These screenshots are from Mistlands, a online role playing game in development by Zero Point Gameplay. The game uses our own game engine called ZeroFps and the game is made for both Linux and Windows. We make this game both as a learning experience and also to have something to show when we look for work.
MistClient -
The top image shows the view from the game when you play it. The view is third person but you can also zoom in and use first person view if you wish. The main focus right now in the development process are the controlls and combat system. The gui shows the skillbar, a chat window, emote icon (the smiley), compass, status bars (health, mana and stamina) and some icons to display inventory and other things.
Zeroed -
The top two of the small images shows the editor and it goes by the name ZeroEd. The editor can both be run on it's own or connected to a server to edit parts on the world online. Both images was taken in online mode. The left ones shows a outdoor area. The right one shows below ground in a waterfilled cave.
Madview -
The lower left image show madview, our modelviewer. The engine supports simple skelleton animations and there are no support for blendning of animations right now. The modell shown is one of the player models and models are exportable from maya and .OBJ files. Things such as weapons and shields can be linked to the hands of a model in the game.
GuiEdit -
GuiEdit is the name of the editor for the graphical user interface and a image of it is shown in the lower right image. The GUI support things such as textboxes, buttons, lists and treeboxes. Guis are saved as lua scripts.
For more information about Mistlands you can visit Zero point Gamerplays website ( [LINK http://www.zeropointgameplay.com] ), look at our gallery and also download it if you wish.
(L) [2005/06/05] [tbp] [tbptbp@gmail.com]
A recent post on comp.graphics.rendering.raytracing tickled my curiosity, the
challenge was to implement a raytracer to render a sphere flake within 100 lines
- cough - of C++.
This IOTD is what i've come up to after a couple of revisions.
Features:
- generates a sphere flake and the corresponding hierarchy in place.
iterative, that is only the scene generation phase is recursive.
simple shading with 1 light and shadows (monochrome PPM output).
full scene 2x2 anti-aliasing (rotated grid).
decently fast.
On 2ghz k8, for a 1024x1024 picture...
# time ./sphereflake100 8 >pix.ppm
5380840 spheres,claiming 369.473 MB.
real 0m7.642s
user 0m7.329s
sys 0m0.295s
More information, source & whatnot here: [LINK http://ompf.org/ray/sphereflake/].
-- tbp.
(L) [2005/07/01] [MichalStaniszewski] [bonzaj@kolos.math.uni.lodz.pl]
The demoscene group "plastic" demo called "195/95".
The image shows some of the screenshots from "195/95" (party version) and our working environment.
Our engine is not so old (about two months) and that's why we implemented just a couple of new effects.
And these are:
- GPU spherical harmonics precalculation
fresnel reflection added to reflection mapped HDRI's
tons of postprocessing effects
For the developers the most interesting part will be the core of the engine.
We've designed a similar architecture to what maya uses (just from SDK's), and we
added the mechanism that combines the maya DependencyGraph to our dependency
graph. So triggering any attribute within maya automatically triggers the coresponding
attribute within our "PicoEngine". So actually we have realtime preview of everything
we want. There is no other software (except the editing script for cuts and in-betweens)
that changes overall look of the scene. So forget about any other tools that you must use
after using your modelling/texturing package.
There is much to do. We want to concentrate more on subdivision surfaces and history
modelling. So then we'll replay all the actions that maya does to receive the final model.
"195/95" was ranked first on Breakpoint 2005 demoscene party.
more info: [LINK http://www.plastic-demo.org]
back