Category Archives: 3D

Amiga Memories

This blog remained silent for too long. As I’ve been rather busy lately, I’ll adopt the shortest Input/Output style for this post πŸ™‚

Amiga

 

The recent project (purely hobbyist project, that said) that occupied me during the past weeks is centered on the old computer Commodore Amiga.

The input of the video sequence below are (basically) :

– The GameStart3D game engine.
– The MaryTTS text to speech engine.
– A few 3D models borrowed to friends or made by myself.
– The following squirrel script :

The output is the video sequence below :

 

What I did is more or less an automated talking box, some sort of “Max Headroom” inside an Amiga. This sequence is automatically generated, frame by frame.

More to come … stay tuned πŸ™‚

Preparing a trailer for Astlan

Today, as we have planned a walk to the Aerotrain’s test site, I decided to bring my iPhone and a tripod.
The Aerotrain railway makes a perfect landscape to create a fun & intriguing trailer for my (almost finished) game ‘Astlan’.

For the record, the Aerotrain prototype was designed during the 70’s as an high-speed alternative to the regular railways. A test site running on 25km, made of a concrete rail was built in order to test this prototype (max speed recorded was around 400km/h).

Nowadays, only the concrete rail remains, making a perfect place for urban exploration.

Here are a few mockups I made of the kind of framing I want to shoot once on the site. We’ll see if the final result is close enough. Or not πŸ™‚

Ideas for my next project

While it is too early to expose here the idea I have regarding my next game project, I can say it will involve robots…animated robots.

The challenge here will be to animate the robots using a procedural technique as I want them to be able to place their hands randomly.

For this purpose I will probably use two things :

1. This robot I modeled years ago (here in a shameless photoshopping)

20120106-231343.jpg

2. The physic engine of GameStart, and especially joints, to assemble a sort of ragdoll, so that I shall only need to animate the hands if I want to move the arms πŸ™‚

Stay tuned.
I need to finish and release Astlan first, anyway!

GameStart3D : an introduction to the Shader Tree

What is this Shader Tree thing all about ?


Since its first beta release, GameStart came with an internal abstraction to handle materials (aka shaders). One of the major improvements of the latest release (namely GS Beta 6) is the ability to edit & create a shader with a comprehensive and visual editor.


A basic tree example.

The main benefit of this abstract representation of a shader appears when it comes to port your project & assets to several platforms. No matter its complexity, a shader designed with the Shader Tree editor is fully portable. Each node is basic and independent from any kind of hardware implementation.

As a testbed, and to demonstrate how straightforward and powerful this Shader Tree editor can be, I spent half a day to design random materials. The result is shown below :


A grid of experiments with the shader tree.

Animated Shaders


One of the funny features is a clock node, that allows the user to inject a clock tick inside a shader. Use it to scroll your UV coordinates, to blend colors along time, and so on. Here’s a video capture showing various use of this feature :


The same thing in motion.

Here you are, boys & girls. Feel free to download the source file below, and enjoy !!!

MGT Project DevLog #4

Game Items

There’s no adventure game without powerups, keys and doors. For this prupose, I needed a generic class that handles the basic operations on items :
– the item knows when it interacts with the player and calls the proper method/function.
– the item can be picked, destroyed, unlocked, and this state should remain if the player left the room.
– the item can increase the vitals/energy/shield of the player, or appear in the game inventory

To perform these actions, and any other kind of possible future needs, I wrote a very simple class called ‘GameItem


//--------------
class GameItem
//--------------
{

item_trigger = 0
inside_trigger = false

enabled = true

project_script = 0

tank = 0
tank_script = 0

function OnUpdate(item)
{
if (!enabled)
return

if (tank == 0)
{
tank = SceneFindItem(ItemGetScene(item), “tank”)
tank_script = ItemGetScriptInstanceFromClass(tank, “SteamTank”)
}
else
{
// Test the player against the trigger
if (item_trigger != 0)
{
if (TriggerTestItem(item_trigger, tank))
{
if (!inside_trigger)
{
print(“GameItem::OnUpdate() tank inside”)
ItemTaken(item)
inside_trigger = true
}
}
else
inside_trigger = false
}
}
}

function ItemTaken(item)
{
print(“GameItem::ItemTaken() – Stub method called.”)
}

function OnSetup(item)
{
print(“GameItem::OnSetup(” + ItemGetName(item) + “)”)

local _item_trigger
_item_trigger = ItemGetChild(item, “item_trigger”)
if (ObjectIsValid(_item_trigger))
item_trigger = ItemCastToTrigger(_item_trigger)

project_script = ProjectGetScriptInstance(g_project)
enabled = project_script.GetItemStateEnabled(item)

if (enabled)
Enable(item)
else
Disable(item)
}

function Enable(item)
{
print(“GameItem::Enable(” + ItemGetName(item) + “)”)

ItemActivateHierarchy(item, true)
enabled = true
project_script.SetItemStateEnabled(item, true)
}

function Disable(item)
{
print(“GameItem::Disable(” + ItemGetName(item) + “)”)

ItemActivateHierarchy(item, false)
enabled = false
project_script.SetItemStateEnabled(item, false)
}
}

Basically, when setup, the class will look for a trigger parented to the main item. Then, during the update loop, the class will test the player against the trigger. If the item is triggered by the player, a stub method ItemTaken() is called.

Based on this generic class, I can derive (or extend) any kind of specific class, and overload the ItemTaken() method.

The class also provide two methods to enable and disable the item and its children. This is very handy when it comes to hide several items and lights. When disabled, the state of the item will be stored by the project, so that the item will know if it is enabled or not in case the player exits then enters the room again. Here, all the state logic is handled by two accessors methods I wrote directly in the project script : SetState() and GetState()

Here’s an example of a typical ‘power up’ class inherited from the base GameItem class. You will note how the ItemTaken() class is overloaded in order to perform the proper action : here it increases the shield level of the player.


class ShieldCellItem extends GameItem
{

function OnUpdate(item)
{
base.OnUpdate(item)
}

function ItemTaken(item)
{
print(“ShieldCellItem::ItemTaken()”)
tank_script.ShieldUp()
Disable(item)
}

function OnSetup(item)
{
base.OnSetup(item)
}

}

 

The Inventory

Some items can be picked and must be kept by the player. In this purpose, they will invoke another class called Inventory. At the moment the implementation of this class is really basic. It is more or less a few accessors to handle an array that contains the game items picked by the player.


class Inventory
{
inventory = 0

constructor()
{
inventory = []
}

function AddItem(item_name)
{
inventory.append(item_name)
}

function RemoveItem(item_name)
{
print(“Inventory::RemoveItem(” + item_name + “)”)

local idx, val
foreach(idx,val in inventory)
if (val == item_name)
{
inventory.remove(idx)
return true
}

return false
}

function FindItem(item_name)
{
local i
foreach(i in inventory)
if (i == item_name)
return true

return false
}
}

 

Video Capture

The following video shows the player that grabs several items (a powerup and a key), opens a first door, unlock a second door with the key he just grabbed. The key is marked as a X in the inventory, you can see it appear, the disappear when used.

Trying to model an outdoor scene.

All these dark level designs I previously started made me feel a bit gloomy… Going outside for a bicycle ride, and visiting the huge city of Berlin, I felt I should imagine something less confined, so I started to doodle this open air design.

I tried to imagine some sort of lost ruin, up in the sky, that the player would reach through a long way made of traps & elevators.

no images were found

no images were found

The screenshots were grabbed directly from the engine, with infinite shadow maps & SSAO, yaye πŸ™‚