Jegas Game Classes Version 3.0 Library

Home

Jegas Products

Written by Jason P Sage

Friday, 30 January 2009 18:58

Overview

The JGC Library is a collection of integrated C++ object oriented classes that can assist you in making 2D and 3D games. Its designed to work with Microsoft Visual Studio 2008 Free Edition (Or Enterprise with some changes to your project's compiler and linker settings), The Game Creators' DarkGDK Game Engine, The Game Creators' Dark Physics Product (optional), and the freely available "Sparky's DLL" (optional but recommended).

This library contains well over 33,000 lines of working code by last count! Click for Pricing!

Download the Demo

Details

The Game Creators released the DarkGDK C++ library for freeware creations - at no cost and it's obtainable via the link above.
DarkGDK is NOT FREE for commercial applications. (e.g. To sell a game you make) there is a special license fee required that needs to be paid to The Game Creators (aka TGC) before you can sell your application.
Working examples are plentiful but documentation is sparse! Be advised! Intellisense however makes this library extremely easy to use! A forum has been created specifically for this product and all your questions will be answered there to serve as a form of documentation.
Additional utilities are in the development phase now specifically designed to work with and compliment this library and will be available freely to registered users.
Registered owners will recieve all updates to the library for the current version 3.X series free of charge.

Prerequisites

Microsoft Windows XP or Vista
DirectX 9.0c Aug 2007 SDK
Microsoft Visual Studio 2008 C++ Express or Other
DarkGDK Game Development Kit - From The Game Creators

Optional

DarkPhysics - From The Game Creators
Sparky's Collision DLL
Tokomak Physics Library

What's New In Version 3.x?

Ease of Use - Array System Overhauled (Template Based)
New Tokomak Physics Support
New utilities for creating shader media
New utilities for manipulating image files and USGS satellite data
GUI TextBox Cursor Handling Overhauled - Much Improvement!
GUI Button Control modified to serve as Picture Box, Picture Button, or Normal Button

Demo's of New Tokomak Physics Support - (Microsoft's DirectX 9.x Required)

Demonstration Executables - Source Code for Demos included with purchase (Click Here for Larger Image)

Vehicular Fun Demo - Drive various "models" like cars, a bus, two 4x4 Monster trucks, a semi, and an exagerated limo named the centipede!

Ragdoll Physics - Watch as an observer, various ragdolls falling down a staircase - OR - press one key to take the plunge yourself using the first-person point of view!

Falling Objects - Simple concept - but definately shows off the Tokomak Physics at work!

Features

37 Demonstration Programs with Source
Wrappers for all DarkGDK entities complete with ID number handling. You do not need to worry about the ID values unless you want to!
Generic Classes and Functions that are not DarkGDK specific:
- jfc_ar - Template Based Dynamic Array class
- jfc_clock - Windows Based Clock (Query Performance or Tick Modes)
- jfc_common - Contains many measure conversion functions and eular to quaternion math functions.
- jfc_date - contains DateGDKConv function which converts DarkGDK Date to readable string format
- jfc_dl - JFC_DL and JFC_DLITEM class pair - versatile, daisy-chainable double linked list class, some features include:
  - * Item autonumbering - guaranteeing unique 32 bit id's - useful for gaming and database applications
  - * String Tokening - Pass a string and the list fills up with all the tokens
  - * Filename parsing - pass a filename and the filename gets broken down in many different ways: filename, path, individual directories, etc. All properties are easy to retrieve
  - * Quadtree Auto Creation tool - creates nested daisy chain quadtree structure in memory for you as many levels deep as needed based on your specifications!
  - * Averaging FIFO - Great for Speedometers, Averaging Scores per time frame, many uses.
  - * Search functions - binary and string based, case sensitive or not - you can literally query a linked list and find your first match and continue iterating through subsequent matches.
  - * Header file comes with complete template to make inheriting and adding to this class very simple!
