Apparance has been a long time in the making, and whilst the initial release in plugin form is close, there is a lot more planned. Find out more about the project here.
What is Apparance?
If asked to summarise in a single sentence it might go something like:
Apparance is an new technology built for the interactive authoring of procedural algorithms to create detailed and expansive 3D experiences for visual applications.
The key features of which are:
- Build 3D worlds - for games and interactive applications
- Procedural generation - parameterise your objects for variety
- Unified toolset - edit with the same application across engines
- Pipeline free - no baking, build steps, or offline processing
- Live editing - fully interactive editing environment
- Run-time content synthesis - everything generated or placed on the fly
- Fully data driven - no compilation or coding (text)
- Small data storage costs - all assets are stored as their procedures
- Dynamic detail - build procedures that know how to add detail
- Level-less continuous world - no loading screens
- Scalable detail control - the more power you have, the better it looks
- Customisation - any external parameters you want can drive content generation
- Parallelisation - synthesis is spread across all available CPU cores.
Some of these main features expanded in a bit more detail:
All content is generated, this means:
- Very small storage requirement - only the procedure definitions are stored, not all the generated geometry. This leads on to...
- No loading during play - all procedures are read in up-front as part of the application startup, after that you have everthing you need.
- Every instance can be customised - parameterise your content as you wish, every tree can have a different name carved on the trunk, every leaf unique, every brick printed with its own serial number.
- No baking or compiling - Since generation happens live, changes you make are immediately used and the content simply re-built.
- Variety - You still need to put in creative effort to keep things rich, but the variety that procedural generation excels at brings this out to much greater effect.
- Scalability - parameterisation by detail gives you the ability to adjust your scene for load balancing, trading complexity for performance, tunable at runtime.
- Customisation - any data source you like can be used to drive content generation, from localising in-world text, to including peoples names, to following local weather and season. Of course, any number of creative controls could be applied too, an obvious example is difficulty level.
- Real-time editing - Because any editing operations of value changes in the editor are applied directly to the procedures representation in the engine, they are immediately available to be re-synthesised and update the 3D world.
- Procedural playground - Interactive editing allows, and positively encourages, exploration of procedure constructions and the parameter space they occupy. Play is a hugely powerful tool in forming ideas into tangible and useful creations.
- Small form - Storing only the procedure definitions is a form of compression, you are crystalising the essense of your objects into their very elemental parts so that the computer can magic into existence one of its many variations as required.
- Working procedurally - This is going to be the biggest shift in mind-set, the need to consider exactly how to encode the structure and its variable aspects into procedures.
- Modularity - Making it easy to factor out and encapsulate functionality, and create procedures for any purpose encourages re-use. Parameterisation only aids this further since you can support variation in your procedures for a variety of settings.
- Horizontally - The amount of re-use allows project-wide improvements to be applied easily. Improve that wall procedure and all the walls improve. This means you can work 'horizontally', fleshing everything out project wide in tandem, then applying improvements across the board. This is rather different to the 'build each thing fully before moving on to the next' approach.
- Collaboration - Since many procedures contribute to each object in game, and a lot of them are re-used, people can work on different aspects of the same objects at the same time.
Object placement is the primary way to build your structures. This means any engine specific object types (sush as meshes, lights, even prefabs/blueprints) can be instanced and placed using procedures. The procedures providing driving parameters to inject as properties and function calls to set them up.
Apparance is a pairing of two tool-sets; a run-time module plugged into a 3rd party engine to view and build your world with, and an editor to author and interact with the procedures that drive the generation process.
The node-based editor where all content authoring happens. Includes procedure browser, node graph editor, and property editing panel. This is a stand-alone application that connects to the procedural synthesis system running in the 3D engine application.
In addition to object placement, geometry synthesis is supported, but due to the huge amount of potential operators needed to provide a comprehensive toolbox, this is still considered experimental at the moment. Some basic geometry primitives, mapping, and manipulation operators are available to experiment with and combined together like the object placement operator output.
Texturing generation is planned for the future, along with the image processing and generation operators and synthesis support needed to create rich procedural textures. These can then be applied to the materials on the generated meshes.
There is great scope to make the interaction with procedural assets much more intuitive and powerful in the host engine editing environment. Procedurally constructed 'handles' injected into the generation objects when editing open up all sorts of possibilities. This is something that will be explored.
The Apparance runtime is written in C++ and can in principal be ported to many platforms to support procedural operation in all sorts of games. Initially the main runtime is going to be released for 64 bit Windows, but several other target platforms have been proven out, including: Linux, OSX, Xbox, and Stadia, but there is no reason Playstation, iOS, Android, Switch, and others can't be supported too.
The runtime has a clean C++ single header API that can be used to integrate the technology into any bespoke engine you wish. This requires .lib access and specialist support. Enquiries welcome.
The Apparance editor is a standalone Win 64 application and as such, only authoring on Windows is available (you may have some luck experimenting with running on Linux/OSX via some Windows interop/emulation techniques though).
What Apparance isn't
Whilst Apparance is setting out to achieve a great number of ambitious things, there are a some things that are not in its list of goals. Some of these are indeed possible to do, but where they don't align to the core goals the effort involved will be spent on proving the unique (and more interesting) aspects of the project. These non-goals include:
Loading of assets
A goal of the system is to generate all content procedurally, and at runtime. There are no plans to support loading of most common asset types such as meshes, textures, materials, and animations. These are left to the engine Apparance is plugged into.
Saving of assets
Apparance isn't intended as an asset authoring tool, in part due to the unique way in which content is generated, detailed, and rendered. Whilst technically feasable, it's not currently a goal to support this. Some engines support 'bake to mesh' for selected objects which can be used to 'freeze' generated geometry and possibly placed assets.
Apparance isn't going to solve all your problems, like any engine it has it's strengths and weaknesses. It isn't going to be suitable for some game type, but there will be plenty it will be good for. Encouraging the use of new techniques to build games has the potential to bring to light new types of game that really benefit from what Apparance has to offer.
It's not likely to be useful (at least in the sort term) if you are trying to do the following:
- Specific detail - recreating exact replicas of real-world environments or overly strict designs.
- Sculpted structures - organic, hand sculpted structures that implicitly contain a large amount of data.
- Creatures - realistic organic creatures and their movements, like sculpted structures, are hard to generate procedurally. This is something to investigate in the future, but unlikely to fit well for now.
- People - Even more difficult that creatures in general. Humans are very good at recognising the human form and it's hard enough to get it right in games in general without having to embody procedures with these skills. Something to experiment with in the future.
- Static Lighting - It will not be possible to use baked static lighting since generated geometry, particularly of a dynamic/parameterised nature, will present too many variations for storage to be practical.
- Hand Placement - Placing restrictions on specific objects or locations can be done, but is messy and hard to do. It's best to spend the effort understanding the requirements and imbuing the procedures with that knowledge then leave the generation to do the work.
- Voxels - Although there's no reason not to include these in the engine, it's not in the short-term plan.
There are other considerations to bear in mind too:
- Disruptive - The workflow behind and the skill-set needed to get the best out of Apparance will require a shift of mental gear. These way you create assets is far from the conventional pipeline, and require a broader mix of talents. This isn't going to fit in a large studio without some serious consideration and changes.
- CPU - The run-time generation of content is highly CPU intensive, and will benefit from as many cores as you can throw at it. That said, it is scalable and you can parameterise by detail/quality and adjust accordingly at runtime for a lower spec system.
Having said all this, I believe nothing is impossible with software and we should ultimately strive to investigate possible solutions in these problems in the future. They provide some very interesting areas of research.
"Apparance" (or often "Apparence") refers to the outward manifestation of a person or thing, the act of being visible, what others see, the process of creating this external impression. The original inspiration for this comes from "Against A Dark Background" by Iain M Banks; The Solipsists don't subscribe to the concept of the individual with no use of the word 'me', referring to, and in a way justifying, the existence of other members of their group as 'apparences'.
"Apparance" is pronounced the way the start of "apparently" or "apart", and the end of "appearance" or "importance" are spoken. The emphasis is on the middle "PAR" sound, and not the starting "APP". i.e. "a-PAR-ance"