Worklog for sswift

Worklog 1

Return to Worklogs

Seamless Texture Generator2005-03-23
Check out the website here:
http://www.seamlesstexturegenerator.com

Or grab the demo, and some test images here:
www.seamlesstexturegenerator.com/STGDEMO.zip
www.seamlesstexturegenerator.com/testimages.zip

You may order it online here:
www.shareit.com/product.html?productid=300018902

Or via paypal.com by sending payment to hide_email('scswift@comcast.net') (scswift @ comcast.net)


Seamless Texture Generator is a tool for creating seamless textures from photographs quickly and easily, while retaining maximum image quality. It will save you hours of work. Make most textures seamless with a single click, while simultaneously correcting highlights and shadows!

For those textures which need a little more work, the program provides the ability to easily remove rotation/perspective, adjust or disable the automatic highlight/shadow removal, and change the amount of blending on each axis... Need a texture which tiles in one direction only? No problem!


Seamless Texture Generator - Turn photos into high-quality seamless textures!
MAX: Sprite System - Animate position, scale, rotation, color, alpha, frame, and order! Attach sprites to one another, and the child's properties and position adjust with the parent! | New Info! | Info | Info | Info
3D: Swift Shadow System - Cast soft projection-map shadows from animated meshes! | Info
3D: SwiftGUI - Make game-style interfaces with image-based fonts! | Info
3D: Swift Terrain System - Create fast and detailed terrains! | Info
Plus: SwiftBOBS - Draw and animate sprites! Five blending modes! | Info
Share*It | Paypal (See Share*It link for price details.)

Swift BOBS System2004-04-23
To purchase this system, go here:
www.blitzbasic.com/logs/userlog.php?user=963&log=267

To contact me for further information, email me at hide_email('scswift@comcast.net') (scswift @ comcast.net)



Demo:
http://www.seamlesstexturegenerator.com/systems/swiftbobs-demo-021.zip


The "Swift Blitter Object System" is a library designed for handling 2D sprites. These sprites, are referred to in the system as "BOBS", which is an homage to the term used for sprites on the Amiga.

With SwiftBOBs, creating 2D moving objects is made easy.

Just load your image, call CreateBOB(), and off you go. A single flag enables masking, if you use the default masking color.

And if you want, you can change the mask color for each BOB individually, or for a whole group of BOBS that use the same image, at once.

And this is just the tip of the iceberg.

Not only does the system make it simple to create sprites, but it supports every blending mode you get with 3D graphics in Blitz3D. Add, Multiply, Multiply x2... You can even do alpha blending if you specify an image to use as an alpha map.

Blending does come at a price however. It incurs a pretty significant performance hit. But it's there if you need it. Just don't expect to draw a hundred antialiased things at once.

You can also change the base color that the BOB's image is multiplied with, just like on an entity in Blitz 3D, and you can change the overall alpha of the BOB.

When not using the special blending modes, or the color shifting, or the alpha transparency, the system is lightning fast, as you can see in the demo. On my system I had 2000 24bit color 30x30 masked sprites moving around at 60fps. So when blitting normally you get no less than you have come to expect from Blitz.

To achieve maximum performance, the system has FOURTEEN seperate blitting functions, each one optimized for a specific task. A normal blit uses the standard image blitting functions which are super fast, while the special blending modes use highly optimized functions specifically designed for each combination of blending operations.

Here is a list of all the functions included in the system: (minus the internal blending functions)


InitializeBOBS()

CreateBOB.BOB(Image, Flags=1)
FreeBOB(ThisBOB.BOB)

