Granny 3D SDK Features

Or, you can drop Granny into your project well down the development cycle to add key features like animation blending, normal map generation, or to upgrade your exporters to take full advantage of new art tool features like shader graphs, animation plug-ins, or lighting and camera control.

Granny 2.7 is built in a highly modular and decoupled fashion, allowing you to use as much of its functionality in your application as you choose. All APIs are tiered, such that you can easily shift from using high-level "do-everything" APIs, to using fine-grained APIs that give you explicit control over everything, to manipulating Granny data directly and beyond. Granny 2.7 never puts you in a situation where you have to do something our way - we do not force you to use particular vertex formats, we do not impose a proprietary scene graph architecture on your application, and we don't demand that you inherit from a custom object hierarchy. Everything is always done your way, and remains under your control. You can use all of Granny 2.7's features quickly and easily without ever giving up control over your engine's architecture.

Below is the list of shipping bullet-points for Granny 2.7. As with all RAD products, we frequently update our codebase, and new features and optimizations are added on a monthly basis, so this list is rapidly expanding and is by no means complete.

• Integrated normal mapping and texture generation tools
  • supports MAX (6.x, 7.x, 8.x, 9.0, 9.0x64) and Maya (5.0, 6.x, 7.0, 8.0, 8.0x64)
  • produce single, complete low-res texture maps for your low-res geometry from cinematic-level high-res geometry with an arbitrary number of applied materials
  • generate beautiful normal maps from high-res geometry for use with advanced shaders
    • Generate tangent-space normal maps, object-space normal maps, or displacement maps
    • User-controllable over-sampling
    • Automatic texture filling for better MIP-map generation
    • Blazingly fast... generates gorgeous looking normal maps in a TENTH the time of other available tools, or less!
    
    
  • automatic generation of tangent space basis vectors for exported models
  • fully SSE-optimized deformers for tangent spaces, both for normal-tangent and normal-tangent-binormal formats
  • special texture compression path for normal maps that provides extra accuracy, and avoids YUV conversion
  
  
• Exporter integration
  • supports MAX (6.x, 7.x, 8.x, 9.0, 9.0x64), Maya (5.0, 6.x, 7.0, 8.0, 8.0x64), and XSI 5.11.
    • MAX support includes all node-level animation, rigid meshes, Bones Pro, Physique, and Skin
    • Maya support includes all node-level animation, rigid meshes, rigid skinning, and smooth skinning
    
    
  • all accessible art-tool data is exported, even if it's specific to a particular package
    • exports MAX-only or Maya-only userdata, light settings, camera settings, dummy bones, etc., so you can use it for full-scene exports as well as characters and props
    • exports all MAX-specific and Maya-specific material parameters for use in your custom-written shaders
    • exports animated custom attributes as spline curves that you can sample in the same way as the standard bone animations
    
    
  • hierarchical settings interface for precise control over export contents and settings
    • control what models, textures, animations, and materials are included in the export
    • set global preferences like texture compression percentage, maximum weighted bones-per-vertex, and animation curve types or override settings on an item-by-item basis
    
    
  • settings saved in scene and in settings files
    • settings automatically persist with scene files and with individual objects, so models copied from one scene to another will actually retain any specific Granny export settings in the new scene
    • commonly used settings can be saved to compact settings files and loaded into new scenes, shared across a network, or e-mailed between artists
    • settings are backwards and forwards compatible so new versions of the exporter can read common settings from older versions and vice versa
    • settings are tool independent, so Granny export settings made in MAX can be used in Maya, etc.
    
    
  • native tool scripting support
    • MAXScript and MEL bindings allow hands-free, completely automated batch exporting
    • automatically run your own custom post-processing executables after export
    • write special-purpose scripts for automating common settings, or check and enforce art conventions
    
    
  
  
• Physics Integration
  • Full source shipped for the Granny/Aegia integration library
    • add ragdoll to your game with a few lines of code
    • mix in physical results for automatically generated recoil, impact, or other animation effects
    • create zombie affects by physically driving a blended animation with no extra asset creation
    • small, focused integration layer is easy to customize to whatever effects you have in mind.
    
    
  • easily retargeted to other physics APIs such as Havok, ODE, or custom solutions
  
  
