Jolt 3D Game Engine (open source)

[Tami]

Engine Updated: September 2007

[url=\"http://jolt-3d.sourceforge.net/\"]Jolt3D![/url] is a 3D Game Engine, designed by the start to give the EASIEST possible access to DirectX.
The true power of Jolt3D! is not only engine's abilities, but also the rapid installing & developing.
The engine is developing about 3 years now (1.5 year about released on internet) and is still continuing to update frequently.
Developed under MSVC++ 6.0 (in first versions until 3.0 if i remember correctly) & MSVC .NET 2003 for the latest versions.
The current DirectX SDK that Jolt3D! using is DirectX 9.0c April's 2005. (second edition in 'c' revisions)

The Jolt3D! created using these 2 kinds of PCs:

* AMD Duron 800MHz, GeForce MX 440 & Radeon 9200
* AMD Athlon64 2800+, GeForce 6600GT

The graphic cards that engine was tested (in time order), are:

* Rage 128 Pro (poor performance & quality, but jolt3d worked with it)
* GeForce MX 440 (great quality & performance, althrough several shaders & abilities like bumpmapping doesnt supported)
* Radeon 9200 (great quality & performance, all-goes-well with this one)
* GeForce 6600GT (what to say about this diamond? all are just superb. Engine is FULLY working with this card)

Currently, the Jolt3D! demand just only a C++ language (MSVC++ 6.0, MSVC .NET 2003, Dev C++) to operate.
Also, cause of the reason that engine is created by using the April's 2005 DirectX 9.0c SDK,
it -demands- the file D3DX9_25.DLL for Jolt3D! created apps to run. This is because Microsoft updates the Direct3D extensions.
Itll be stopped when a new DX version it comes...But until then, be sure to have this file.
The installing process is discussed very clearly for each of the above 3 languages inside the user_guide.zip of each Jolt3D! SDK version.

Filtering:
Jolt3D! can filter textures & models with varius ways.

* Texture Filtering: None, Bilinear.
* MipMap Filtering: None, BiLinear.
* Shade Modes: Flat and Gouraud (smooth interpolation between triangles).
* Fill Modes: Solid and Wireframe (triangle lines).
* Dithering: Smooth over a low-colored scene (very good at 16-bit high color).
* Alpha Blending: Add transparency to your models/textures with one value change.
* Alpha Transparency: Remove unwanted colors from textured objects.

Textures:
Jolt3D! can load & render a wide number of image formats:

* .BMP Bitmap Microsoft
* .DDS DirectDraw Surface
* .DIB Device Independent Bitmap
* .JPG Joint Photographic Experts Group
* .JP2/J2K/JPC JPEG-2000
* .PNG Portable Network Graphics
* .TGA Targa
* .PPM Poskanzer's Pixelmap
* .PGM Poskanzer's Graymap
* .PBM Poskanzer's Bitmap
* .HDR High Dynamic Range
* .PFM Portable Float Map
* .PCX ZSoft
* .GIF Compuserve
* .MAC MacPaint
* .LBM Deluxe Paint
* .JIMG Jolt3D! Official Image Format

The textures can be rendered via polygons in space or like sprites in 2D Screen position.
Also, can be dynamic rotated & scaled without performance cost. (both in 2D/3D)
They can also be manipulated in pixel level, as well filtered by specific effects.
For info, check the User Guide under the 'jLoad_Texture()' function.
Model Formats:
Jolt3D! can load a number of widely used & popular model formats.

* .X Microsoft DirectX (Static/Animated)
* .3DS Autodesk 3D Studio
* .MD2 Quake2 Model
* .MD3 Quake3 Model
* .MS3D MilkShape3D
* .BSP Quake Map
* .OBJ Alias|WaveFront
* .COB Caligari TrueSpace
* .LWO Lightwave 6/7 Object
* .JMDL Jolt3D! Official Model Format
* .JWRL Jolt3D! Official World Format

The loaded models can be fast & easily
positioned,rotated & scaled at both vertex
and world level.
The Jolt3D! Buffering system allows the creation
of HUGE (or infinite) models, limiting ONLY to
your RAM+virtual memory.
Video & Audio:
Jolt3D! uses its own Audio Library for sound.
The engine is capable for 2D/3D Sound plus EAX 2.0 Api.
The DirectShow used for videos. They can be rendered in both
2D screen position(x,y) or 3D space position (In a quad)

Video Formats (DirectShow used)

* .AVI
* .MPG
* .WMV

Audio Formats (a custom engine is used)

* .OGG
* .WAV

After loading the media, the user can easily
handle it with easy functions.
NOTE: Because this is a 'heavy' process,
you might suffer performance degrade in low-end
cards; Choose the K-Lite Codecs pack for performance.
Retrieving Device Infos:
Jolt3D! can retrieve the abilities of your devices.

The supported devices are:

* CPU Device: (CPU Name, vendor, MHz speed, MMX, SSE, SSE2, 3DNow!)
* Graphic card: (Many infos, see the User Guide)
* Sound Card: (How many sound cards, card name, driver)
* Mouse Device: (How many buttons, has a wheel?, existed?)
* Joystick Device: (product name, number of buttons, axes number, existed?)
* System Infos: (Operating system, window+system directories, memory sizes)

Lighting:
Jolt3D! supports both the Per-Vertex & Per-Pixel Lighting methods.

The suppored light types of Per-Vertex lighting are:
Point, Directional & SpotLights (or cones).
The suppored light types of Per-Pixel lighting are:
Point
Fog:
Jolt3D! supports the default Direct3D fog techniques:

* Density: (need a density-factor)
* Linear: (need start & end distance)

2D Drawing:
Jolt3D! supports a wide variety of 2D drawing shapes:

* Put Pixel: write a single pixel to screen. (or 3D Scene)
* Draw Line: Draw a single line from x1,y1 to x2,y2.
* Draw Circle: Draw a circle with a specified radius.
* Draw Ellipse: Draw an ellipse with specified x,y radius.
* Draw Rectangle: Draw a bar without body (not filled).
* Draw Torus: Draw a 2D ring, with specific radius & thickness.
* Draw Bar: Draw a bar with body (filled).
* Draw Triangle: Draw a triangle (3 differently placed corners).
* Draw Trapezoid: Draw a trapezoid (4 differently placed corners, unlike bar).

3D Shapes:
Jolt3D! supports the creation of some basic 3D shapes:

* Quad
* Box
* Pyramid
* Sphere
* Culinder
* Polygon
* Teapot
* Text
* Torus

After the creation, these shapes can be handled like loaded models.
Effects:
Jolt3D! allows the creation of different 'natural' effects:

* Mirroring: Specify a Trapezoid in space (4 differently placed corners) which will mirror/reflect anything that is drawn in front of it.
* Rain: Emulates a rain plane. Givin the option (static) to specify the number of drops(!) that will be used from Jolt3D! for each frame.
* Snow: Emulates a snow plane. Givin the option (static) to specify the number of drops(!) that will be used from Jolt3D! for each frame.
* Shadows: Jolt3D! supports the well known method (and very realistic) Shadow Volumes. Also, a 'flat' method of shadowing is used, and an early approach to Self Shadowing.
* Skydomes: A seemlessly endless plane of sky can be added using a Jolt3D! function. The method used is NOT the 'box' one (used in Quake). Here, only 1 texture is needed for great results, not 6 sides etc.
* BumpMapping: Allows the drawing of 'liquid'& 'underwater' surfaces, by using just a loaded texture. This effect is great for lakes, seas etc.
* Cartoon Shading: Or Cel Shading if u prefer. Convert your world into a comic magazine /smile.gif\' class=\'bbc_emoticon\' alt=\':)\' /> by calling just ONE function. The shader used is hardcoded; no external files, no complexity.
* Depth-Of-Field: Add bluriness to your 3D scene after specific distance. The effect is using a hard-coded shader too, and the ability to set the CoC (circle of confusion) as well focal & focus ranges.
* Lens Flare: This effect simulates the sun-glow when you are across it.
(or sun exists on screen)
The effect actually is working on 2D & is just giving you these screen positions
for placing your graphics.
* Beam: This was the first Jolt3D! effect. The main purpose of this one is to allow u to 'fire' seemlesly endless bullets (or beams). Also, these bullets CAN collition with landscape or any other geometry.
* Render-To-Texture: With this effect u can render your entire 3D scene to a single texture (of user desired resolution). This helps in both performance (with lower texture resolution) & also in creation of progressive texture effects.
* Texture Effects: These are a number of functions, able to create different 'natural' texture. More specifically, these functions are able to create realistic Clouds, BumpMapped textures, Flames able to update overtime, and elementary ones like inverted,monochrome textures etc.

...and more coming or planned
Particle System:
Jolt3D! allows the creation of Particle Systems by using physics functions.
Also, the particle streams can be dynamic (real time) changing.

These physics functions handles:

* Position: The streams can be placed directly anywhere.
* Velocity: Like air, is where the particle sprites travel to.
* Gravity: A vector from where the particle sprites are 'pulled' of.
* Collition Plane: An invisible plane that particle sprites 'hit'.

...and many others
Finally, the Particle System Editor allows u to create custom Particle Systems by changing their physics dynamic in a 3D graphical environment (using between others and the build-in Jolt3D! window system)
Window System:
Jolt3D! allows the creating and using of a custom Window System.
A default pre-made one is present, but the user can 'mess' it up to create a custom one.
(By saying 'custom' i mean ONLY at graphics; the actual usage of window system remains the same)
The maximum number of EACH control that a user can create is 500 (for now).
Also note that the window system is fully dymamic; u can change it to anything, also it 'runs' like a cover above anything; u can 'play' your 3D Scene & having a window system above it. (The window controls also is full-3D, no 2D or GDI api is added)

The user can create,modify,delete & use the following control types:

* Windows
* Buttons
* EditBoxes
* CheckBoxes
* DropDowns
* GroupBoxes
* TextLabels
* ListBoxes

Network System:
Jolt3D! using Winsock 2.2 for Network.

The Winsock is a low-level Network API, which Windows are using for their networks jobs; Its more hard than DirectPlay8 to coding, but its more -faster- & direct; Even the DirectPlay8 use it, but instead Jolt3D! use it directly, giving the most possible speed.

U can create Server(s) in a single PC, with just a Port as the most basic info.
Then, Clients from all the world can connect to your server, needed to know only your Port & IP; The Server (u) will be then responsible to accept them or not.
This is one of the most Easier approaches to network your 3D game.
Physics System:
Jolt3D! support the Newton Game Dynamics Physics Engine. (1.53 release)
U can apply physics effects by calling very simple functions.
U can 'connect' visually different objects to perform a 'chain' effect,
or let them falling from a high place.
By now, only 4 collition shapes are supported:

* Box
* Sphere
* Model (a bunch of points, representing triangles)
* Area (an area which can be used as level for your entities)

Landscapes:
Jolt3D! can create HUGE landscape surfaces with specified width & height.
It can create landscapes from zero, from map files, from a floating buffer (etc. float *map) or from an image!
There are MANY functions to handle basic & advanced things such texturing, heights, colors, draw distance etc.
The Jolt3D! supports the following elevation formats:

* Terragen terrain (.ter)
* L3DT terrain (.hff)
* Binary terrain (.bt)
* Jolt3D! Official Landscape (.jlnd)
* Custom float array

MySQL (Client) support:
Jolt3D! is givin' you the ability to control large databases fast & in the easiest
of ways, in the most widely used technology, the MySQL API.
With this API you will be able to:

* Create & Read databases
* Connect to a hard-disk or network database.
* Applying any kind of SQL queries
* Getting results via C++ structures

Path Finding:
Jolt3D! is using the A* (A-star) method of computing a path between 2 given points,
in a 2D-map of nodes, each one having specific level of 'moveness'.
Only a function call is needed (and a map) for calculating path finding,
without complex set-ups.