BOBBlend(ThisBOB.BOB, BlendingMode)
BOBAlpha(ThisBOB.BOB, Alpha#)
BOBAlphaMap(ThisBOB.BOB, AlphaMap)
BOBColor(ThisBOB.BOB, Color_R, Color_G, Color_B)
BOBMask(ThisBOB.BOB, Mask_R, Mask_G, Mask_B)
MaskBOBS(Image, Mask_R, Mask_G, Mask_B)
BOBOrder(ThisBOB.BOB, Order)
BOBFrame(ThisBOB.BOB, Frame)
BOBFlags(ThisBOB.BOB, Flags)

ShowBOB(ThisBOB.BOB)
HideBOB(ThisBOB.BOB)

PositionBOB(ThisBOB.BOB, Position_X#, Position_Y#)
TranslateBOB(ThisBOB.BOB, Offset_X#, Offset_Y#)

SetViewport(X1, Y1, Width, Height)

UpdateBOBS()

BOBS_Overlap(FirstBOB.BOB, SecondBOB.BOB)
BOBS_Collide(FirstBOB.BOB, SecondBOB.BOB)
BOB_RectOverlap(ThisBOB.BOB, Rect_X, Rext_Y, Rect_Width, Rect_Height)
BOB_RectCollide(ThisBOB.BOB, Rect_X, Rext_Y, Rect_Width, Rect_Height)

BOBX#(ThisBOB.BOB)
BOBY#(ThisBOB.BOB)


Now that you've read about it, try the demo, and see for yourself. Most functionality is represented in the demo,
and there's lots of options to play with.

I have included one demo compiled in Blitz3D, and one compiled in BlitzPlus, so that you can see the perfromance differences between the two.

I highly reccomend you use BlitzPlus if you're going to make a 2D game that uses any special blending modes, but both BlitzPlus and Blitz3D are extremely fast with regular masked blitting.

By default the demo has triple buffering enabled. This improves the performance of blending operations in Blitzplus, but slows down normal masked blitting (Blend mode 1). Try disabling triple buffering when in mode 1 to see how fast the system can go if you don't use the special software based blending modes. Triple buffering has no effect on Blitz3D.


To purchase this system, go here:
www.blitzbasic.com/logs/userlog.php?user=963&log=267

To contact me for further information, email me at hide_email('scswift@comcast.net') (scswift @ comcast.net)


Seamless Texture Generator - Turn photos into high-quality seamless textures!
MAX: Sprite System - Animate position, scale, rotation, color, alpha, frame, and order! Attach sprites to one another, and the child's properties and position adjust with the parent! | New Info! | Info | Info | Info
3D: Swift Shadow System - Cast soft projection-map shadows from animated meshes! | Info
3D: SwiftGUI - Make game-style interfaces with image-based fonts! | Info
3D: Swift Terrain System - Create fast and detailed terrains! | Info
Plus: SwiftBOBS - Draw and animate sprites! Five blending modes! | Info
Share*It | Paypal (See Share*It link for price details.)

Flux2004-04-15
Flux is a Blitz library for animating the positions, scale, and rotation of entities in Blitz in simple ways that are useful for menus, powerups, etc.

You can transform them linearly, with acceleration, with deceleration, or with acceleration then decelrationusing a cosine curve.

You can play these animations between two positions/orientations/scales in a one shot, looped, or ping-pong animation.

There's 101 uses for this lib in any game, and like anibrush, it's FREE! Just email me for your copy.


Seamless Texture Generator - Turn photos into high-quality seamless textures!
MAX: Sprite System - Animate position, scale, rotation, color, alpha, frame, and order! Attach sprites to one another, and the child's properties and position adjust with the parent! | New Info! | Info | Info | Info
3D: Swift Shadow System - Cast soft projection-map shadows from animated meshes! | Info
3D: SwiftGUI - Make game-style interfaces with image-based fonts! | Info
3D: Swift Terrain System - Create fast and detailed terrains! | Info
Plus: SwiftBOBS - Draw and animate sprites! Five blending modes! | Info
Share*It | Paypal (See Share*It link for price details.)

Anibrush2004-04-15
Anibrush is a Blitz library desgined for animating brushes between two sets of values.

With the system, you can animate color, alpha, shininess, and texture. You can also set the blend and FX parameters.

You have three modes of animation to choose from with the system. One shot, which plays the animation once, loop, which loops the animation continously, and ping pong, which plays the animation forwards and backwards in a loop.

All the commands are simple variations on the Blitz Brush commands, so you work with commands like ANI_CreateBrush, ANI_BrushColor, ANI_BrushAnimMode, etc.

You set all the brush parameters with functions just like you would set up a normal brush, but when setting parameters like color, you specify two sets of values for the start and end of the animation.

The main difference between this system and the regular brush system is that each loop you need to call ANI_Update(), and you must "unpaint" an entity before you delete it if it has been painted with an AniBrush.

With this system you can also paint both entities and surfaces just as with a regular brush.

Here is a complete list of commands available within ths system:

ANI_CrateBrush
ANI_CopyBrush
ANI_PaintEntity
ANI_PaintSurface
ANI_UnpaintEntity
ANI_UnpaintSurface
ANI_Update
ANI_BrushAnimLength
ANI_BrushANimMode
ANI_BrushColor
ANI_BrushAlpha
ANI_BrushShininess
ANI_BrushBlend
ANI_BrushTexture
ANI_BrushFX
ANI_FreeBrush
ANI_LERP
ANI_InverseLERP

The last two function are math functions which are used by the system, and which you might find useful. They allow you to do a linear interpolation between two values, and determine where between two values a third value is.

Also, note that like regular brushes, you can delete an AniBrush at any time without worrying about whether entities have been painted with them. You can also modify an AniBrush at any time without affecting the entities which have been painted with the brush previously.

In short, AniBrushes behave exactly as you would expect an animated version of Blitz's brush system to behave!

Here is a small demo showing the system in action:
home.earthlink.net/~sswift/anibrush.zip

The demo comes with source code which shows how you would use the system in an actual game.

This system is FREE! Free to use in commercial or non-commercial projects, and free to distribute.

Email hide_email('scswift@comcast.net') (scswift @ comcast.net) to request your copy!


Seamless Texture Generator - Turn photos into high-quality seamless textures!
MAX: Sprite System - Animate position, scale, rotation, color, alpha, frame, and order! Attach sprites to one another, and the child's properties and position adjust with the parent! | New Info! | Info | Info | Info
3D: Swift Shadow System - Cast soft projection-map shadows from animated meshes! | Info
3D: SwiftGUI - Make game-style interfaces with image-based fonts! | Info
3D: Swift Terrain System - Create fast and detailed terrains! | Info
Plus: SwiftBOBS - Draw and animate sprites! Five blending modes! | Info
Share*It | Paypal (See Share*It link for price details.)

The Swift Terrain System2004-04-15
To purchase this system, go here:
www.blitzbasic.com/logs/userlog.php?user=963&log=267

To contact me for further information, email me at hide_email('scswift@comcast.net') (scswift @ comcast.net)



The Swift Terrain System is a system designed for rendering highly detailed terrains utilizing multiple textured and lightmapped meshes with dynamic level of detail management.

This is a demo of my terrain system which you can license for use in your games:
Swift Terrain System Demo

The demo contains some example source code demonstrating how the system is used.


How it works:
-------------
The terrain system constructs it's terrains out of a series of tiles, each which is a discreet mesh which can have it's own texture. For each tile, you can flip the texture so that you can dramatically reduce the number of textures you need. You can also apply a lightmap seprately from the textures which is stretched over the entire terrain.

The system manages the level of detail at each tile replacing them with lower detail meshes as the tile receeds into the distance. This allows very long view distances with high levels of detail, while maintaining a polygon count of between 10,000 to 50,000 polys per frame. You can change parameters to decide where you want the detail to be, what kind of view distance you want, and you can even change the mesh detail on the fly in your game to a lower detail level instantly.


Known Issues:
-------------
You should be aware that currently there can be cracking between tiles. You can reduce the visiblity of this if you use a dark background for the lower half of the sky, or if you, like in my demo, move the distant tiles downward slightly. Also, there will be visible popping of new tiles in the distance if the fog is not heavy enough to cover them up completely, or if you do not scale them vertically like I have also done in the demo. This scaling and moving of tiles which I do in the demo comes at the cost of potentially causing distant objects to appear to float above the terrain. If your game has lots of flying enemies, this will not be a problem, and you can also use autofade to fade distant enemies out before they start to visiblity float above the ground which you should probably do anyway to avoid haivng too many enemies visible at once. But the option is there to remove that scaling and motion if you need to.


To purchase this system, go here:
www.blitzbasic.com/logs/userlog.php?user=963&log=267

To contact me for further information, email me at hide_email('scswift@comcast.net') (scswift @ comcast.net)


Seamless Texture Generator - Turn photos into high-quality seamless textures!
MAX: Sprite System - Animate position, scale, rotation, color, alpha, frame, and order! Attach sprites to one another, and the child's properties and position adjust with the parent! | New Info! | Info | Info | Info
3D: Swift Shadow System - Cast soft projection-map shadows from animated meshes! | Info
3D: SwiftGUI - Make game-style interfaces with image-based fonts! | Info
3D: Swift Terrain System - Create fast and detailed terrains! | Info
Plus: SwiftBOBS - Draw and animate sprites! Five blending modes! | Info
Share*It | Paypal (See Share*It link for price details.)

The Swift Shadow System2004-04-15
To purchase this system, go here:
www.blitzbasic.com/logs/userlog.php?user=963&log=267

To contact me for further information, email me at hide_email('scswift@comcast.net') (scswift @ comcast.net)



The Swift Shadow System is a Blitz library designed for casting realtime shadows from animated and static meshes onto arbitrary geometry.

NOTE, MD2 meshes are not at this time supported.

B3D bone animated meshes and 3DS segmented animated meshes are both supported.

In plain english, my shadow system can cast multiple shadows from your animated characters onto your level. It can also cast shadows from static objects placed in your level to add detail, such as a desk.


Here is a demo of the system in action, with a number of options to play with:
Swift Shadow System Demo


How it works:
-------------
The system provides three diffrent types of shadows for maximum efficiency. The first two types are dynamic shadows. dynamic shadows change every frame, warping to fit the local level geometry as your object moves around. Of these two, there are rendered shadows, and textured shadows.

Rendered shadows are the most processing-intensive types of shadows. A rendered shadow is created by making a texture that approximates the shape of the object that is casting the shadow, and then applying it to the level surface.

Textured shadows on the other hand are cheats. Textured shadows take a premade texture you specify and project it onto the level. You can use textured shadows to cast round shadows from your characters that deform around geometry. Textured shadows are therefor a lot faster than rendered shadows.

The last shadow type is static. And thus they are called static shadows. Static shadows once rendered are never updated, though can be deleted and recreated on an as-needed basis. Static shadow use rendered shadow maps just like rendered shadows, and so are realistic looking. However, once rendered a static shadow never changes. It is always rendered with the same shadow map, and always to the same polygons, unless you delete it. This makes static shadows very fast, and appropriate to use throughout your world to make level decorations like desks, trees, and buildings cast shadows. The cost of a static shadow is merely the cost of an additional entity, a few extra polygons, and a texture.

In addition to supporting diffrent types of shadows to speed rendering, my shadow system also has several important optimizations. The most basic of which is the light radius.

When you want to create a shadow with my shadow system you specify every obejct that you want to cast shadows, every object that you wan tto recieve shadows, and every object that you want to be a shadow casting light.

For each of these light sources, you can specify a max radius of effect. Any object outside this radius will not cast a shadow for that specific light. This allows you to fill you level with lights and automatically cast shadows from only those nearest the player.

The second more advanced optimization the system does is that is re-renders shadow maps for dynamic rendered shadows only when the angle between the caster, receiver, and light source has chnaged enough that the shadow map has become too inaccurate a representation of the ideal real shadow. This cuts the amount of times the shadow map needs to be re-rendered greatly, and if neither the caster, light source, or receiver are moving at a particular moment then the shadows will render much more quickly than if any of the three are moving at a high rate of speed.

Below you will find a demo of the system, with a number of options you can play with. Take a look at it, and note that the demo has a high number of casters and receivers... More than you are likely to have in one room at one time in many types of game. So the demo is something of a stress test.


Known issues:
-------------
Note that if you double the number of recivers, the number of casters, or the number of lights, then you double the amount of work which needs to be done on a particular scene. That is why you will notice a drop in framerate when you have two lights flying around. Not only are the lights moving quickly, requirng the shadow maps to be re-rendered almost every frame, but you double the work when you add the second one! In many games, you're much more likely to have several NON-MOVING light sources in a room, and characters which move relatively slowly. So this demo is not neccessarily an accurate picture of what the speed will be like in your particular game.

Also note that the shadow system will work better if your level is broken up into several sections made with individual entities. This is how you should construct your levels anyhow for optimal rendering with modern 3D cards. Doing this allows the system to cull whole groups of polygons with simple boundign sphere tests.

Another thing to be aware of is that this system can only cast shadows ont static meshes. The meshes can rotate and move around, and you can even move the vertices around menaully. But you cannot cast a shadow onto a vertex/bone animated MD2 or B3D. You also cannot cast shadows onto terrains because they too animate their vertices internally to the Blitz 3D engine in such a way that you cannot access their changing locations.

You CAN of course cast shadows from B3D and 3DS animated meshes.

One last issue to be aware of is that with a frame tweening based setup, and a light source which is close to the objects being shadowed, the motion of the shadows over the surfaces may not be completely smooth. If you move the light source farther away, or use a delta time based system, then this will not be an issue.

So check out the demo, and the source code that accompanies it. The source code demonstrates how simple the calls are to activate the shadow system, and gives you a good idea of how well commented and formatted the shadow system source itself is.



To purchase this system, go here:
www.blitzbasic.com/logs/userlog.php?user=963&log=267

To contact me for further information, email me at hide_email('scswift@comcast.net') (scswift @ comcast.net)


Seamless Texture Generator - Turn photos into high-quality seamless textures!
MAX: Sprite System - Animate position, scale, rotation, color, alpha, frame, and order! Attach sprites to one another, and the child's properties and position adjust with the parent! | New Info! | Info | Info | Info
3D: Swift Shadow System - Cast soft projection-map shadows from animated meshes! | Info
3D: SwiftGUI - Make game-style interfaces with image-based fonts! | Info
3D: Swift Terrain System - Create fast and detailed terrains! | Info
Plus: SwiftBOBS - Draw and animate sprites! Five blending modes! | Info
Share*It | Paypal (See Share*It link for price details.)

The Swift GUI System2004-04-15
To purchase this system, go here:
http://www.blitzbasic.com/logs/userlog.php?user=963&log=267

To contact me for further information, email me at hide_email('scswift@comcast.net') (scswift @ comcast.net)



The Swift GUI for Blitz3D is a library of functions designed to allow you to create super-fast user interfaces and heads-up displays quickly and easily!

This system allows you to do much more than simply overlay sprites with alpha transparency on top of your 3D scene. Read on for more info, and while you're reading, download the demo here:

Swift GUI Demo - 700K


Super fast bitmap fonts:
------------------------

This sytem has functions for loading and displaying text using bitmap fonts, which are much faster than using the standard text commands in Blitz in a 3D scene.

You can lose up to half your framerate by using a REGULAR font! But this system renders text lightning fast.

In advanced terms, the system uses one surface per text object, per font texture. The system can load fonts packed into a single texture, or for greater detail, it can make use of fonts which use multiple textures.

The text commands use the MOST OPTIMISED method available for putting the text on the screen. A text object can be a an entire page of text, all contained within a single entity with a single surface. Or, if more detailed multi-texture fonts are used, then there may be 3-4 surfaces per text object. Either way, there's so few surfaces for all those letters that you will see almost zero impact on your framerate, save for what you'd normally see for having an overlay of that size on top of your scene.

The text commands also allow you to WRAP text at a certain width, with no word-splitting, and you can choose a variety of ways to align the text with it's handle, just as with the TEXT command in Blitz.


Heath bars/fuel gauges/spedometers/magic meters:
------------------------------------------------

The system also contains two types of object called a "databar" and a "dataarc". Databars are rectangular, whereas Datarcs curve around in a circle of a specified radius. Both can change length and color accoridng to their current "value", which you set the minimums and maximums for.

As you can imagine, Databars and Dataarcs have a TON of potential uses, and can be used in almost any game.


Object grouping/ordering:
------------------------

When you create GUI objects, each object is assigned to a specific group. These groups are collections of objects, and with the special GUI_HideGroup and GUI_ShowGroup commands, you can hide and show all the objects in a specific group. This allows you to make all the interface elements for each menu part of a unique group and hide or show them all at once with a single command. This comes in especially handy if you 're making an RPG hand have numberous heads-up displays that pop up, like inventory or spell-selection boxes, which you want to be able to dismiss selectively.

Also, with GUI_ObjectOrder, you can specify the order in which all your objects render, so that you can ensure that the mouse cursor always draws over everything in the scene, and the background on your inventory window draws behind everything else.


Specialized mouse commands:
---------------------------

The Swift GUI system, in addition to containing commands to create and manipulate graphical user interface elements, also contains commands that allow you EASILY create interactivity using said elements!

Polygon-perfect mouse commands that work with any of the user-interface objects allow you to easily determine when the mouse has moved into or out of an object's region, or whether the mouse is currently hovering over an object.

These may not seem like much, but with these commands the objects the system created can be made interactive easily! I have chosen to give you these commands rather than commands to create things like buttons and toggle switches because commands to create those things would greatly limit what you can do with them, and what actions they can perform when moused over. What if you want your buttons to jump up and down when the user mouses over them? With one standard command to create a button, you're limited to a boring interface that performs only basic changes in appearance to the objects when their state changes, and you don't have easy control over keeping said objects from activating at inopportune times, or keeping your actions on said objects from affecting the rest of the game. For example, what if you created a button that represents a sheild, on top of an inventory box that you can also select, on top of your game which uses the left mouse button to fire? You need fine control over when buttons actually activate, and when they take precendence over gameplay input, and a function to create a simple buttom won't do that for you.

These mouse functions provide you with everything you need though. Check out these code examples for creating interactive objects. With the specialized mouse commands, things are a breeze, and you keep all the control you need to make your game run smoothly!

This example code demonstrates how to create an object which animates when the mouse moves onto it, and turns off the animation when the mouse moves away:

format_code('
If GUI_MouseEntered(GUI_Smiley)

ANI_PaintEntity(GUI_GetObjectEntity(GUI_Smiley), AniBrush02)

Else

If GUI_MouseExited(GUI_Smiley)

ANI_PaintEntity(GUI_GetObjectEntity(GUI_Smiley), AniBrush01)

EndIf

EndIf
')


And here is some example code which creates an object which toggles it's appearance when clicked on:

format_code('
Mouse_Hit = MouseHit(0)

If GUI_MouseOver(GUI_Smiley) And Mouse_Hit

Smiley_Active = Not Smiley_Active

If Smiley_Active

PaintEntity(GUI_GetObjectEntity(GUI_Smiley), BRUSH_SmileyActive)

Else

PaintEntity(GUI_GetObjectEntity(GUI_Smiley), BRUSH_SmileyInactive)

EndIf

EndIf
')


Combine these two, and you have a standard user interface button which glows when you move the mouse over it, and is greyed out when you move the mouse away, and which allows you to click on it to change it's state from checked to unchecked, or simply, start the game. And by finishing up by playing a sound when any of these actions is triggered, you will have created a truly professional quality user-interface element in your game.

Interface elements that are fun to interact with make your game more fun to play, and add value to it!

You may notice some ANI_ commands in the above...

When combined with my FREE Anibrush system, provided at your request with the system, you can create truly professional quality animated buttons and interface elements with ease! Check out my next worklog entry for information on that system! When purchasing my GUI system, request the AniBrush system as well, and make your interfaces really shine!


Command list:
-------------

Here is a complete list of functions the system provides to you:

GUI_Initialize()
GUI_Destroy()
GUI_HideGroup(Group)
GUI_ShowGroup(Group)
GUI_SetGroup(Group)
GUI_SetFont(NewFont.GUI_Font)
GUI_SetFontHeight(Height#)
GUI_CreateText.GUI_Object(TextX#, TextY#, Message$, CenterX=False, CenterY=False, Wrap_Width#=65535)
GUI_CreateSprite.GUI_Object(X#, Y#, Width#, Height#, U1#=0, V1#=0, U2#=1, V2#=1)
GUI_CreateDataBar.GUI_Object(XPos#, YPos#, Thickness#, Length#, MinR=255, MinG=255, MinB=255, MaxR=255, MaxG=255, MaxB=255, Startvalue#=1.0, Justify=0, Orientation=0)
GUI_CreateDataArc.GUI_Object(XPos#, YPos#, InnerRadius#, OuterRadius#, ArcLength#, MinR=255, MinG=255, MinB=255, MaxR=255, MaxG=255, MaxB=255, Startvalue#=1.0, Direction=0, Segments=16)
GUI_FreeObject(ThisGUIObject.GUI_Object)
GUI_PositionObject(ThisGUIObject.GUI_Object, XPos#, YPos#)
GUI_ScaleObject(ThisGUIObject.GUI_Object, Scale_X#, Scale_Y#)
GUI_ObjectOrder(ThisGUIObject.GUI_Object, Order)
GUI_GetObjectEntity(ThisGUIObject.GUI_Object)
GUI_SetString(ThisGUIObject.GUI_Object, NewMessage$, ForceUpdate=False)
GUI_SetValue(ThisGUIObject.GUI_Object, NewValue#)
GUI_SetDataColors(ThisGUIObject.GUI_Object, MinR#, MinG#, MinB#, MaxR#, MaxG#, MaxB#)
GUI_CorrectCameraFOV(ThisCamera)
GUI_CreateSpriteMesh(U1#=0, V1#=0, U2#=1, V2#=1)
GUI_LoadFont.GUI_Font(File_Prefix$, File_Suffix$, Character_Set$, Characters_Per_Line, TextureFlags)
GUI_MouseOver(ThisGUIObject.GUI_Object)
GUI_MouseEntered(ThisGUIObject.GUI_Object)
GUI_MouseExited(ThisGUIObject.GUI_Object)
GUI_ProjectedX#(ScreenX#)
GUI_ProjectedY#(ScreenY#)
INTERNAL_SetDataBarValue(ThisGUIObject.GUI_Object, NewValue#, ForceUpdate=False)
INTERNAL_SetDataArcValue(ThisGUIObject.GUI_Object, NewValue#, ForceUpdate=False)
INTERNAL_SetDataBarColors(ThisGUIObject.GUI_Object, MinR#, MinG#, MinB#, MaxR#, MaxG#, MaxB#)
INTERNAL_SetDataArcColors(ThisGUIObject.GUI_Object, MinR#, MinG#, MinB#, MaxR#, MaxG#, MaxB#)
INTERNAL_CreateTextMesh(ThisFont.GUI_Font, TextString$, CenterX=False, CenterY=False, Wrap_Width#=65535, Mesh=0)



To purchase this system, go here:
http://www.blitzbasic.com/logs/userlog.php?user=963&log=267

To contact me for further information, email me at hide_email('scswift@comcast.net') (scswift @ comcast.net)


Seamless Texture Generator - Turn photos into high-quality seamless textures!
MAX: Sprite System - Animate position, scale, rotation, color, alpha, frame, and order! Attach sprites to one another, and the child's properties and position adjust with the parent! | New Info! | Info | Info | Info
3D: Swift Shadow System - Cast soft projection-map shadows from animated meshes! | Info
3D: SwiftGUI - Make game-style interfaces with image-based fonts! | Info
3D: Swift Terrain System - Create fast and detailed terrains! | Info
Plus: SwiftBOBS - Draw and animate sprites! Five blending modes! | Info
Share*It | Paypal (See Share*It link for price details.)

How to purchase a system.2004-04-15
If you would like to license one of my systems to use in your games, then you're in the right place!

You have two licensing options. You can either license a system for use in shareware/free games, or you can license it for use in commercial titles.

* With a shareware license you get a limited amount of tech support, and may use the system in as many shareware games as you like.
* With a commercial license you get a lot more tech support, my eternal gratitude, and may use the system in as many commercial games as you like.

Current prices may be found on the Share*It order page here:
http://www.shareit.com/product.html?cart=1&productid=208046&languageid=1&currencies=USD

When you consider that most of my systems took several weeks to write, and were optimized and debugged over the course of months, I think you'll find these prices quite reasonable.




To send payment, you have several options:


Share*It - The easiest method:
http://www.shareit.com/product.html?cart=1&productid=208046&languageid=1&currencies=USD


Paypal - Good if you have a paypal account with some cash already in it:
To pay via paypal go to www.paypal.com and send payment to the user hide_email('scswift@comcast.net') (scswift @ comcast.net)


Bank transfer - If you don't have a creidt card accepted by paypal or Share*It:
Transfer money directly from your account to my account. Go to your bank and ask about this option. It's quite simple to do.


Western Union - A last resort. Very inconvenient:
www.westernunion.com


Personal check by snail mail - Also a last resort:
Make checks out in US dollars ONLY. (Otherwise it takes six weeks to clear!) Email me for my address if you wish to use this payment method.


Once I receive confirmation of payment, I email the system to the email address you specify, unless you specify an alternate email address.
Please include your email address in any comment forms when paying, just in case.


If you have any questions about the systems or methods of payment, you may email me at hide_email('scswift@comcast.net') (scswift @ comcast.net)

Seamless Texture Generator - Turn photos into high-quality seamless textures!
MAX: Sprite System - Animate position, scale, rotation, color, alpha, frame, and order! Attach sprites to one another, and the child's properties and position adjust with the parent! | New Info! | Info | Info | Info
3D: Swift Shadow System - Cast soft projection-map shadows from animated meshes! | Info
3D: SwiftGUI - Make game-style interfaces with image-based fonts! | Info
3D: Swift Terrain System - Create fast and detailed terrains! | Info
Plus: SwiftBOBS - Draw and animate sprites! Five blending modes! | Info
Share*It | Paypal (See Share*It link for price details.)