• Mesh exporting and processing
  • extensive vertex layout support, including packed formats
    • pick from floating point, packed 16-bit, packed 8-bit, and a variety of other formats for each individual vertex attribute
    • automatically convert between Granny's standard formats and your own custom vertex formats
    • save your own custom vertex formats directly in Granny files
    • let Granny do weight clipping and normalization for you
    
    
  • full support for multiple 2D or 3D texture coordinates and 3D or 4D colors per vertex
  • user-specifiable bones-per-vertex for weighted blending
  • automatic splitting of vertices based on normal and material boundaries
  • face-to-neighbor, vertex-to-face, and vertex-to-vertex rings
    • makes for easy user implementation of custom mesh post-processing routines
    • includes all information necessary for run-time silouette edge extraction
    
    
  • automatic handedness and coordinate system remapping, so you can easily change right-handed art tool data into left-handed data for your engine, or vice versa, change "up" vectors, etc.
  
  
• The Granny Preprocessor
  • Customizable pipeline tool that natively supports a number of common operations including
    • setting file compression parameters
    • breaking meshes along bone boundaries for submission to hardware deformers with a limited register set
    • cleaning unwanted data from the file
    • convert mesh indices to smaller formats
    • convert mesh vertex formats to a custom engine type
    • prepare the file for loading on 32/64 bit systems with big- or little-endian byte ordering
    • transform the file into your engine's coordinate system
    • optimize index ordering for hardware post-transform caches
    
    
  • works with all platforms
    • supplied as source code for you to modify to your engine needs
    
    
  • add your own commands easily
    • simple, flexible driver program makes customizing the tool with your own operations a snap
    • detect data unsupported in your engine (like scale/shear) quickly, before it causes bugs to be tracked down later.
    
    
  
  
• Animation exporting and processing
  • perfect sampling
    • allow your animators to use any bone animation methods including plug-ins
    • "frame-less" sampling converts everything to consistent time-frame based information
    
    
  • advanced compression
    • per-bone user-controllable curve fitting and compression of animation data
    • choose from cubic, quadratic, linear, or step interpolation for position, rotation, and scale/shear data separately
    • Granny automatically chooses the smallest possible representation for your data. Granny supports everything from full floating point curve representations, down to 7-bit dimension-reduced formats. You get the smallest possible format without exceeding your tolerance targets.
    • sample animations at arbitrary times and timesteps while retaining perfect continuity
    • full support for C0 and C1 discontinuous curves, so objects can bounce, teleport, etc., whilst still maintaining perfectly smooth motion at any time scale
    
    
  • extensive post-processing capabilities
    • rotate, translate, or scale entire animations after exporting
    • automatically align animations so they begin at the origin, regardless of where they were originally modeled
    • strip various degrees of freedom from any bone (including the root) for all or part of an animation
    • automatic handedness and coordinate system remapping, so you can easily change right-handed art tool data into left-handed data for your engine, or vice versa, change "up" vectors, etc.
    
    
  • integrated track mask support
    • allows in-game per-bone masking of animations
    • create with UI integrated into Max and Maya, or use your own custom scripting tools
    
    
  • Morph targets and vertex animation
    • Export an arbitrary number of morph targets for viseme animation or custom mesh-based animations.
    • Export per-vertex curves for the ultimate in control. Positionally update each vertex either in model-relative or bone-relative space.
    
    
  
  