- jfc_file - JFC_FILE class - various file handling function including Directory at startup, current dir, functions for manipulating the log file for the JGC v3.x Library
- jfc_rgba - RGBA structure and JFC_RGBA class offer various functions to make working with 32 RGBA values a snap
- jfc_string - JFC_STRING class is an easy to use STL alternative string class that supports dynamic string length, and functions you know like Left, Right, Mid, ConCat, Insert, RTrim etc.
- jfc_stringw - JFC_STRINGW class is the wide string variation of JFC_STRING with conversion routines to go from ASCII to UNICODE/Multibyte
- jfc_timer - JFC_TIMER class allows you to have timers that can be polled to see if the specified time has elapsed. Resets automatically for subsequent calls
- jfc_tlbr - JFC_TLBR class allows you to have 2D boxes (Top, Left, Bottom, Right) with various functions to help working them - such as the Inside(p_X, p_Y) function.
- jfc_userinput - JFC_USERINPUT class is automatically updated and polls some basic keypresses and the mouse and its buttons so you don't have to. Not DarkGDK compatible.
- jfc_xyz - This file contains numerous classes not unlike DarkGDK vectors but in some cases more friendly to use:
  - * JFC_XYINT - X and Y integer class
  - * JFC_XYFLOAT - X and Y float class
  - * JFC_XYZINT - X,Y, and Z integer class
  - * JFC_XYZFLOAT - X,Y, and Z float class
  - * JFC_XYZIINT - X,Y,Z, and I integer class - Where I could be intensity or just a place for the forth value.
  - * JFC_XYZIFLOAT - X,Y,Z, and I float class - Where I could be intensity or just a place for the forth value.
DarkGDK entity Specific Wrappers PLUS features you won't find anywhere else:
- jgc_bitmap - contains a class wrapper for DarkGDK Bitmap Entities
- jgc_bitmapfonts - contains classes to load various bitmap fonts and ability to write them to the display as sprites or directly onto images/bitmaps
- jgc_camera - contains wrapper class for DarkGDK entity plus ability to save virtually unlimited camera settings and apply/save them at will. e.g. you can have 50 virtual cameras, and view any of them at any time.
- jgc_clock - contains clock class similiar to jfc_clock except it is based on the DarkGDK dbTimer function.
- jgc_common - contains various constants, and also ties together the JGC v3 Library engine
- jgc_configuration - hard coded default values used by the library. these can be overridden in code or even overriden by a configuration file that supports over 190 settiongs!
- jgc_daddy - the Daddy of all the JGC classes - this is the REAL glue that runs everything, handles loading the optional configuration file for the lib, and runs the show.
- jgc_darkphysics - this class simply syncronize DarkPhysics initialization and updates. There are also defines and such so that compiling applications with DarkPhysics enabled or not enabled is easy.
- jgc_display - wrapper class for the display/screen
- jgc_effect - wrapper class for shaders
- jgc_file - wrapper class for the JFC_FILE class (jfc_file) with extra functions to allow dumping ANY dark gdk checklist to a text file for analysis.
- jgc_frustrumculling - Object and Limb Frustrum Culling - Quadtree, Groups, Regions, Object LOD, Physics Tie allows hidden physics object to manipulate visible models regardless of current LOD model being displayed... to many features to list.
- jgc_funstuff - currently contains two 3D menu systems, and a class/tool to help with 2D development - four lines you can manipulate to box off regions of the screen and record the dimensions.
- jgc_fvfinfo - contains a structure used by the two custom terrain systems: JGC_JMESH and JGC_VMESH
- jgc_gdk - this file contains various MISSING DarkGDK function declarations like Object size functios, Perf timer, Blend Mapping On etc.
- jgc_gui - This is the GUI system! This has been enhanced since JGC v2.0 Which was featured in The Game Creators NewsLetter.
- jgc_image - Wrapper for DarkGDK Image entities with some extra functionality added
- jgc_light - Wrapper for DarkGDK (hardware) Light entities.
- jgc_matrix - Wrapper for DarkGDK Matrix Entities
- jgc_memblock - Wrapper for DarkGDK Memblock entities
- jgc_mesh - Wrapper for DarkGDK Mesh entities with one reserved for use by Sparky's DLL.
- jgc_meshj - JGC_JMESH class is an ONE OBJECT, MULTI-LIMB Memblock Mesh based Terrain System based on simple 2 poly quads.
  - * UNWELDED Vertices and functions to manipulate any vertices in any direction in 3D space
  - * Loads Heightmaps - Supports 24Bit Bitmap Grayscale Format
  - * Shaderless Texture Shading - Texture Blend Once - Free up GPU - EXPERIMENTAL -- See Screen Shots
  - * Ground Height function - utilizes sparky's if enabled otherwise dbIntersectObject function is used
  - * Smooth Matrix and Matrix Normalization routines
  - * Various UV functions to assist in applying textures how you want where you want with ease
