IndieZen - 3D Modeling Tool

Continuous Automatic LOD / Multi-mesh Modeling Tool

Wow, that's a mouthful. What is it?

Lets break it down:

Modeling Tool

Easily create 3d models with an emphasis on NURBS high-poly / high-detail models.

Originally based on Blender, this modeling tool has been completely re-written in C++ for optimal performance and extensibility. The plugin system allows for user created C++ plugins and it comes with fully integrated LUA and Python scripting engines to facilitate creating plugins / extensions in those two languages.

Automatic LOD

Near real-time algorithm that allows modelers to quickly see their high-poly NURBS models tessellated (i.e. converted to polygons) and view multiple levels of detail.

Paint tools allow modelers to paint weights on NURBS curves, Edge Rings, Edge Loops and individual control points or vertices (depending if the node is in NURBS or Mesh mode). These vertex weights are used to provide hints and override the behavior of the poly-reducer algorithm.

Multi Mesh
Not just useful for creating multiple LOD, multi-mesh modeling allows modelers to quickly and easily create clothes that conform to the original model. Spring / weight editing provide a mechanism for creating in-game clothing (provided your game engine supports clothing).

Continuous
Complete collapsible and editable modifier stack allows modelers to go back to the original mesh and modify it through the use of deformers. All derived meshes (LOD and multi-mesh) are automatically adjusted in near real-time.

Create Morph Targets
After creating a base model, modelers can create morph targets by applying deformers or by importing existing models.

The base model and morph targets can then be saved in a library and shared with other developers or even imported directly by your game engine.

Animations
Create multiple key-frame skeletal animations and pre-view animated morph targets and merged animations.

Skinned meshes automatically retain the skinning information on derived meshes (LOD and multi-mesh).

Shaders and Textures
Procedural texture generation includes subsurface scattering, ambient occlusion, texture baking, scripted user-generated procedural textures, bitmap (jpg/png/tga) textures.

Automatic generation of normal maps and bump maps; use the highest detail model to create your normal maps and/or bump maps and apply them to the lower detail models to help reduce poly-count without significantly reducing the visual appearance of your models.

Using GLSL and HLSL editors and compilers, modelers can create shaders and pre-view the models complete with animation without ever leaving the modeling environment.

Current Status

Using the FOX GUI toolkit, boost, Cal3d, and temporarily "borrowing" some C/C++ and Python code from Blender and MakeHuman has allowed me to make significant progress on this project.

Today I finished putting it all together, but there are still some major technical hurdles.

Today I also finished one of the one's that I thought would've been the hardest problems.... polygon reduction. I started with Blender's poly-reducer script, but it doesn't take edge loops / rings into consideration, nor does it work well with my weight paint system or multi-mesh history.

Starting with an image like this:


And using Blender's poly reducer, you get an image like this:


Not horrible, and using a shader with normal maps I doubt you'd really be able to tell much of a difference. The problem is if you mangle your model like this, animations that work well with the original high-poly model will end up creating some strange creases in the lower poly models.

For an in-depth discussion, check out this article.

The new poly-reducer algorithm takes edge loops and rings into consideration and attempts to reduce the polycount by either creating new edge loops / rings interpolations like this:


The advantage of having the poly reducer understand edge loops / rings is significant. Game modelers aren't simply trying to reduce polygons... they're trying to reduce polygons in such a way as to allow their animations to continue working correctly.

The IndieZen poly reducer allows you to paint weights onto significant poly loops / rings to indicate the locations of joints and other significant details and the poly reducer will be less likely to remove / move the loops / rings with heavier weights.

Next Steps
The next steps include creating an export system and a native Torque resource handler for a new model file format that doesn't lose any of the morph target, multi-mesh, animation or shader information yet can be efficiently loaded.

After creating the MDL resource handler for TGEA a year or so ago, this part won't be too difficult, but it will be time consuming. Unless I directly use MDL (or NWN2's file format since it also includes shader support), creating a new file format takes a lot of creative time and energy.

The next part will be to (optionally) eliminate the GPL code. If I change my mind then I'll release the code under the GPL license, but at this point I'm interested in creating Intellectual Property outside of games so it's unlikely that I'll skip this step.

IndieZen

Ok, so what is IndieZen?

In addition to creating the game Fractured Universe, the tools that I'm using to create that game will eventually be packaged together under the brand name of "IndieZen". I'm not sure the pricing model yet (possibly free / open source if I continue using GPL code), but if it's not free then it'll definitely be cheap.