• Material exporting and processing
  • exports entire material and texture graphs from MAX and Maya
    • let Granny's high-level routines interpret standard shader graphs, or write your own tool-specific custom shader graph parsers for special effects
    
    
  • programmatically access all maps, including specular, diffuse, ambient, self-illumination, bump, displacement, refraction, reflection, and many others
  • programmatically access all material parameters like UV cropping and wrapping types, environment mapping types, tool-supplied physics coefficients, mixing percentages, and hundreds of others
  • built-in support for S3/DXT compression
    • store textures in hardware-ready format
    • let Granny's custom DXT texture compressor quickly and automatically detect which DXT texture format most accurately encodes your textures
    
    
  • built-in Bink texture compression
    • get 20:1 and better texture compression for cases where disk space or download size is critical
    
    
  • built-in conversion support for all raw texture formats for arbitrary bits-per-pixel and bit ordering
    • automatically convert Bink-compressed or DXT-compressed format images into raw data of any format for manipulation or submission to hardware
    
    
  • high-quality texture resizing for automatic MIP-map creation or run-time constraining of textures to 256x256 (or any other abitrary size) for older graphics hardware
  • files can contain textures and material in their entirety, or reference them by name to support shared material and texture libraries
  
  
• File format
  • completely transparent and flexible file format
    • all aspects of file format are exposed at the API level, so you can write your own Granny file readers and writers even without using the Granny API utilities for doing so
    • file format is not hard-coded, so you can add your own extensions or even change it completely and use it for files other than your art assets
    
    
  • ready-to-run default file structure
    • all data is (by default) stored in ready-to-run format, so loading is just a single block read and an extremely fast pointer fix-up pass; no clunky RIFF parsing or type conversion
    • file data can be stored in multiple segments within the file to facilitate fast freeing or re-loading of various types of data (such as texture data or vertex data)
    
    
  • built-in versioning
    • Granny can convert older Granny data transparently in either the toolchain or in the runtime. We are serious about never making you throw away or reprocess your data except when you want to. As a demonstration of how robust Granny's versioning support is, the "GrannyRocks.gr2" sample file that ships with the Granny viewer was last exported in 2003. We've never had to touch it.
    • your custom data gets the same version treatment as Granny's native data, so you can store critical data in your .gr2 files without worrying about keeping it up to date.
    
    
  • built-in "better than ZIP" compression
    • let Granny automatically compress all your files at ratios better than PKZip and other standard compressors
    
    
  • automatic endianness conversion
    • Granny handles all byte-swapping, so you can use the exact same files on all your target platforms with no modification to your source code
    
    
  • support for 64-bit platforms.
    • Granny can load and fixup pointers on either 32 or 64 bit platforms, regardless of the pointer size of the platform that created the file. You always get back native C structures from Granny, with all the references, array sizes, and data ready to use directly on your platform.
    • The Granny Exporter and Preprocessor can create files optimized for loading on any target platform, regardless of the platform on which you run your toolchain.
    
    
  • supplied conversion DLL for processing old Granny 1.x files
    • Upgrade your old Granny 1.x assets to 2.x in a batch process, or on-demand
    • Granny Viewer automatically converts old files on-the-fly for easy viewing and browsing
    
    
  
  
• Memory management
  • low memory overhead for Granny bookkeeping
  • all internal Granny allocations are block-based
    • very few allocations total
    • no small allocations
    • no need for advanced memory allocator underneath
    
    
  • "allocationless" at run-time
    • memory is allocated and freed only when you request it, so there are never any hidden per-frame allocations or other slowdowns
    
    
  • all memory operations are over-ridable
    • control how memory is allocated at the low-level
    • in many cases, you can provide memory directly to the appropriate APIs without overriding the low-level allocators at all
    
    
  
  