- jgc_meshv - JGC_VMESH class is a MULTI-OBJECT, MULTI-LIMB Mesh based on a diamond poly arrangement.
  - * WELDED Vertices and functions to manipulate any vertices in any direction in 3D space
  - * Loads Heightmaps - Supports 24Bit Bitmap Grayscale Format & USGS (United States Geological Survey) satellite imagery (GRIDFLOAT format) formats.
  - * Smooth Matrix and Matrix Normalization routines
  - * Various UV functions to assist in applying textures how you want where you want with ease
  - * Integrated With Tokomak Physics
- jgc_music - Wrapper for DarkGDK Music entities
- jgc_object - Wrapper for DarkGDK Objects
- jgc_physics - Wrapper for Tokomak Physics that integrates JGC and DarkGDK so they all can play together.
- jgc_physicsmesh - Internal Use - Tokomak Class for handling Physics static Mesh which are for terrains and more: only limited to static poly triangles
- jgc_pixelgrid - JGC Exclusive - this class is like an in memory paintbrush to a certain degree. you can paste, copy, cut, fill, draw boxes, on virtual canvas and then make images or memblocks from them!
- jgc_rgba - identical to jfc_rgba - slated for removal
- jgc_sky - Shader Based SkySphere with Moving clouds
- jgc_sound - Wrapper class for DarkGDK sound entities
- jgc_sprite - Wrapper class for DarkGDK Sprite entities
- jgc_terrain - Wrapper class for DarkGDK Terrain entities
- jgc_timer - Slated to be merged to jfc_timer - Similiar to jfc_timer except has special functions for working with QueryPerformance timer in addition to DarkGDK's dbTimer integration
- jgc_tlbr - slated to be removed - identical to jfc_tlbr - a 2D Region/box class with Inside, width get/set, height get/set functions. Initial stand for Top, Left, bottom, Right
- jgc_userinput - JGC_USERINPUT class is automatically updated and polls some basic keypresses and the mouse and its buttons so you don't have to. DarkGDK compatible for sure!
- jgc_usgs - Various tools for working with USGS Gridfloat formatted satellite imagery:
  - * USGSMapToBitMap - Color or Grayscale Conversions
  - * USGSMapToRaw16 - Raw 16 is a Heightmap format utilizing 16Bit unsigned values - very accurate compared to Grayscale Heightmaps
  - * Resizer - Resize Graphic files and USGS Gridfloat Satellite heightmaps
  - * Tiler - Chop up Graphic files and USGS Gridfloat Satellite heightmaps into separate TILE files.
- jgc_vector - Wrapper class for DarkGDK vector entities
- jgc_vertinfo - Class for manipulating locked vertex data - tightly integrated in the two JGC exclusive terrain systems.

Screen Shots

Note: Still Working on organizing these.

