Game pipelines is all about integration. You have to integrate many different tools, and many of different data types, and all of them have to end up on not just one but many different platforms. You also need to integrate a diverse team of different talents and make them all pull in the same direction even if they are spread out over multiple locations.
What Verse can help you do is to integrate. Verse doesnt dictate how you should work, what tools you should use or what the end product will be. Verse just helps you make it all come together.
Normally the content, tools and rendering technology are very tightly interlocked. The engine can only take specific data that is made with very specific tools. By separating the three we create a much more dynamic pipeline where the content is stored in Verse format that is not looked to one specific rendering technology or tool.
-If you need to change your engine and the data format it uses you can make changes to the engine and/or your Verse exporter with out having to make changes to the tools or content.
-If you need new tools all you need to do is either write a Verse enabled tool or buy one off the shelf. Since Verse is an open API you can even contract it out, or sell the tools you produce to others.
-If you need to exchange data you can do so with other project or even content that is archived form previous projects. If you model a asset in one project it should look great in any other game disregarding of platform and hardware.
A pipeline built using Verse lets you separate the artists domain and the programmers domain. With the Verse server in the center everyone has access to data. If anyone makes a change to any of the data anyone else connected to the Verse server will see the change in real time. There is never any need to check in or out, save, load or merge the data. Everyone has access to everything when ever they need it.
In the artists domain the artists can use any tool that that can interact with the Verse server. If artists require new tools, it does not have any impact on the work of the programmers. The programmers can access that data disregarding of what tool it was created in. Given this continuity, more care can be given to tools that can improve productivity. Tools not directly bound to a specific engine can be shared between projects and even sold or outsourced. With this continuity artists are given the chance to hone their skills.
The programmers can access the Verse data format and write custom optimization tools to refine the data to fit the target platforms. This may include normal-map generation, lighting, LODs, triangle strip generation or shader generation. While the artist control the look, the programmers have full control over how it is implemented.
If the engine programmers need to make a change to the data format or rendering algorithms they can at any time make changes to the exporter and then just re-export form the artists master data to the new format. With real time connection to the artists tools the programmers will know that they have access to the latest data to cut down on turn around time. The data in the Verse client is all interlocked so the programmers know what assets is used for what, instead of getting individual shaders, models and textures.
+ Data Format
The data format used by Verse can store natively most data types needed for games like, geometry, materials, animation, audio and scripts.
The Verse data is not tied to any specific rendering engine and has many similarities to the formats found internally in DCC applications, then game data. Verse data is intended to then be converted in to a platform/engine specific format. By letting the artists create data not specific to any platform it is very easy to add new platforms.
All geometry in Verse is stored in Subdivision surface format. These Subdivision surfaces can be used as normal polygons, but they can also enable you to use sophisticated automatic LOD tools.
Thees two LODs where generated from the same SDS control mesh using our PERSUADE technology. As you can see the generated high-res polygon is indistinguishable form a user generated high poly mesh.
By having this ability to refine models automatically it is possible to build up a library of assets that can be reused in future generations games.
The Verse data format is very flexible and powerful, but if it for some reason doesn't support data needed by a specific project, it has a number of facilities for custom data. This makes it very easy to for instance associate game play data like health, armor, speed and intelligence to a character model.
You can read more about the data that can be stored in the Verse data format in the Verse spec.
Shaders in Verse are describes as shader trees built out of 14 basic building blocks. Thees basic blocks are composited together to create a material description. This description describes a look, but not the algorithm used to compute this look.
GLSL Shaders interactively generated form Verse data.
The programmers can then generate shaders from this shading tree in the shading language of their choice. The programmers can choose how each of the 14 blocks are to be implemented. So while the artist chooses a look, the programmers chose what algorithm should be used to achieve that look on a particular platform. If the programmer wants to make changes to the algorithm they can do so once and then by re-exporting the data they can with one button push propagate that change to all shaders in the entire game. By not locking down your data in to a very platform dependent format like shader code, the algorithms are separated from the art.
Displacement data may be defined by the artist, and can for example be implemented as texturing, normal maps, parallax mapping, or displacement mapping by the programmer in the language of choice, depending on platform and performance. In our Collada based implementation we export GLSL, GLSL 120, Cg, CgFX, and a fixed function output simultaneously.
Artists can use familiar material interfaces (like 3Ds MAX) have that in real time be converted to Verse format, that combined with developers own custom implementations for things like lighting and reflections can be turned in to shaders.
It is important to understand that shader trees are not a replacement for shaders, but rather a data format that stores what can be created in a material editor. With such a format multiple editors can edit the same data with a artist friendly interface with out being too complicated or infringe on how it is implemented. it is a meta format that lets artists control how the programmer implemented algorithms are used to create shaders.
The shader tree is very powerful but on some occasions you may want to have special hand written shaders, and therefore we support "trap doors" that lets you hand edit specific shaders. By having a simple artist friendly way to describe 99% of the shaders and at the same time allow full control over that special 1%, we can strike a balance that gives both efficiency and flexibility.
+ Data Prosessing.
Data coming from tools usually needs a lot of processing to generate normals, skeleton data, tangent space UV, collision volumes and much more. Usually this is done by having the artist manually export files using a custom exporter. This presents some problems. If you want to make a change to the format you need to re-export all files manually. It also makes the exporter very complicated making it hard and expensive to implement for many different tools. Keeping track of all thees individual files also becomes a nightmare.
By storing to a simple generic centralized format like Verse, the pre-processing can be centralized and therefor much easier to maintain. A single command can re export to a new platform or in a new format.
Some processing such as lightning and PVS can be very expensive and take very long time. In this case a linear conversion path is not desirable as a small change may trigger a expensive recompute. In this case you can write your processor to operate directly on the Verse data rather then on the export data.
This scene whas generated using a brute force Global illumination algorithem connected to a Verse server.
A light processor may generate lightmaps/vertex lighting for all models, incrementally improving the environments lighting. If a small change is made the processor will start correcting the light computation according to the change. If the user exports this data before the processor has completed the lighting the exported data may be slightly in correct, but it wont stop a developer from evaluating the game play.
+ Data Management
Verse can store all the assets you need, geometry, textures, audio, materials and scripts. Beyond the standard data you can add custom data like tags and text files containing scripts and what ever else you need. Tags are a great way to associate meta data directly with the 3D environment, for instance data used for game play and physics like health, weight, class and damage directly to characters, weapons, and other assets.
In a 3D application asset management is rarely a problem since you have access to all loaded material, geometries, animations and textures at once. if you want to access a material you just click on the object to select it and open your material editor. The problem comes when you start saving out geometry, animation, shaders, textures and meta data on to separate files. A simple file can easily become very problematic. if there is a error in one of the files it can be hard to back track that file. You have to create strict rules for naming and handling of thees files so that the programmers can asses the correctly. This places a huge burden on artists and makes the pipeline very error prone. if any data if wrong it can potentially break the entire pipeline.
Artists can in their 3D interfaces see the state of assets, by color coding or HUD text or symbols.
But in Verse you always have all assets in one place means you always know what object uses what material and what textures and so on. The programmers accesses the data directly from Verse and can then save it out in what ever structure they want. Buy moving the responsibility of exporting to the programmers it can be automated and the programmers can at any time make a new save, change the format, or modify the way data is being processed, without bothering the artists. By having ate possibility to save out data even while the artists are working on it you can cut down turn around time, something that often can be a bottleneck when one is refining art assets and game play.
Quality control and management can use spreadsheet applications to overview the status and progress of a project.
We have developed an number of tools that uses Verse tag system to quickly communicate the state of a asset. This way an artist can easily see what parts of the data he or she needs to spend time on. Things can for instance be tagged as in progress, completed or critical. This is especially useful when you have many specialized artists who can communicate this way. A modeler may tag a model as complete so that a texture artist know that the model is ready for texturing. The tags can be displayed as coloring in a 3D view or as a spreadsheet to give a good overview.
The fact that Verse is networked also makes it possible to have people working form remote locations, outsource or to have outside overview
Currently we are working with SCEA and Khronos to make Verse work in collaboration with COLLADA. Verse and COLLADA works very well together as Verse is a very artist friendly platform independent format, while COLLADA is closer to hardware and can express very hardware specific features such as shaders. We have created a Open Source COLLADA exporter that showcases the many features like shader generation, LOD generation Custom data support and texture management.
Sony is also currently working on integrating Verse in to their COLLADA DOM technology and have Experimental Viewer running on the PlayStation 3 platform.
The Crystal Space verse integration lets developers paint texture maps using averse enabled paint tool like GIMP and see the results update in real time in the 3D engine.
The Crystal space project have implemented Verse support straight in to their 3D engine allowing people to edit the content of the game while people are playing using a Verse connection.
In game screen shot.
Quel Sollar has also built its own pilot project where the entire content of a game was created using Verse. In this project all the assets where stored in a single Verse server. The tools used was a mix of our off the shelf tools and a number of custom tools made specifically for the project. The levels where created using a mixture of generated and hand edited object placement. A tools was made that connected to the Verse server and could generate rough levels that artists then could go in and adjust by hand using a simple level editor. A custom saver could then export to a engine on the target platform. This saver generated Collision volumes, generated normals, occlusion and much more.
Custom level editor built for level editing using verse.
We used tags extensively to store game play related information that could be read by the engine. By building a solid structure for this meta from the start the programmers and game designers where able to work very independently and game tweaks could be made without modifying the executable.
In game screen shot.
+ Making it happen
If you or your company is interested in using Verse or learning more about Verse as a pipeline the first thing to do is to talk to us. We are here to help you, either by E-mail, phone support, over IRC. If you you pay for our travel expenses we will come to your site and help you figure out how verse can help you develop better games.
We have a long experience of developing applications and solutions using Verse so show us your problem and we will be able to guide you to a Verse solution. We can create a road map for you to adopt this new type of pipeline that doesn't upset you current projects and build a stable foundation for future development and innovation.
We are now looking for partners who are interested in using and developing the technology, from the game development, DCC, middle ware and hardware community.
All software we develop is free and Open Source, so we don't charge you anything. Verse has a growing community of users who share knowledge and software.