• Animation playback and blending
  • individually decomposed translation, rotation, and scaling for perfect interpolation
    • allows artists complete freedom to use scaling and shearing in their animations
    • prevents scaling and shearing animation from introducing rotation artifacts and vice versa
    • no work done for channels which are not used (eg, you don't pay for scale and shear if your animations don't use them)
    
    
  • explicit timing control of animations per-model and per-animation
    • play animations backwards or forwards at arbitrary time scales
    • easily advance time for all models in a scene or just those visible
    • adjust times per-model or per-animation, forwards or backwards, for painless synchronization of playback across a network
    • advance some animations in real-time and others in sub-real time for matrix-like special effects
    • query and change model clocks multiple times per frame for easy collision detection searching
    
    
  • support for single animations that control multiple models
    • animate two characters dancing, or multiple characters in a cut scene, and play back the animation and multiple, separately-loaded characters in your engine
    • quickly and easily animate throwing or catching objects, taking objects on or off, or handing objects from one character to another
    
    
  • blend arbitrarily many animations at once
    • new "priority-less" weighting scheme makes even complex multi- animation blends (like 9-animation aiming blends) trivial
    • entirely quaternion blending ensures no undesirable blending artifacts (like gimbal-lock)
    • no work done on zero-weighted animations, so leaving many animations attached to a model incurs no computation overhead
    
    
  • optimized playback
    • Granny has platform-specific optimizations for sampling, blending, and deformation matrix construction, including SSE, VMX128, and Altivec.
    • Granny supports multithreaded sampling for maximum performance on multi-core or multi-processor platforms.
    
    
  • complete bone-level control of blending percentages
    • individual control of animation track-side weighting and model bone-side weighting per animation
    • easily feather upper-body motion into lower-body motion
    • automatically interacts properly with ease-curves for easing in and out feathered animations
    • tool plugins and automatic extraction make authoring bone weightings easy
    
    
  • ease animations in and out over time with cubic beziers
    • automated calls for default timings and smooth transitions
    • user-controllable curve tangents for explicit ease-curve control
    • optionally release control resources at completion of ease-out curves for completely hands-free control memory management
    
    
  • quick root-bone motion prediction
    • keep feet planted by moving characters as they were moved when animated
    • predict collisions without computing entire character state
    
    
  • explicit blending stage control
    • directly modify or override local transforms for each bone post-blending but pre-hierarchial composition
    • directly modify or override world transforms for each bone for manual or IK-assisted adjustment of limbs (keeping feet level on uneven terrain, or pulling hands or hand-held items away from walls)
    • save local or world transform states for use at another time or as a animation to blend in later
    
    
  • integrated animation LOD
    • reduces the cost of detailed skeletons in distance
    • eliminates need for multiple versions of skeletons or animations
    • animation-specific LOD - subtle animations reduce sooner
    • offline or load-time calculation of LOD parameters
    • all animation sampling calls take a desired error value
    • all blending functions work the same - complete orthogonality
    • all transitions are smooth with no "popping"
    
    
  • high-level blend directed acyclic graph for complex animations
    • construct complex blending graphs from multiple layers of simpler ones
    • user callbacks for custom effects such as muscle and cloth
    • sampling and rendering code becomes independent of animation complexity
    • easy encapsulation of animation classes such as facial animation, lipsync, hand gestures, foot IK - makes it easy to apply complex functional blocks to multiple skeleton rigs and types without requiring each to have full knowledge of context
    • even easier integration with external modifiers such as collision-detection, physics constraints and ragdoll simulation
    
    
  • built-in camera handling routines
    • use intuitive camera parameters like relative motion, elevation- azimuth-roll, and target-relative displacements
    • let Granny build your camera and projection matrices with full resolution AND physical aspect ratio correction
    
    
  • not limited to Granny meshes
    • animation APIs are completely separate from mesh and texture APIs
    • get composited, hardware T&L-ready 4x4 matrices for use in your own mesh deformation or rigid mesh rendering.
    • download Granny's matrices directly to the 3D hardware for blazing fast shader-based deformation. Hardware deformation examples are available for all console and PC platforms.
    
    
  
  
• Mesh deformation and control
  • easily manipulate and switch meshes at run-time
    • all mesh/model bindings are user-manipulatable, giving you complete control over rendering order, deformation order, storage of deformation results, card-residency, and LOD swapping
    • transparent mesh structures allow you to change vertices, weights, colors, texture coordinates, even polygon ordering and inclusion at run-time
    
    
  • fast deformers for a variety of platforms
    • includes optimized blenders for multiple platforms and multiple vertex formats, with an expandable architecture that lets your code instantly and automatically take advantage of new blenders we release
    
    
  • support for tangent-space deformation in addition to position and normal deformation
  • let harware T&L do the work where available
    • all mesh data is available to the application for submission to hardware or modification into a hardware-ready format, whether or not Granny explicitly supports the hardware platform you're targeting
    
    
  • not limited to Granny animations
    • mesh deformation APIs can be used with any vertex data and transform set, whether they came from Granny's animation APIs or from your own custom animation code
    
    
  
  
