HOME ABOUT SCREENSHOTS DOWNLOADS PLAY

by munin, RTSan and zzorn

This page is meant to be a collection of ideas and descriptions of the tools used to generate and enhance game media. More will be added as we go.

Media Object Builder Scripts

Media Object Builder Scripts is a python scripting framework that allows generation of different aspects of media objects on the client when needed. It can be used to generate or load and modify/combine textures, meshes, sounds, animations, particle systems, and effects/behaviours/triggers that a media object consists of.

Game Object

A Game Object is an object representing some entity, or some abstract thing like a skill. They are stored on the server and manipulated by rule modules. The client interacts with some game objects in different ways. Some of the game objects have a location in time and space, and can be observed by characters. These game objects need to be rendered by the client, and for that tehy should provide a mediaObject and an appearance attribute.

Media Object

A Media Object is a client side object that is used to visualize a visible Game Object. It can have various different parts; texture, mesh, animations, sounds, particle systems, icon, textual description, sprite, triggers, etc. Different clients may use different parts, parts that are not needed need not be loaded/generated.

mediaObject Attribute

The mediaObject attribute of the Game Object contains the name of a python script that implements functions for generating or providing the different parts of a media object. The script name is relative to the media_objects/ directory in the media repository (so it contains any subfolders under media/media_objects/, and then the name of the script). E.g. "creatures/iceWolf.py", "humanoids/orc.py", "items/table.py", or "genericObject.py".

Media Object Builder Script

A Media Object Builder Script is a python script, that is required to have some standard functions, that the client calls to get the texture, mesh, animations, sounds, etc. to use. The functions may either return references to existing media files in the media repository, or create and return a texture/mesh/sound/etc. The functions are given some of the properties from the appearance attribute o the game object as input. It should also be possible to query the script for what parameters are used when creating the different parts of the media object, so that the client can regenerate that part when the parameters it uses changes. The script uses an API with special designed functions for manipulating textures, meshes, and other media object parts. The API has an optimized C++ or similar implementation, although a reference implementation in e.g. Java might be constructed first. The script should have access to very little else beside the media object manipulation API, in particular it shouldn't be able to read/write to files or use the network, for security reasons.

Parameters

The media object builder script uses named parameters provided by the appearance attribute of the game object when generating the media object. The appearance parameter can specify properties like hairColor, eyeColor, skinColor, age, woundAmount, isGiganticSize, hasThePox, isUndead, etc. The appearance parameters are often specific for certain media object types. The appearance parameters are set and changed by Rule Modules on the server for Game Objects. E.g. if the hit points of a creature changes, a rule module might change the woundAmount parameter in the appearance attribute to some value between 0 and 1, roughly reflecting the severity of the injury.

Default Parameters

Running the media object builder script without any parameters from the appearance attribute produces a default media object for that builder. It can be used as a placeholder media object, or if the builder uses no parameters.

Caching

The generated media object parts are cached on the client, and only re-generated if attributes they use change, or if they were thrown out of the cache and need to be regenarated. Strategies like waiting some time before regenerating after an attribute change can be used to reduce teh number of changes. The generation should also take place in a background thread. Until the generation is ready, the result of running the media object builder script with no parameters can be used as a placeholder media object.

Media Object Library

An utility library should be created, that handles running the media object builder scripts, caching the results, and recalculating media object parts when the attributes change. The library should also provide a placeholder media object while the actual one is being built, and should handle running the builder scripts in one (or several) separate threads. The client should just need to ask the library for a media object for a given game object, and allow the library to listen to changes in the appearance and mediaObject attributes of the game object, as well as getting some notification when game objects go out of sight (or their distance to the camera). The library returns a reference to a media object to the client. The media object parts may change as they are generated and the placeholders are replaced, the client should be able to listen to such changes.

Preview Tool

A preview tool should also be created, that allows the user to select a media object builder script, uses the utility library to generate the media object, and allows the user to change the appearance parameters on the fly, recalculating the media object. The user should also be able to send signals to the media object, using a similar system as the client when some animation or other effect of the media object should be triggered (the details of this need to be thought out in a separate media object specification). The preview tool should periodically check the media object builder script file to see if it has changed, if so, it should reload the builder script and regenerate the media object. This way the user can edit the script in a separate editor or IDE, and see the changes directly after saving, and also test out the effect of appearance parameters or different actions.

Character Generator

• Mesh generator
  The mesh generator module is at the very least a simple morpher, which potentially can be used for objects other than characters.
  

  **The simple morphing process**

  This is the simple process on which the morping is based

  1. Find the vertices that have changed position.
  2. Subtract the original vertices from the target vertices.
  3. Store the vector from step 2 (this should usually be much smaller then the whole mesh)

  **User interaction**

  This is how the user would do stuff...

  • You make a model in your favorite modelling app and export it in a convenient format - lets say that I have a model of a generic male and export it as obj or asc ( easier :) )
  • You open up the character generator and create a new class ( file/project? ) - I would name mine "Generic male" then.
  • Next you import the model - this will be the original or base model.
  • Then you modify the model in your modelling app - make a model of the generic male with a big nose for example. As this is only a simple morpher the vertex count should stay the same after the modifications.
  • Back in the character generator you create a new target by importing the newly modified mesh - the targets name could be "Big nose" in the current case
  • The simple morphing process takes place.
  • Now any user can open this class and modify the size of the nose using a slider called "Big nose". This slider will go from 0 to 1 or 0 to 100. Programming wise it would still be 0 to 1. The stored vectors are then scaled by this factor and added to the corresponding vertices on the original mesh. We could provide a way of typing in the scalar - so users CAN scale over 100% and use negative values. But the sliders will have limits.
  • After setting all the sliders you can export the model.

  **Scripts**

  There are two kinds of scripts:

  • *Simple* or specific scripts. These simply store the slider values.
  • *Advanced* or general/random scripts. These could have some sort of a scripting language. They provide the user with a randomly generated character every time they are run. Why do we need a script for this? Well...so we don't get absurd morphs. The user has to provide some criterion by which to morph. Otherwise you could have targets like "Small nose" and "Big nose" and the morpher would not know that it makes no sense to modify them both.

  **Advanced features**

  • Morphing could additionally be scaled by a map. Which means - users could paint morph weights.

• Other features could include selecting from a variety of meshes (heads, clothes etc) and textures

Texture Mixer

A great idea

Mercator Tools

Blah

Procedural Texture Blending

Blah

Procedural Trees

Blah

The content on this site is distributed under the terms of the
GNU Free Documentation License unless expressly stated otherwise.
Copyright © 1998-2008 of the authors of each page.