Click Here for Larger Image	JGC_FRUSTRUMCULLING Example: This example shows how the frutrum class in the JGC library works regarding poly count by excluding objects and/or hiding limbs that are not on the screen. This demo specifically tests dynamic objects (ones that move, limb culling is effective for static objects only) and you can view the poly count jump or drop appropriately. DarkPhysics is in use in this demo: used so the camera (YOU the user) can fly into the heli's and bump them around in this ZERO gravity test environment.
Click Here for Larger Image	JGC_FRUSTRUMCULLING Example: This screen shot is from the FRUSTRUM REGIONS demo, and the demo source code shows HOW to create REGIONS but it doesn't go into to WHY so much. Why make a region? Why are they important? Frame Rates is the answer! Frustrum culling is the process of determining if an object (or object limb) is in the camera view or not, and showing the object/limb so its visible onscreen or hiding/excluding (best applicable method to gain frame rates) objects/limbs not on the screen so they are not being processed (or at least lighten the load) of the rendering the DarkGDK does each time the dbSync function is called. a problem arises when there are so many objects to check that it takes just as long or longer to check if they are in the frustrum or not than it would to just display them. This is how utilizing REGIONS can be advantageous. Simply put, Regions are an artificial "container" that you can place many objects in side of. If the "Region" is in the frustrum, then ALL the objects/limbs are made visible in one fast full swoop. If the region is not on the screen, then ALL the objects in it are hidden or excluded as appropriate in one fell swoop. This feature, if used properly, can definately improve framerates for a scene that otherwise wasn't using regions for things like... this group of trees.
Click Here for Larger Image	JGC_FRUSTRUMCULLING Example: This demo touches on something special about the JGC_FRUSTRUMCULLING class and its Node system. The frustrum culling class does more than CULL, it handles LOD, Bill boarding, Regions, and has built in QUADTREE support. The Game Creators latest newsletter, issue 76, discusses a billboarding technique for having alot of trees using one object consisting of many billboards. This would eliminate much of the "OBJECT" handling overhead in the rendering process. why do I bring this up? Because the JGC_FRUSTRUMCULLING class is the ideal place to implement such a system. Once you get used to it, it's hard to go back - because once you "Teach It" how to handle each thing in your game: physics, lod models, ranges, billboarding, offsets, frustrum preferences.... it does all the render leg work for you from then on.
Click Here for Larger Image	JGC_FRUSTRUMCULLING - Like JGC_PHYSICS, Sparky's, DarkPhysics all can display "Collision wireframes" or "Primitives", the JGC_FRUSTRUMCULLING class can show primitives too for debugging purposes. In this SHOT, I was debugging a QUADTREE "Level". There is a BIG boax around these trees, each of these trees is culled individually as well. So, when the Camera has the "BIG" box on screen, only then does it bother to work the trees in the BOX. Now, if I had a TON of trees in the box - I might consider making them part of a REGION. A Region allows you to CULL multiple objects with one frustrum check: used wisely they can help your game frame rates.
Click Here for Larger Image	JGC_FUNSTUFF Example: This screen shot shows two things from the FUNSTUFF files - 3D Menu 01 which is like being in a gerbil's running wheel and has keyboard, mouse click and mouse wheel navigation, LINES Tool - which allows you to use F1 thru F8 keys to move those white lines about and read the coordinates (Useful for getting screen regions like those used by the 3D menu.. this is a development shot). Also you'll notice a JGC_VMESH landscape in the background too with a water shader applied to a simple plain (two triangle quad). The Text drawn on the menu's is done using the JGC_BITMAPFONT and JGC_BITMAPTEXT classes using the function call that writes text directly to a JGC_PIXELGRID. The "Iron Infantry" text uses instances of the same JGC_BITMAPFONT and JGC_BITMAPTEXT class but utilizes the function that writes text to the screen with sprites: this allows the "Iron Infantry" text to float in front of all the 3D action happening "behind" it. If you aren't aware - Iron Infantry has been a pet project of mine (Jason) for over a year now that I have every intention of seeing through. If you want to see a pre-darkgdk executable of it in early development, its here for free: http://code.google.com/p/ironinfantrydbpro/ Yes, the JGC library is now a corner stone of Iron Infantry! Eventually you'll be able to go here: http://www.ironinfantry.com to see its progress but now the project progress is only available from here: http://www.jasonpetersage.com/?PAGE=ironinfantry&SECTION=ironinfantry you'll definately notice some cross over.
Click Here for Larger Image	JGC_GUI Example: This shot shows the JGC_GUI as well as some interior diagnostic information useful for debugging. You might recognize, if you have worked with DarkGDK or DarkBasic Sprites, that the ZOrder is actually a list of Sprite Priorities handling which window is in front of which. You might recognize the the tidy stacking of minimized windows along the bottom of the screen: this stacking is done for you as you'd probably expect.
Click Here for Larger Image	JGC_GUI Example: A user named elspin on the The Game Creators forum asked in this thread: http://forum.thegamecreators.com/?m=forum_view&t=129759&b=5 , questions about the GUI and how some things weren't working for him. After he explained what it was he was looking for (Mind you this is a version 2 screen shot), I put together a demo program matching what he was looking for. He seemed pretty happy with the result.
Click Here for Larger Image	JGC_GUI Example: This screen shot shows off the gui but also shows off one of the cool features it has. You see those rainbow looking boxes? Well... those are drawn only when the window is being painted in preparation to be displayed or updated. The message pump sends a message DURING the paint process so your window message handler function can be notified of the proper time to draw or copy custom media to the window before the controls are drawn. There is a message for after the controls are drawn also, but I'll leave that up to you to figure out something cool to use that for. In short though, you have alot of control over how windows look. Someone once commented how they look "Old Skool" - I smiled knowing full well this GUI is designed so that you can totally make any kind of window you want... Circle shaped windows, transparent, disconnected hovering controls - whatever. I know that developers want a GUI they can get up and running quickly - especially when getting started with a project. The "Eye Candy" usually comes later, so I made it a point to make sure that this GUI's appearance is extremely pliable. So take it for a spin. Impress the community by making your own skin so it's not even recognizable! If you need help - just ask in the forum.
Click Here for Larger Image	JGC_GUI Example: This colorful shot was actually pretty easy to make! 3 windows (One with a background image loaded from a graphic file containing the Jegas Logo), and a spinning cube. The message handler routine for this application waits for the "GotFocus" message that is sent when a window gets focus from clicking on it, when the message is received the code textures the spining cube with the image the window's sprite is using. Pretty simple eh? Simple, but this is one of our favorite screen shots of the GUI!
Click Here for Larger Image	JGC_GUI Example: Another GUI Shot with a spinning cube :)
Click Here for Larger Image	JGC_GUI Example: This shot shows clearly some features of the JGC_GUI and of the JGC_BITMAPTEXT class. First you can see that the GUI is reusing the JGC_BITMAPFONT and JGC_BITMAPTEXT classes. This kind of code reuse helps keep EXE file sizes down for sure. Secondly, you can see two techniques for rendering bitmap fonts to the JGC_PIXELGRID. One technique renders bitmap fonts how they are in meory - exactly like the media. The other technique allows you to dicate the color to use for the background, and the color to use for the foreground: this technique overrides multi-color text and generates simple two color output - as seen with the Arial black. Now you might dig in and say, "but the arial font is black in the media!". My response is to open a GUI demo with a textbox using the arial font, and change the foreground and background colors of the text box and give it a whirl. You'll see you have complete authority over the bitmap font rendering B^)
Click Here for Larger Image	JGC_GUI Example: Another GUI Screen Shot - early Development.
Click Here for Larger Image	JGC_JMESH Example: This image demonstrates how the JGC_JMESH terrain is put together and demonstrates how you can individually texture each limb. In version 3.x there are new UV functions for both JGC_JMESH and the JGC_VMESH terrain classes that make texturing with authority easy!
Click Here for Larger Image	JGC_JMESH Example: Shaderless Shading Experiment using the JGC_JMESH terrain class - Part #1
Click Here for Larger Image	JGC_JMESH Example: Shaderless Shading Experiment using the JGC_JMESH terrain class - Part #2
Click Here for Larger Image	JGC_JMESH Example: Shaderless Shading Experiment using the JGC_JMESH terrain class - Part #3
Click Here for Larger Image	JGC_JMESH Example: Shaderless Shading Experiment using the JGC_JMESH terrain class - Part #4
Click Here for Larger Image	JGC_JMESH Example: Shaderless Shading Experiment using the JGC_JMESH terrain class - Part #5
Click Here for Larger Image	JGC_JMESH Example: Shaderless Shading Experiment using the JGC_JMESH terrain class - Final Result. I'm looking forward to revisiting this and getting things even smoother. I think with some modifications to the USGSMapPaint function, I should be able to devise an even higher "texture splatting" resolution. Note this technique is not TRUE texture splatting, and is actually a procedural mixing of textures that ultimately finish with "tiles" of textures you apply to your terrain. This technique does use more memory for texture data, however it frees up the GPU from constantly processing the same data redundantly. You have to consider your application, intended audience and intended graphics hardware to devise the best solution for your own games or applications.
Click Here for Larger Image	JGC_PHYSICS integration wrapper for Tokomak Physics - This image is of the JGC Physics Primitives Demo and it shows the JGC's Tokomak Physics animated and Rigid Bodies in motion. When the JGC_DADDY class is instantiated and Tokomak Physics are enabled, the JGC_PHYSICS class is automatically created in the JGC namespace. From there you can access the integrated physics functionality.
Click Here for Larger Image	JGC_PHYSICS integration wrapper for Tokomak Physics - This image is of the JGC RagDoll Demo and shows the JGC's Tokomak Physics animated, rigid and joints in action. The JGC is already integrated with Tokomak: Initialization, Timer Based Updates, and Animated and Rigid Body. Joints however are not integrated, but as this demo shows, its possible to call the Tokomak Physics API directly and mix and match how you access it: JGC or Directly - Use the right tool for the job.
Click Here for Larger Image	JGC_PHYSICS integration wrapper for Tokomak Physics - Another RagDoll Demo Screen Shot
Click Here for Larger Image	JGC_PHYSICS Example: Here we have the vehicular fun demo which uses the integrated JGC physics primitives for the vehicle bodies, and directly calls the Tokomak API to get both Sensor (Form of raycast) functionality for where the "wheels" touch the ground and joint functionality for the Semi. when you try the demo, get into the semi, hitch up the trailer (H Key) then press the DELETE Key to lift the SEMI up. Especially using different observer views.
Click Here for Larger Image	JGC_PHYSICS Example: This is one of the early screen shots of the vehicular fun demo. This shows the BASIC car doing one of its first jumps! (I don't think it made it if I recall LOL)
Click Here for Larger Image	JGC_SKYDOME Example: This screen shot is of a skydome that is controlled by the JGC_SKYDOME class and it uses UV coordinates to "scroll" the clouds with timer based math for smoothness and the speed and direction is configurable.
Click Here for Larger Image	jgc_usgs USGSMapPaint Results: This shot is of the island Kauai in Hawaii. You are looking down on a 3D model containing well over a 600,000 poly here. How the shot was created: Aquiring the USGS GRIDFLOAT format of the satellite heightmap data of the island. The data set is rather large. A shader was selected for the texture blending: the shader used here supports four textures and blends them based on an alpha map. Select three textures to splat the island (not four because I wanted to keep one available for roads later). Create a program that does only one function call: USGSMapPaint. This is the exe I run to "create" the alpha map for the shader. Load the USGS height data into a game engine terrain system. Load the textures: Sand, Grass, Rock and the Alpha Map created in step 5 Load Shader and apply to terrain Take a screen shot because it looks neat! this island is 20 miles across I believe, and this shot was taken after zooming really high up and looking down. I wonder how HIGH in feet or meters up you'd have to be in life to see that much of the island at once.
Click Here for Larger Image	JGC_USGS Example of the USGSMapPaint function: This shot is one of my favorites. Look for the Hawaii Kauai island top view shot as a reference but this image is the alpha map used by the shader that did the texture splatting for that island shot. This graphic alpha map was created using a function located in the jgc_usgs.h file. It works like many terrain editors' Paint restraints: altitude, edge blending distance, angle restrictions - except its not a constraint! It allows you to procedurally paint the alpha map to your liking, and then use other tools for handpainting your particulars. Too much techno babble? Let me sum it up: The final result, that island shot, looks AWESOME! You should have seen it up close walking around in it!
Click Here for Larger Image	JGC_VMESH Example: This shot if of the "UV Groovy Demo" and shows both the poly arrangement for the JGC_VMESH as well as what the UV functions it offers allow you to do quite easily. One thing that is sometimes an annoyance is Z-Fighting. When you want to place a heli pad or a road on a terrain - you don't have to deal with zfighting if you can just texture the poly's in question directly. These routines make this sort of thing easier than trying to place a textured plain (or flattended cude) onto your terrain. Texture Splatting via shader is another way to handle this issue, but that's another technique altogether.
Click Here for Larger Image	JGC_VMESH Example: This shot is one of the first USGS height maps I loaded into the JGC_VMESH terrain. Since this shot was taken in Version 2.0, the code to work with these exceptionally accurate and readily available data sets has become even easier. Version 3.X houses more utility functions to help your terrain media creation workflow.
Click Here for Larger Image	JGC_VMESH Example: JGC_VMESH meets one of Green Gandalf's early terrain shaders. This shader works in a similiar fashion to the USGSMapPaint function found in the jgc_usgs file, except the shader naturally performs the algorythm in real time by leaning on the GPU. Don't let the distorted thumbnail throw ya, it's a pretty shot full size.
Click Here for Larger Image	JGC_VMESH Example: Here is another shot of a JGC_VMESH terrain using a shader for texture blending a terrain. The video card that was used fror this shot barely had the wherewithall to do it, but the shot still looks decent. I have found that on the older cards, utilizing the hardware pipeline often performs better than using shaders, while the newer cards eat shader code like its going out of style.