• Collision detection
  • bounds-level detection
    • quickly check for ray-model collisions with bone bounding boxes
    • know exactly which bones were potentially hit
    
    
  • triangle-level detection
    • get pixel-accurate ray-model collisions, complete with entry and exit normals for special effects or ricochets
    
    
  • not limited to Granny models
    • use low-level collision detection routines on any bounding box, sphere, triangle, or plane in your engine as part of your collision detection system
    
    
  
  
• Inverse kinematics
  • pre-composition IK
    • use IK to aim guns, point fingers, and turns heads, then blend them in with the rest of your animations using the standard Granny animation control APIs
    
    
  • post-composition IK
    • analyze post-composition bone positions for validity (collision with your world geometry, etc.), then quickly use IK to fix them up
    
    
  
  
• Model, Animation, and File Data Viewing
  • natively supports both PC and Macintosh with full use of hardware 3D acceleration on both
  • full 3D previewing
    • load multiple models from separate files
    • vertex normals, face normals, bounding boxes, bones, bone names, and coordinate frames can all be inspected visually on the fully animating model
    • support for all common aspect ratios and FOVs, so you can see how the model will really look with your engine's perspective
    • auto-detection of mesh size and native orientation, so you will always see your model oriented properly (whether it's y-up or z-up) and at the right distance (load big buildings or tiny characters, and they'll always come up frame properly, even before you adjust the camera)
    
    
  • full animation previewing
    • audition animations from multiple files on separately loaded models
    • play animations with or without root node motion
    • onion skin testing for visualizing animation boundaries
    • slow down or speed up time to see animations more clearly
    • drag time back and forth to inspect specific animation segments
    • preview animations playing backwards
    
    
  • visual calibration tools
    • User-selectable min, max, center, and origin grids for easy model alignment
    • Multiple, common-unit grid sizes for visual inspection of measurements (mm, cm, m, km, etc.)
    • Auto-measurement lines with meter read-outs for determining the exact length of the working space
    
    
  • texture inspection
    • Inspect textures separately from models
    • Use UV overlays to see how models are mapped
    • Swap calibration textures in and out for on-model visualization of how UVs are assigned
    
    
  • complete raw file data inspection
    • see actual raw file data for debugging purposes
    • navigate entire file data tree as hyperlinks
    • view exact vertex, mesh, and animation data
    
    
  
  
• Source code
  • natively supports all common compilers and platforms with an ANSI-C standard library
    • no templates, inheritance, or other undersupported C++ features, so there are no hassles even on severely non-compliant C++ compilers
    • compile under GCC, MSVC, CodeWarrior, etc.
    • compiles on supported platforms like Win32, Win64, Mac OS X, XBox, GameCube, Xbox 360, PS3, PSP, Wii etc.
    • compiles on unsupported platforms like PSX2, Linux, etc.
    
    
  • extremely clean, segmented design makes user-added features easy to implement and maintain
  • no news or deletes - all memory management calls go through centralized allocate and free function pointers so memory management can be over-ridden through the API or at the source level
  • no hard-coded file opening or closing - all file calls go through centralized open, read, write, and close function pointers for easy replacement through the API or at the source level
  • a granny:: namespace can be optionally imposed on the codebase via a macro, so if your compiler supports them, you can keep all Granny code in its own namespace to avoid name conflicts when compiling Granny source code into your own executables
  • introspection support
    • query Granny's memory usage at any time, and find out exactly which source files are using which memory blocks
    • query Granny's CPU usage at any time, and find out which code blocks are taking what percentage of the total CPU clocks
    • extensive logging options and parameter validation allow quick and easy failure analysis