Granny Development History

• Home
• Bink
• Miles
• Granny
• Pixomatic
• Pricing
• Support

Changes for 2.8

2.8.2.0 dag_beta 2008/07/03

• Fixed a crash relating to the custom control hook in XSI.
• Fixed a memory leak in the SPU animation paths.
• Fixed an ordering bug with triangle annotations in the exporter.
• Compatability Note: XSI Exporter will now prefer the "RealTime" material connection over the "Surface" connection to use as a granny_mesh's material.
• Trackmasking is now supported by the Blend Graph Editor.
• (internal) Take up new stb_image.c
• (internal) Add some localized material usages strings to the the viewer.
• (internal) Name consistency change for granny_track_mask field.

Hot fix for three serious bugs, one in the exporter, one in the Motion Extraction on Sony platforms, and a looping artifact fix for SPU sampling. Please also read the note for 2.8.0.0, everything there still applies, we're still in open beta on the DAG tool, and looking for feedback!

• Compatability Note: Version numbering change. The convention for Granny releases is now Major.Minor.Build.Customization. Previously, the convention was Customization.Build, which was slightly confusing. This alters the parameter ordering in GrannyGetVersion.
• Fix a bug in the SPU sampling paths for orientation curves that improperly blended quaternions from incompatible hypersphere neigborhoods at the animation loop point.
• Serious bug fix for Sony platforms (PS3, PSP, PS2). A parameter reversal in one of the RAD custom trigonometry routines meant that motion extraction at the very least was compromised on these targets. This bug has been fixed, and this is a highly recommended upgrade if you're shipping a a game on a PlayStation platform.
• Fixed a Max texture handling error that could cause textures with the same underlying bitmap to export improperly.
• Repair Maya exporter's animated camera/light/particle handling.
• Max meshes now contain a list of sibling instances in their extended data.
• Max meshes now put the full mesh path, including parents in the granny_mesh::ExtendedData field.
• You can now attach an arbitrary file to an exported gr2 from either Max or Maya. The file is attached as a raw byte array to the granny_file_info::ExtendedData member. Use with either 'GrannyExport -f "attachFile" "fileName.gr2" in Maya, or 'GrannyExport "fileName.gr2" attach:"attachFile"' in Max.
• Altered the SPU SpeedCheck demo to allow tweaking the number of models, as well as turning on and off rendering.
• Fixed a crash bug in the tangent creation process in the exporter.
• Editor Documentation may now be found as "doc/EditorDoc.pdf".

Welcome to Granny 2.8! This is the first public release of the new Blend Graph Editor. Please let us know what you think of the beta tool, and send us suggestions for improvements, either in the tool, or in the runtime API!

• New tool and API: The Animation Graph API and Editor.
• New preprocessor command "AddTexture". This will take a raw image from disk and poke it into the specified granny_file_info using a given set of compression parameters.
• Created a new subdirectory of the preprocessor project ("samples") for storing small commands that aren't quite universally useful, but can serve as good examples of the sorts of things the preprocessor is suited to.
• The Max exporter will now record some information about the XRef status of meshes.
• Fixed an exporter bug that caused meshes to be improperly exported if they contained 64k+ verts, and "16-bit indices" was turned on. These meshes are left in 32-bit mode and a warning log message is emitted.
• (internal) Factored out some functionality from the granny_controlled_animation motion extraction to make it available to the DAG.

Changes for 2.7

It's been a busy 2 years since the last minor version bump. As is the custom, we're going to use up a couple hundred bytes here to underline some of the major changes that Granny has undergone since the 2.6 release series. As always, the best way to keep up with Granny is to read the changelog as it is published, but let's hit the highlights.

The top line feature for our PS3 customers is that Granny now supports asynchronous sampling on the SPUs using mulitple SPU threading models. This is a fully general replacement for the PPU based GrannySampleModelAnimations family of functions. Each SPU is able to handle an animation workload in excess of the PPU in our tests, so with just part of 1 SPU, you may be able to completely eliminate animation from your profile on the host processor.

For both the Xbox 360 and the PS3, we've added Altivec math routines for building final poses, and custom code to decompress the most important curve types. Every significant LHS stall and fdiv/fsqrt has been profiled, and where feasible, eliminated.

New platforms added in this release series include Intel-based Macs, which use the same optimized routines as the mature Win32 target, and the Nintendo Wii. Early in 2.7, Granny added x64 support, and the file processing routines got an upgrade to make moving files between 32 and 64 bit platforms seamless.

The Granny Preprocessor is now a full-fledged, production ready tool. Out of the box, it supports 26 of the most common runtime preparation operations that most people need to get their content out of Max or Maya, and into their game. The Preprocessor was rewritten to make it absolutely trivial to drop in your own operations.

Continuing our goal of "Granny Everywhere", we've added support for 3 new versions of 3ds Max (9, 2008, and 2009) and 2 new versions of Maya (8.5 and 2008). For the first time, XSI (versions above 5.11) are now supported! Along with the x64 runtime upgrade, we now support the 64-bit versions of the DCC packages.

In all of these tools, data extraction has been improved. We now support animation of Camera, Light, and Material parameters through the same granny_vector_track mechanism used to support custom attribute animation, Max particle systems are detected and exported, and visibility tracks are made available to you in the runtime. Morph modifiers (Morpher in Max, BlendShape in Maya) are now directly supported, allowing you to extract and animate morph animations directly from the DCC package. We've added support for the triangle annotation features found in Max, making it possible to associate arbitrary bits of data (strings, floats, bools, etc) with the triangles of your mesh. To make the exporter easier to automate, there are new scripting tutorials targeted at each DCC package. In addition, all of the Granny script commands in each package are now self-documenting.

The Granny Viewer has received a few tweaks as well, some of the more useful features for artist workflow:

• The viewer will now bind animations to multiple models for attachment previews.
• Vertex colors can be separately displayed
• The viewer tries to load external textures for files that reference their bitmaps by name only.
• Drag-and-drop file open support

2.7.0.34 final 2008/04/21

• Support for 3ds Max 2009 added.
• New preprocessor command: "ThresholdVectorTrack" which can convert one or more scalar granny_vector_tracks into a granny_text_track for animation event handling. This is especially handy for Maya, which lacks the concept of "Note Track". Boolean or Float animated attributes can processed into discrete events easily using this method.
• Alleviated a memory exhaustion problem that could occur with large compound array attributes in Maya.
• Preprocessor command "MakeSPUAnimation" now warns explicitly about animations that exceed the maximum size limit for SPU dma transfers.
• New option in the exporter relating to custom attributes attached to ExtendedData members. If "Only User Attributes" is checked, the exporter will try to include only attributes created by the user, rather than attributes specified by the art tool. It's not always possible to do this with 100% accuracy in all tools, but the exporter will make a "best-effort" attempt to cull the static attributes if you don't need them.
• Better guard against crashes in the exporter. Clean up any temp files created if the exporter fails to be a better citizen.
• Fixed another "touch and die" parameter case in the Max exporter.
• Compatability Note: granny_dag_pose_cache API has been altered to both better support new DAG structures, and improve efficiency in the legacy DAG.
• "Compress" and "Decompress" preprocessor commands will now properly preserve the section count.
• "RemapStrings" preprocessor command will now work properly with custom formats. Previously the type of the file would be coerced to granny_file_info, even when inappropriate.
• AggrAllocations for counted arrays with zero size would previously return a pointer to memory that was technically owned by the next component of the compound alloc. These pointers are now properly zeroed.
• (internal) Allow AggrAllocs to end to an arena directly, without a two stage placement pass.
• (internal) AggrAllocation functions were being a little paranoid about zero filling memory that would never be touched. Altered the behavior to be paranoid only in debug mode and more efficient, but safe, in release.
• Compatability Note: granny_log_callback API changed to pass the source file and line explicitly to the log function, rather than in the string. This allows for more succinct error reporting in many cases. If log writing is enabled with GrannySetLogFileName, the on-disk log file will still contain the file and line number explicitly.
• Compatability Note: API for retrieving the most serious message logged thus far removed. This was a very sparsely utilized API, and the storage for the buffers was not an insignificant addition to the total size of the Granny library. This functionality can be duplicated with a custom granny_log_callback at the application level.
• Exported granny_memory_arena APIs for pushing strings and binary data chunks, GrannyMemoryArenaPushString and GrannyMemoryArenaPushBinary.
• Compatability Note: Default memory arena alignment changed to 4 bytes. Previously, if unspecified, arenas would allocate at the granularity of the allocator. This is not anticipated to cause any problems, nearly all allocators return at least DWORD aligned memory.
• Compatability Note: In previous versions of Granny, when a GrannyStringMember field was written out, NULL strings would be converted into "". NULLs are now properly propagated through the type IO system for these fields.
• Compatability Note: Removed obsolete and little used period loop API from the public definitions.
• (internal) Change string_database remapper to replicate new NULL string behavior.

• Handle kMatrix typed custom attributes in Maya.
• Prevent empty compound type objects from slipping through into granny_bone::ExtendedData
• Added "texture_name" option to GrannySetValue. This allows poking values into the Granny export settings by the filename of the texture, which can be useful in certain situations.

• GrannyWindowSpaceToWorldSpace function now recognizes the output Z range of the granny_camera. Previously, it would assume the OpenGL default range.
• The Max exporter for versions 9 and above will now allow you to pull the Max computed tangents from an arbitrary map channel instead of computing them separately in the same way as the Maya exporter.
• Altered the handling of the DirectX material in 3dsMax to allow bitmap parameters for shaders to be extracted with custom settings. Because of the way Max represents these parameters internally, identical bitmaps will potentially be represented in the final .gr2 multiple times. The preprocessor can be used to clean up these extra textures. Bitmap parameters in shader materials are exported as full path filenames, which can be matched to texture objects in the granny_file_info::Textures array.
• Compatability Note: The exporter now only supports directly indexed annotation sets. These are annotations in which the index map of the annotation takes the triangle or vertex index to the index of the annotation. This has been the recommended annotation mode for quite some time, this change remove a confusing option. The indicator variable remains in granny_vertex_annotation_set and granny_tri_annotation_set in case you want to use the preprocessor to switch an element-annotation set back to the annotation-element representation.
• Max exporter will now extract vector animations correctly from objects with a non-trivial modifier stack. As a bonus, it will usually be able to extract animated attribute tracks from the modifiers themselves as well.
• Fixed a plugin bug in which the face annotation extractor looked at the wrong Max object to retrieve the channels.
• GrannyCopyLocalPose could conceivably silently write off the end of the transforms array of the destination pose if GrannyGetLocalPoseBoneCount(Dst) was less than GrannyGetLocalPoseBoneCount(Src). This, and an inconsistency with respect to the internal FillThreshold and TraversalID fields have been cleaned up.
• Boolean blind data in Maya queried as BoolValue rather than IntValue.
• Corrected the transform flags on the SampleModelAnimsSPU pathway
• Fix a bug in extraction of color parameters in the triangle annotation section of the Max exporter.
• Fix for an uninitialized pointer access in the Viewer menus.
• Try harder not to touch IParamBlock2 parameters if we're not going to extract them. In Max, several of these have the undetectable "touch and die" bit set.
• Change GrannyExtractTrackMask to search all sub-members of the bone. This fixes an issue that arose after the reorginization of the ExtendedData member for Max in 2.7.0.22.
• GrannyCopyTextureImage would incorrectly decompress S3TC texture on big-endian platforms (Wii/360/PS3). Fixed.
• Fix a bug in the SPU animation sampler for granny_controls with GrannySetControlForceClampedLooping enabled.
• Added a parameter to the Granny casting interface to match the "Tangent Merge Tolerance" setting from the tangent space generator. Previously, the caster would always assume the default merge tolerance. Access with "tangentMergeTolerance" or "tmt" from the casting script command.
• MakeSPUAnimation was placing type information in the wrong section, which could cause trouble when the GrannyStandardDiscardableSection was freed.
• GrannyLocalPoseAlignment macro exported.
• Internal: Retire some older targets from the "Actively Built" list.
• Internal: Allow chaining of granny_local_pose objects.

• Compatability Note: where possible, the exporter will now pick up the defaults from the global settings for newly created objects. Previously, any items created after global settings were changed would get a fresh set of default values, which was a bad "least surprise" violation.
• Compatability Note: When morph targets are extracted from a Morpher or BlendShape modifier, the morphs are now moved to the base position of the root mesh. This allows artists to line up head morphemes, etc. next to each other without worrying about bringing them back in line at export time.
• Exposed the GrannyBeginControlledSPUAnimation API to allow setting granny_track_masks for SPU sampled animation. New public functions include: GrannyEndControlledSPUAnimation, GrannySetSPUTrackGroupTarget, SetSPUTrackGroupTrackMask, GrannySetSPUTrackGroupModelMask. All SPU functions are direct analogues of their non-SPU counterparts.
• String remapping speed greatly improved.
• Added an option to the exporter to pull the vertex tangents from Maya rather than generating them in granny_mesh_builder.
• Allow setting viewer toggles from the command line. Toggle buttons will show they name of their underlying variable in the status line when they are highlighted, use "-set" or "-clear" to manipulate them at application startup.
• Fixed the handling of ExtendedData attributes for Max objects with a non-trivial modifier stack.
• Max attributes of type TYPE_INODE and TYPE_INODE_TAB now export the referenced object's name when possible.
• Fixed the handling of Point4 attributes in Max.
• GrannyGetWorldMatrixFromLocalPose was incorrectly asserting when a sparse bone array was present.
• New exporter command "GrannyVersionString" to return the exporter version in an easily parsed format to allow programmatic version checking. Hat tip to BobB for the suggestion.
• Added a project to build the Xenon target from source.
• Added GrannyRemovePointerFromHash API
• XSI Export Selected fix
• XSI 6.5 plugin
• Handle XSI texture nodes that are raw ImageClip2 objects without an intervening Shader node.
• Add GrannyLockValue, GrannyUnlockValue, and GrannyClearAllLocks to the XSI plugin.
• Fixed an edge case in the GrannyInlineMember case of GrannyRemapFileStrings. If the inline member began at offset 0 of the containing structure, it was possible for its strings, and those of any referenced sub-objects to remain unremapped.
• During file versioning, objects could have their pointers examined multiple times, which would slow down the version of highly interconnected data graphs.
• Rare issue in GrannySampleTrackUUULocalAtTime0 with custom compressed curves. This caused a valid, but non-unit length orientation member to be set to the LODTransform member, which causes spurious assertions in the debug consistency checks.
• Fixed a bug in the GrannyReferenceToVariantArrayMember case of the GrannyRemapFileStrings. In certain cases, this could cause unremapped strings in unrelated parts of the file.
• Plugin installer for Maya was using short path names in the module initialization files for historical reasons. In newer versions of Maya, this caused the "auto-load" flag to fail on the Granny plugin.
• Added a section to Animation Level Of Detail on using the preprocessor to compute LOD values.
• (internal) Changed the include structure of the runtime source.

• Allow GrannyCompressCurve to handle sample vectors of length 0 or 1.
• New tutorial Model Attachment: attachment.
• "GrannyLoadSettings/GrannySaveSettings" script commands now respond to a "-s" argument in Maya in the same way GrannySetValue command does, settings are applied to the current selection only. In Max, use "GrannyLoadSettingsSelected/GrannySaveSettingsSelected". A similar change has been made to "GrannyChangeSettings".
• Fixed a problem with uninitialized memory in the Maya exporter function GetTextureCoordinate. For certain UV mappings with holes, random stack memory could be returned in the texture coordinate.
• Compatability note GrannyCurveFormatIsInitializedCorrectly function signature changed to allow safe calling of this function when the type information (typically stored in the GrannyStandardDiscardableSection) is freed. In this case, the underlying type match will not be done, but the curve will be examined for a valid format enumeration.
• Max exporter will now generate names for the vertex components in a granny_mesh::PrimaryVertexData member.
• Preprocessor command "KillUncommonData" removes the extended data from granny_file_info::ArtToolInfo.
• New preprocessor command "RemoveTextTracks".
• New preprocessor command "RebaseTextureFiles" which converts absolute texture paths to relative paths, given an applicable base path string.
• Altered the The Variant API to explicitly warn about accessing granny_variant objects after calling GrannyFreeFileSection.

• Add support for Max 2008
• Alter the "PlatformConvert" command to be able to handle string-remapped files. You have to pass a parameter of "-remapped true" to enable the new behavior.
• Fix an error in the string remapper that could leave types for GrannyReferenceToVariantArrayMember members unmapped.
• Fix the handling of the Composite material in 3dsMax.
• (internal) Alter the type signature calculation for string remapped granny_file_builder objects.

• The GrannySetValue and GrannyGetValue commands now have versions that tell the exporter to use the current selection set as the basis for the settings. This ensures that an ExportSelected command will match the desired value. This is mostly important when setting global parameters for models or animations. In Maya, you pass "-s" as the first argument to Set/GetValue, while in Max, these are separate commands SetValueSelected and GetValueSelected.
• "LODCalc" preprocessor command now supports attachment standins. See the header file for details on the command format.
• Better previewing of the DirectX material from Max when there is a sensible software fallback material available.
• Fixed an error in the platform conversion routines that could exhaust the store of fixup remap table entries by double-inserting certain classes of pointer fixup.
• GrannyCalculateLODErrorValues is now much faster.
• Fixed an error in the ExportSelected operation of the Maya exporter. In certain cases, meshes could appear more than once in the final export, even though they were referenced by only one bone.
• Maya's MImage class always returns "4" when queried for the number of color channels, which means that the alpha texture format specified will always be selected. Added a flag to the exporter settings to specify that you want the texture scanned for non-1.0 alpha values.
• Fixed a bug in the S3TC encoder that occasionally manifests when an input block is exactly representable in the S3TC compressed format.
• (internal) Change the Granny implementation of radmalloc to return at least 32 byte aligned blocks to be a more friendly when linked in an application that also uses Bink.

This release corrects two serious errors that were recently called to our attention. It is strongly recommended that you upgrade to this version if possible.

• Fixed a bug in the GrannyReadEntireFile family of functions that manifested when the app runs out of memory. These functions could cause a crash, depending on when the allocator runs out of space. Several functions like GrannyReadFileSection have been altered to report errors as part of this change, however compiles should not break as a result of these changes. There is only one exception in the undocumented API, reported below.
• Fixed pointer aliasing markup in the Xenon target. Bones with only positional animation could use a composite matrix that lags one frame behind the correct value.
• "VertexCacheOptimize" now correctly rearranges vertex annotation entries to correspond to their new locations, rather than killing the annotation set entirely.
• Allow the "VertexCacheOptimize" preprocessor command to elide unused verts in the vertex buffer. Previously this was an assert, but that's not strictly necessary.
• Bugfix in "RemoveElements" preprocessor command.
• (internal) ClearUnreferencedPointers now clears out unused variant array types if the count or destination pointer of the array is 0. This fixes an assertion that would fire on platform conversion.
• (internal) Make sure that all include directives use forward slashes.
• (internal) Loosen up an assert in the granny_stack_allocator.
• (internal) Move granny_mesh_deformer to the header to make it available to applications building from source.
• Compatability Note: GrannyLoadFixupArray has a new argument signature.
• None yet.

Granny now supports SPU sampling on the PS3! Since this is the first public release of the SPU code, we're asking (pretty please!) that you send us feedback if you use the new sampling paths. The new documentation section SPU Sampling Support details how to setup and sample animations asynchronously on the SPU.

• New preprocessor function "MakeSPUAnimation", which will create an granny_spu_animation_info that can be used to create asynchronously-sampling SPU side animations.
• Significant new feature in the exporter: animated material attributes. This will allow you to access granny_vector_track curves for animated parameters like texture transforms, color cycles, etc. Each material now exposes a granny_track_group option in the exporter dialog, so don't be surprised by the increased number of objects in the Animations subsection.
• Allow animated camera and light parameters in Max. If the variable is contained in the [Camera|Light]Info member of the bone, you can obtain the animated value from the granny_vector_tracks if necessary.
• Exporter settings dialog box was blowing away custom settings in edit boxes when higher level settings pages were displayed.
• Fixed a potential stack overflow in the granny_material search functions for granny_material graphs with cycles.
• New undocumented function GrannyFindBoneByRule to match GrannyFindTrackByRule.
• Exposed GrannySampleTrackUUULocalAtTime0 for use in the preprocessor.
• Allocation alignment in the Blend DAG
• (internal) Rearranged several files to make it easier to segregate SPU code without bringing in large swaths of Granny.
• Aggregate allocations could return a size that was not a multiple of the specified alignment. This caused problems for some in-place allocations. Fixed.
• Added support for Maya 2008 (32- and 64-bit versions)
• Changed the "RemapStrings" preprocessor command to preserve file section formats and the platform granny_grn_file_magic_value, which allows it to be used as the last command in the preprocessor chain.
• Fixed a bug in the the 3DSMax Physique parser that only affected the 64-bit plugin.
• Fixed a bug in the data type IO system which caused type coalescing to conflict with string remapping.
• If a sub-object of a granny_data_type_definition described object was NULL, it was possible for the ReferenceType pointer to be left unremapped, leading to problems for tools that walk the entire metadata hierarchy of a granny_file.
• The exporter in 3DSMax will now strip granny_bone_bindings from granny_meshes when the referenced bone does not affect any vertices in either the PrimaryVertex data or any Morph targets. An option has been added to the "Meshes" section, "Preserve Bones affecting no verts" to allow you to select the old behavior.
• Fixed a Bink texture compression crash in the x64 target.
• 64-bit exporter plugins now respect the Oodle1 compression flag.
• Fixed a problem with the image scalers in the 64-bit target when passed an image with a negative pitch. (Maya images, or old-school BMPs, for instance.)
• (internal) Aligned up granny_model_control_binding, and cache the binding type in the alignment member.
• (internal) Add a cached pointer to the instantiated granny_skeleton to granny_model_instance to improve flexibility and alignment.
• (internal) granny_controls will now be allocated on 16 byte boundaries.
• (internal) Moved some string buffers from global scope to local scope.
• (internal) Dead code elimination.
• (internal) Take up the new version of stb_image.c for bugfixes.
• (internal) shuffled the floating exceptional values.
• (internal) Fix a nasty bug in GrannyLinearBlendTransform
• Warn about sizeof(bool) problems in System Dependent Types.
• Guard against NULL granny_model::Skeleton member in GrannyInstantiateModel.
• granny_fixed_allocator blocks are aligned by default to 16 bytes. This does not affect the alignment of chunks allocated from within those blocks, they are aligned to the native structure size.

• Optimized GrannyCopyMeshVertices and GrannyConvertVertexLayouts for common cases. Previously, copying the verts involved a number of string compares on a per-vertex basis, which is obviously bad. Now a copy plan is created when the function is first called, and if the types are amenable, no work other than memory shuffling is done per-vertex. Tests show this to be 10-20x faster than the old method on typical vertex buffers.
• Port the Xenon math improvements to the PS3.
• New tutorial Export Scripting: XSI (along with Using GrannySetValue and GrannyGetValue: XSI).
• New document section Recommended Asset Pipeline, which answers the burning question: if Granny herself was writing your toolchain, what would it look like?
• New PS3 example: ps3_speedcheck, which demonstrates how to implement threaded animation sampling on the PS3 using the pthread library. Found in the "tutorials/platform" directory of your distribution.
• New exporter script function "GrannyClearAllLocks", which removes any setting locks, regardless of location in the settings hierarchy.
• Align granny_local_pose elements to 16 bytes. GrannyNewLocalPoseInPlace will now fail if passed a Memory argument that is not aligned to 16 bytes.
• Fix the export of array numeric attributes in Maya.
• Certain ExtendedData members such as those for granny_meshes were having their inclusion flag in the exporter overriden by the "Include data in export" flag, which was incorrect, and confusing. Fixed.
• For transform nodes with shapes that will not be exported as meshes in the Granny file, attributes on the shapes are now dumped into a "ShapeInfo" member in the ExtendedData block of the appropriate granny_bone, so they're accessible to the toolchain. Geometry nodes still export their attributes to the granny_mesh. Light, Camera, and ParticleSystem nodes are unaffected by this change.
• Fix for the curve rebaser. In rebasing curves with scale/shear transforms, incorrect commutation factors were being picked up by mishandling of the rotation and scale channels.
• Make the preprocessor place types in the standard discardable section in all cases. This makes it possible to always dump the types at runtime, which is a significant memory savings.
• Improve the fast math ops for Xenon and Cell, particularly the fast div.
• Added GrannyAddIntegerArrayMember function for the granny_variant_builder interface.
• Add GrannySetArenaAlignment to allow for aligned granny_memory_arena allocations.
• Fixed an error in the boolean handling of the XSI plugin.
• (internal) Small fix for a radbase interface layer.
• (internal) Add VBScript commenting conventions to the doc extraction tool.

• Fix up the Mac version of the OpenGL tutorial to prevent the skinned shader from falling back to the software path.
• New preprocessor command: "RemoveUnchangingTracks". This command replaces the (removed) exporter option "Store Unchanging Tracks".
• New preprocessor command: "RenameElement". This allows you to rename an granny_animation, granny_model, granny_mesh, or granny_material from the command-line, which makes multi-animation combo files much easier to create. (As well as multi-model, etc., of course.)
• Add triangle annotation for 3DSMax9.
• Fix for the shader compilation in some of the tutorials.
• New exporter option for granny_vector_track exports: "Don't oversample vector tracks", which turns off oversampling for just the custom attribute and visibility track animations. This allows better control over creases and jumps in those curves in certain cases.
• Maya will occasionally write an unrecoverable data attachment in .ma files. This can lead to problems changing the settings in the loaded file. (Settings will be correct for export, but won't persist properly when the maya file is saved.) The exporter now detects and removes these attributes when it can, which loses the settings attached to that node (since they were never written to the .ma file in the first place), but allows the file to be correctly saved with new settings.
• Protect visibility tracks in Max from elision when they are constant.
• Change the way meshes that are referenced by more than one transform node are handled. Previously, these meshes would show up under only one node, which is obviously incorrect. They now appear under each referencing node, and (for the moment) are represented as distinct geometry objects.
• New exporter option to use the full pathnames of meshes, rather than the minimally unique string. This mostly affects Maya; the XSI and Max exporters already use full pathnames.
• Fix some blank ExtendedData members in the Maya exporter.
• Clean up the XCode projects for the tutorials. Fix the working directory behavior such that they run unmodified out of the box.
• Fix a small printing error for inline members in the tree walker tutorial.
• Xenon sample converted to Visual Studio 2005, and updated to the latest Granny and XDK version.
• Simple speed check sample included to demonstrate multithreaded sampling on Xenon. (xenon_speedcheck in the "tutorials/platforms" directory of your distribution.)
• Small fix in the texture loading and material mapping paths of the DX9 Rendering example.
• Rearrange the way that normalized curves (read: Orientations) are normalized in the sampling path. This prevents some duplicated work that was occurring in older builds.
• Fix the "[De]Compress" preprocessor command so that it works correctly on files of non-native platform type. GrannyRecompressFile is now explicitly restricted to files of type of the executing platform to prevent similar errors. The operation of this command can be emulated using the granny_file_builder interface.
• Xenon-specific decompressor for the D4nK8u curve type.
• Add some math ops specific to Xenon to eliminate fdiv and fsqrt instructions that can stall both hardware threads on a core.
• Fixed a bug with shared identity curves. Curve Dimension could be misreported in certain cases.
• (internal) Fix a rare exception case in the exporter.
• (internal) New undocumented function: GrannyDegreesFromOrientationTolerance.
• (internal) Dead code elimination in the exporter

• Hot fix for a material parsing problem in the Maya plugin.

• New tutorial: Simple IK: ik_2bone.
• Compatability Note: Max custom attribute blocks reorganized for scalability reasons. A side benefit is that it's easier to find and extract your custom attribute blocks, but existing extraction routines will need modification. Attributes that previously could be found inline in ExtendedData chunks will now be in sub-object blocks.
• Optimized the platform conversion routines to eliminate a bad linear search in huge files.
• Fix the DDS loader to prevent a crash when the dwLinearSize parameter is invalid.
• Added some logging to GrannyNewMeshBinding to warn when bones are not found in the target granny_skeletons.
• No longer build Max 6 or Maya 5 plugin by default. If you need a fresh version of the Granny plugin for these tools, please contact us.
• Fixed an error in the Wii platform sample, for the case that the sample scene is replaced with a file containing textures without alpha.
• Cleaned up several string comparisons with proper callback check.
• A granny_stack_allocator now returns the address of the new element from GrannyNewStackUnit, rather than a bool indicating success. This eliminates the need to follow the call with GrannyGetStackUnit, which was silly.
• Exporter allocates settings items from a granny_stack_allocator, rather than a granny_memory_arena, which cuts down on the number of allocations, and helps prevent fragmentation in large files.
• Filter granny_mesh::MaterialBindings such that only bindings referenced by a group in the granny_tri_topology are included. This saves a bunch of space for files that use a few Max multi-sub materials as a material library.
• Fixed a flag error in GrannySampleTrackUUULocal. Scale/shear was checking the Orientation curve flag for constant.
• Exporter reverts to using on-disk temporary buffers, rather than in memory. It was bumping up against VM fragmentation issues in large exports.
• Eliminate granny_variant copies from written files if the types are identical at write-time. This saves quite a bit of space in the ExtendedData members of large files, since the created variants tend to be largely the same in any given Max/Maya file.
• New convenience function GrannyBuildRestLocalPose to with GrannyBuildRestWorldPose.
• (internal) Fix system include directive.
• (internal) Handle a memory exhaustion case in the RAD container.

• Fix a normal map crash in the viewer for meshes with no bound materials.
• Viewer will now attempt to load images for files with valid FromFileName members, but no pixel data. Hat tip to David Whatley at Simutronics for the idea. Thanks to Sean Barrett for his awesome public domain JPEG and PNG loading code.
• Compatability Note: GrannyTransformVertices takes an extra parameter to indicate that the vertices represent deltas, rather than absolute values. This changes the way they should be treated when transforming to a different coordinate system.
• Corrected a data loading problem for very old versions of Granny.

• Compatability Note: granny_camera member EAR renamed to ElevAzimRoll. The previous name, EAR, collided with a #define on one of the supported platforms.
• Added the ability to change the encoding settings of the vector tracks associated with custom user attributes, or visibility tracks attached to tool bones.
• Fixed behavior of IgnoreMismatchedTail in GrannyNewMeshDeformer. In the case of completely mismatched tails, those with no prefix in common, the tail should be completely ignored. Before this fix, no deformer would be returned.
• GrannyOneNormalizeWeights will look for 0 weights, and replace the corresponding index with the index of the first bone weight. This is more cache-efficient than the previous strategy of 0-filling, which could cause unused matrices to be accessed by deformers or shaders.
• Simple makefiles provided for the OS X targets.
• Added a "View Vertex Alpha" option to the viewer, to complement "View Vertex Colors"
• Max current vertex channel can be set to MAP_ALPHA, which confused the exporter. Fixed, as well as the face mapping for the alpha channel.
• Fixed a few exporter installer issues with the one-click executable. For certain versions of Maya, Maya would fail to look in the directory it was indicating as the correct module installation location. For Max 9, the 32-bit plugin could be installed when the 64-bit plugin was required, and vice versa.
• Fixed a number of DLL dependency-related problems in the plugins, and the 64-bit Granny DLL.
• Maya visibility attributes will now represent as a vector track in the same way Max vis tracks do.
• Wii platform tutorial rewritten to make it much more like the other platform tutorials, and to exercise more of the rendering pipe.
• Fixed a name error with visibility tracks in the Max exporter.

• New tutorial: OpenGL Rendering: rendering/opengl.
• granny_unbound_track_mask added to represent a granny_track_mask that has not yet been mapped to a specific granny_model or granny_track_group. These are safer when persisted to disk, since you can map them to bone orderings that weren't necessarily known at the time the mask was created. granny_track_mask itself is abysmal for this, since the weights are stored as a flat array, without name bindings. You create a granny_track_mask from an granny_unbound_track_mask by using either GrannyBindTrackmaskToTrackGroup or GrannyBindTrackmaskToModel, depending on whether you want a model mask, or a track mask.
• New member type for granny_data_type_definition, GrannyEmptyReferenceMember, which is a placeholder element only, designed to represent a pointer-sized member. These are always NULLed on output, so Granny will not manage memory, free buffers, or check types for any pointer values you store in these. This can be handy for reserving space for run-time allocated structures that you will fill in yourself, that aren't intended to be persisted to disk.
• New function to keep compression and alignment settings constant across file modifications: GrannyPreserveFileSectionFormats. GrannyPreserveFileSections renamed to GrannyPreserveObjectFileSections to distinguish it from the new function.
• Compound custom attributes now handled correctly in Maya. These represent as either a GrannyReferenceToArrayMember or a GrannyReferenceMember in ExtendedData blocks, depending on whether or not the source attribute was an array.
• Added a new switch to the Maya exporter, "-extNode". If this optional switch is present, the given node will be scanned, and it's attributes used as the ExtendedData field of the ArtToolInfo. This allows the extraction of application custom data for plugin nodes that may not be MFnDAGNodes, and therefore hidden from the scene walker. Any class derived from MFnDependencyNode can be used for this purpose. Hat tip to Arena.net for the suggestion.
• Unbound meshes are now rendered in the viewer at their origin, unless "Hide Unbound Meshes" is enabled in the mesh preview menu.
• Fix a problem in the "Use Accumulator Neighborhood" setting. Granny wasn't always respecting this override in the runtime.
• PS3 Unix-style IO enabled by default. It's still recommended that you replace these routines with your own file handlers, but having them not work "out of the box" is a bad idea.
• New preprocessor command "TouchVersion". Updates a file to the latest format, to prevent the need for runtime conversions.
• Fix the PS3 sample for the new behavior of GrannyCopyMeshVertices (the compat note in 2.7.0.17.) PS3 libraries updated to the 160.008 release.
• Support for Max particle systems derived from SimpleParticle added. The parameters for the particle system appear in a "ParticleInfo" member of the ExtendedData field of the granny_bone that represents the transform of the particle system. (In the same manner that Camera or Light information appears.) Because the SimpleParticle parameters are based on the older IParamBlock interface, rather than the newer IParamBlock2 interface, some of the names of the parameters are unrecoverable. These parameters are given dummy names "UnnamedParam_[Index]". At the same time, a filter was added for some of the spurious objects generated by these particle systems to prevent model clutter.
• Calling GrannySetFileSectionFormat with obsolete Oodle0 compression results in Oodle1 compression being selected.
• (internal) Added an internal granny_track_group_builder option that makes the final version of the granny_track_group in a granny_memory_arena, with several small allocations rather than one large alloc to work around virtual memory framentation in the DCC packages.
• New function GrannyBeginSampledAnimationNonBlocked, which creates a granny_track_group_sampler with individually allocated buffers, rather than one monolithic alloc. This helps work around the VM fragmentation problem in Maya.
• (internal) Added an optional post-deformation transformation step to the granny_mesh_deformer. This makes it straightforward to create deformers that are simple permutations of existing accelerated deformers.
• (internal) Switched the exporter back to on-disk temporary buffers, also to work around VM fragmentation.
• For granny_file_builder objects where the temp buffers are created on disk, the compression buffers are also now stored on disk. Another VM fragmentation fix.
• (internal) Fixed a bug in the case that the Aggregate Allocator fails to acquire the requested memory. Output pointers were not being properly NULLed, and since some accounting data is stored in the pointer location itself, this could cause the return of invalid, non-zero pointers, which were incorrectly interpreted as representing a successful allocation.
• (internal) Add some range guarding to the binormal and normal to uint8 conversions.

• Prevent 0-size objects from being written out in GrannyWriteDataTreeToFileBuilder. These cause severe problems in the file output and conversion routines, since you can wind up with distinct objects sharing a pointer value, which corrupts the internal hash table used to flatten the object tree.
• Fix a bug in the XSI exporter relating to vertex colors. In certain cases, the vertex color property was being walked with an incorrect stride.
• Prevent 0-sized objects from being generated by the file property exporter in Max.
• Added GrannyAbortVariant to terminate a granny_variant_builder without generating the result object;

• New tutorial: Level of Detail: lod.
• Explicit support for collected string databases added with the new type granny_string_database. Added new preprocessor commands "ExtractStrings" and "RemapStrings" that help you build string databases from your .gr2 files, and do the remapping of literal strings to database entry indices.
• The tutorial String Replacement: string_table has been reworked to reflect the new granny_string_database type and related APIs.
• Granny Files, Raw Files, Compression, Sections, and All That Stuff: Converting Strings to Indices has been rewritten to account for the newly supported granny_string_database type and surrounding APIs. Full CRC replacement of strings with no backing store has been moved to the "email us and we'll explain" section of the API. In almost all cases, using granny_string_databases is the correct thing to do.
• New API GrannyRemapFileStrings to support replacing strings at the granny_file level, so version conversion of remapped strings can proceed smoothly during calls to GrannyGetFileInfo.
• Granny now supports float16 data types. You can use these in your vertex formats by specifying GrannyReal16Member. Conversions to and from these fields work exactly like GrannyReal32Member. Conversions to and from GrannyReal32Member work as expected.
• Compatability Note: GrannyCopyMeshVertices contained some undocumented transformations for compressed vertex formats generated by the older Granny preprocessor. To prevent unpleasant surprises, these have been removed. These transformations are better handled as (new) preprocessor commands.
• When old format files are loaded, the older magic value (GrannyGRNFileMV_Old) is replaced with the appropriately matching new magic value. (In all cases, this will be GrannyGRNFileMV_32Bit_LittleEndian or GrannyGRNFileMV_32Bit_BigEndian.) This allows easier error checking and edge case handling in some of the loading paths.
• GrannyRecompressFile now supports input and output file names that are the same.
• Added an export option to flip either the U or V coordinates of a mesh at export time. This allows you to revert to Maya's default interpretation of the V coordinate, if you choose.
• Fixed a bad assertion in the file loading relating to section with no pointer fixups or mixed marshalling entries.
• Fixed a bug in GrannyRecompressFile relating to the references for the Root object and type definition.
• granny_vector_track has been altered to allow easier hook up to the source object in cases where multiple vector tracks share a name. For instance, a "foot_down" track applied to multiple objects in the scene. Each granny_vector_track now contains a "TrackKey" member that can be matched to a bone by using the new GrannyVectorTrackKeyForBone API. The initial value of the attribute is still stored as "<AttributeName>" in the source object for compatability reasons. Ideally, we would provide a direct pointer reference from the ExtendedData variable to the granny_vector_track, but in certain cases this simply won't work. (Imagine a case in which the granny_bone "RightFoot" contains a "foot_down" track, but the granny_model is stored in a separate GR2 from the granny_animation. Similiarly, this mechanism supports multiple animations with identically named tracks.)
• Tightened the OBB bounds for meshes in the granny_mesh::BoneBindings structures. The exporter was including the bone transform in the bounding volume, which is not necessary.
• Note: granny_grn_file_header version tag GrannyCurrentGRNFileVersion bumped to 7. This will cause log messages about file format mismatches until your assets are rebuilt. There is no compatability problem here, older files will continue to load in newer versions of the library, and new files will (to the extent they did before) load in older versions. Something to be aware of.
• In the "projects" directory of the Win32 and Win64 distributions, we now provide ready-made projects to build Granny from source. Building Granny from Source updated to reflect this.
• New undocumented API GrannySetFileStringDatabaseCRC for ensuring proper matching to the granny_string_database that contains its remapped strings.
• Similarity transformation functions such as GrannySimilarityTransformCurveQuaternion were not correctly handling keyframed curves in certain cases.
• GrannyBasisConversionRequiresCurveDecompression was returning results of opposite sense from the name. I.e, a "false" result indicated that the curve did need decompression. Fixed.
• GrannyFindAllowedLODError parameter names corrected. Should have referred to viewport height, and vertical FOV, since those are the values most likely to accord with granny_camera settings. There's no compatability problem here, both are equivalent.
• (internal) Fix a distribution problem with the exporter source.
• (internal) Check assumption that Linear3x3 and InverseLinear3x3 are, well, inverses of each other in the GrannyTransformFile family of APIs. If they aren't send the transformation through the slow, non-swizzled path.
• Fixed allocation error in the LODCalc preprocessor command, and a potential NULL access in CleanMaterials.
• (internal) Fix intrinsic memset and memcpy in the debug distribution.
• (internal) Fix an alignment mismatch in an external declaration (_gbitlevels)
• (internal) Max normals pulled from the MeshNormalSpec in all applicable cases.
• (internal) Simplified the compression preprocessor commands by using the already existing GrannyRecompressFile API. This ensures that the file platform, sectioning, and any remapped strings are correctly preserved.
• (internal) Doc grouping fix for granny_pointer_hash documentation.

• New tutorial: Export Scripting: Max.
• New tutorial: Export Scripting: Maya.
• Some of the preprocessor commands that remove data or modify it in place have been updated with the GrannyPreserveFileSections API to keep exporter- or user-controlled sectioning in place. Preprocessor commands that add data, or create new data still output single section granny_files. You can fix those up with the exporter's default sectioning by using the "ResectionFile" command following a destructive operation.
• Preprocessor commands can now specify to the driver program whether or not they accept multiple files, or only a single input file. This removes the need to duplicate some of the error handling code and parameter validation in each command module. Tip of the hat to David Whatley at Simutronics for the suggestion.
• Improved the RemoveElements command of the preprocessor to recursively clean references to objects removed at the top level of the granny_file_info structure. Previously, if you ran the command with "-remove Skeletons" for instance, the granny_skeleton objects would actually be left in the file, since the granny_model references to them would still be present. Now the entire data tree is walked to clear references to the removed objects.
• Improved the CleanMaterials command to remove granny_texture objects no longer referenced by any granny_material after the cleaning pass.
• Fixed a problem with the computation of granny_bound_transform_track acceleration flags in the animation rebasing path.
• Added support for the Max "Normal Bump" material. If you have other Max materials that aren't exporting properly, please do let us know. Max's architecture makes it very easy for this to happen without our knowledge.
• Fixed a instance detection error in the XSI plugin that caused materials assigned to multiple meshes to be duplicated in the exported .gr2 file.
• XSI Plugin Python code changed to JScript to remove requirement that the Python runtime be installed before using the Granny exporter.
• Fixed a (non-error causing) case fallthrough bug in GrannyConvertVertexLayouts.
• (internal) GrannyEndLocalPoseAccumulationLOD was using GrannyBlendQuaternionNeighborhooded rather than GrannyBlendQuaternionAccumNeighborhooded to choose the blending arity for the reference pose fill. Since the comparision being made in the first case is to the same granny_skeleton transform being blended in, this was both wrong, and not very pointful.
• Plugged a documentation hole in Using GrannySetValue and GrannyGetValue: Max about referencing materials in GrannySetValue calls.
• Fixed a distribution error for the online GrannySetValue documentation, and a linking bug for those docs in the exporter.
• Physique bindings in Max can report the same bone multiple times. This sometimes resulted in bone binding lists for a granny_mesh that exceeded the number of bones in the underlying granny_skeleton. Certain sampling paths will report an error in this case. Each bone should now appear once and only once in the binding list.

• New tutorial: Morph target animations: morph_targets
• New tutorial: Blending Controls: blending
• New doc section: Creating Morph Targets. Note that the morphing documentation from Granny Data Loading Overview has been split up and relocated to Vertex Curve Animation, and Creating Morph Targets: Frame-By-Frame Morphs.
• New doc section: Vertex Curve Animation
• DirectX 9 Rendering: rendering/dx9 switched to runtime-compiled effects, rather than precompiled shaders. This is a more flexible and "DX9-ish" way to go about selecting the appropriate shaders. Since we have a proper DX8 tutorial now, there's no longer a need to maintain easy back-portability in the DX9 specific sample.
• Compatability Note: To better support morph targets, the "Extract Frame-by-frame" option had to be changed from a boolean value to a possible value for the morph enumerant. This means that stored settings in your Max or Maya files will need refreshing in order to function as before.
• Max exporter now directly supports the Morpher modifier for extracting MorphTarget meshes. Likewise, the exporter now supports the Blend Shape modifier in Maya. Morph channel animations will show up in the exported file as a separate granny_animation with the morph channels encoded as granny_vector_tracks.
• For morph targets created from either the Max "Morpher" or Maya "Blend Shape" modifiers, Granny allows you to encode the morph shapes as deltas from the base mesh. This lines up closely with the algorithm used to generate final morphed meshes in both tools. You can, of course turn off this behavior if you want to use a custom lerping scheme for your mesh data.
• Fixed a "Principle of Least Surprise" violation in the Oodle1 decompressor. On byte-reversed platforms, decompression would modify the data buffer, which is passed in as a const void*.
• Fixed a bug in the XSI exporter that was preventing exports initiated from the File|Export menu from opening the export interface.
• Viewer now supports .gr2 files that contain more than one animation.
• XSI GrannyExport command explicitly looks for default arguments passed when the command is invoked from the plugin manager window.
• Granny now supports the new Maya 8.5 release.
• Added GrannyOrientationToleranceFromDegrees to the API to assist in determining reasonable error thresholds for orientation tracks compressed with GrannyCompressCurve.
• Removed "Swap R and B channels" option from the exporter. This can easily be handled with a preprocessor command, and as the colors are exported as granny_real32 values from the exporter rather than D3DCOLORs, there's no particular reason to do this.
• Fixed a threading problem with the vertex API, some of the functions in the GrannySetVertexNormal class were marked as GS_PARAM, but were accessing global state. They now access only local state, so they're properly GS_PARAM safe. See Granny in a multithreaded environment for details on wha that entails.
• (internal) Fix a dll loading error in the Max 9 plugin.
• (internal) Tweaked the Maya 8.5 build to play nicely with Visual Studio 8 and Microsoft's marvelous manifest technology. No, really. It's marvelous.
• (internal) Fixed a doc linking error

• Important distribution change! Libraries and binary modules are now all put in a platform specific directory under "lib" or "bin". That means when you upgrade, don't just unzip the distribution on top of the older directory. You need to make sure that the old lib file is gone to prevent version mismatches. (You're using GrannyVersionsMatch, right?)
• New tutorial: Using the Granny Camera: camera_utilies
• New tutorial: String Replacement: string_table
• New tutorial: Using Track Masks: track_mask
• New tutorial: Traversing Granny's Object Metadata: tree_walker
• New tutorial: DirectX 8 Rendering: rendering/dx8
• Altered granny_bound_transform_track to save some space. This optimization mostly helps runtime memory constrained games that have disabled the LODTransform optimization in that structure, but should save a bit of memory for all users.
• XCode 2.4.1 projects now provided for the tutorials for use on Intel Macs. For projects that depend on Win32 specific APIs like Direct3D, there are no XCode projects, of course, but you can build the majority of the tutorials natively on the Mac now. If you need projects that correctly handle PowerPC Macs, please let us know!
• Xenon platform example
• PS3 platform example
• Modified granny_track_group_builder so that all identity curves in a granny_transform_track share the same representation in the final file. This can save quite a bit of space in the final in-memory representation of an animation.
• GrannySampleModelAnimationsAccelerated was not correctly noting track or model masks set on granny_controls.
• Exported granny_pointer_hash to the undocumented interface. This structure is used by the file API and the exporter to detect and handle data cross references. More info in Traversing Granny's Object Metadata: tree_walker.
• Fixed a bug in the ANSI file writer. granny_file_writers created with the EraseExisting flag set to false were using "a" as the open mode. The correct mode is "r+b".
• Simple breakpoint asserts for the Mac Intel target.
• (internal) PS3 libraries compiled and tested against the 1.32 SDK revision.
• (internal) Checked conversion to 16-bit integer.
• (internal) Fixed an OS X distribution bug.

• New tutorial: Downloading S3TC Encoded Textures in OpenGL: s3tc/opengl.
• New doc section: Bone ordering in granny_skeleton, explaining the way granny_skeleton's granny_bone array is layed out by the exporter.
• Fixed a viewer bug for texture-only .gr2 files.
• Added some missing consistency checks to GrannyBuildRestWorldPose.
• Added a new texture format selection in the exporter "Determine from Source". The intent of this option is to make it possible to have textures already compressed with S3TC (or possibly other formats in the future) autoselect the correct format in the exporter.
• Created 2 versions of the "GrannySetValue" documents, one for Max, and one for Maya. Available as Using GrannySetValue and GrannyGetValue: Maya or Using GrannySetValue and GrannyGetValue: Max.
• Some 3dsmax node properties that were missing before are now exported.
• Fixed a linking bug in the PSP libraries.
• Fixed a bug in the exporter when exporting files with no type information to a platform other than the native exporter platform. This necessitated changing the signature of GrannyPlatformConvertReaderToWriter to indicate if type information should be omitted.
• Incorrect granny_grn_file_magic_value passed in the PlatformConvert command of the preprocessor.
• Improved the reversability of the DXT1 encoder. Any RGB pixel array that was converted using from_S3TC1 should now yield exactly the same image after a call to to_S3TC1.
• Removed "Store Unchanging Tracks" option from the exporter settings dialog. This option is not safe unless the base skeleton for the model is present to compare with. You can accomplish the same thing in the preprocessor if the functionality is necessary, there you can ensure that the root pose of the model is correct before eliding track data.
• GrannyExcludeVariantTypes option removed from GrannySetFileDataTreeFlags options. This is a legacy setting that won't function properly in newer versions of Granny. This setting was also removed from the exporter.
• Fixed a compression bug when writing a file for a reversed platform. This required changing the function signature for GrannyOodle1End and GrannyBeginFileCompression.
• Fixed a pointer-size error in platform conversion caused by overzealous file identity maintenance.
• Fixed a bug introduced when a granny_file_builder is using temporary disk files (i.e., GrannyBeginFile rather than GrannyBeginFileInMemory.)
• Mac Intel build switched to the 9.1.029 version of the Intel C Compiler for compatibility with Xcode 2.4.1.
• (internal) HTML generation for external documentation improved.
• (internal) Fixed incorrect handling of tiny S3TC miplevels.

• The Granny Exporter now supports XSI 5.11! This release is an open beta of the plugin for licensees and eval clients, We're asking for feedback and sample data to help us cover all of the features XSI exposes.
• The Granny exporter now attempts to maintain the property that exporting a file twice from a DCC package will yield the same bits in the resulting .gr2 file. This can help automated build scripts determine which files need to be rescanned for dependencies or checked into source control.
• New tutorial: Downloading S3TC Encoded Textures in DirectX 9: s3tc/dx9
• granny_file_data_tree_writer may modify the bits passed in through the RootObject parameter to ensure that unused pointers and count variables are zeroed on export. GrannyBeginFileDataTreeWriting's signature changed to reflect this. Since GrannyConvertFileInfoToRaw is little more than a wrapper around GrannyBeginFileDataTreeWriting, it's signature changed as well.
• Extended the granny_variant_builder to accept boolean and unsigned integer inputs. (New functions: GrannyAddBoolMember and GrannyAddUnsignedIntegerMember.)
• Max file properties exposed in the granny_art_tool_info of the created granny_file_info. Both granny_art_tool_info and granny_exporter_info now contain ExtendedData fields for storing such information.
• GrannyGetMagicValueProperties and GrannyGetThisPlatformProperties will now accept NULL for either or both of the property parameters.
• Ignore hidden attributes by default in Maya. These tend to be material sampling parameters and node cache state variables that are not deterministic, and have limited utility.
• Added an option to the exporter to flip textures vertically or horizontally on export.
• Exposed the GrannyLoadFixupArray function as an undocumented function for detailed control of file IO.
• Added undocumented functions for retrieving the granny_track_mask object applied to a control when using a granny_controlled_animation_builder. These are left undocumented because they have extremely limited applicability, especially when you're dealing with complicated controls affecting multiple models.
• (internal) Added some missing Vector*N functions.
• (internal) Fixed a crash in the viewer with models missing their skeleton.
• (internal) Settings requester takes local copy of DCC string

• This release is mostly a point release to update the 3dsmax 9 plugin to the retail version. Previous Granny releases contained a plugin compiled against the M059 beta of Max 9, which the retail Max9 cannot correctly load.
• New tutorials: Parsing ExtendedData Fields: extended_data and Customizing the Preprocessor.
• Preprocessor commands registered with a helper class, rather than in a table in preprocessor.cpp. This makes it possible to add commands without modifying the base preprocessor source, which should facilitate upgrades.
• Preprocessor is now a root-level directory in the SDK zip files, not the exporter zips. That was the wrong place to put it.
• Changed the preprocessor command arguments to take a granny_memory_arena argument for allocations. Previously the default Granny commands deliberately leaked memory. This allows them to be a bit more hygenic, which may make it easier to chain them together in compound command functions.
• Maya and Max exporters place the type name of object in the ExtendedData entries for camera, lights and materials, which can help distinguish, say, between a spotlight and a directional light.
• Fixed a bug in the preprocessor "[De]Compress" and "PlatformConvert" commands that could cause problems on files with fewer than the standard number of sections.
• (internal) Changed the way the exporter retrives stored settings data to make things easier on the upcoming XSI plugin.
• (internal) The linker was kicking out the scripting functions for the Max plugin. Fixed.
• (internal) Track the Max 9 registry key for installation.

• New Tutorials: The Granny tutorials have been entirely rewritten and reorganized to get you up and running in the absolute minimum possible time. See Tutorial Overview for details. These are still very much works in progress, so over the next few months we'll be filling in a huge number of pieces.
• GrannyReadEntireFile now marked as "Reads Global Data" rather than "Safe". This reflects the fact that it accesses the default file reader callback. GrannyInitializeFileReader marked as "Safe", since all accessed values are passed in as parameters.
• Preprocessor can now restore the default file sectioning scheme created by the exporter with the command "ResectionFile". This helps preserve the discardability of Granny data used only for initialization, even after heavy preprocessing. In addition, the "Compress", "Decompress", and "PlatformConvert" have been modified to preserve sectioning, since they are typically executed at the end of a preprocessor command chain.
• New function GrannyPreserveFileSections, which helps to maintain file structures when reading in Granny files to modify them and write them back to the filesystem. This allows you to specify that the object section placement in the Granny file structure should be the same as it was in the source file, for objects that are carried over directly. You can still override the behavior with GrannySetFileSectionForObject if necessary.
• Added GrannyGetLogMessageTypeString and GrannyGetLogMessageOriginString to make formatting error output easier.
• A few enums in granny_log_message_origin have been renamed for consistency with the rest of the supported values. These are GrannyMeshBindingLogMessage, GrannyTrackGroupLogMessage, GrannyThreadSafetyLogMessage, and GrannyQuantizeLogMessage.
• const-correctness of the Granny API improved. In particular, many more functions now take const parameters when they don't modify their inputs. GrannyGetMeshBindingFromBoneIndices and GrannyGetMeshBindingToBoneIndices now return const pointers to the bone index arrays, since these shouldn't be changed by the app, which may require you to add const to the pointer if you are storing the return value of these functions.
• Dead code and unexported functions in the main Granny source tree removed where appropriate. If you were using any of the now missing utility files, please let us know, they're available as a secondary distribution.
• Fixed a memory leak in the exporter in the vertex morph curve extractor.
• Added GrannyGetBlendDagNodeCrossfadeWeights to allow querying the current state of a node before changing with GrannySetBlendDagNodeCrossfadeWeights.
• (internal) Fixed a bug in the track sampler functions when using GrannySampleModelAnimations rather than GrannySampleModelAnimationsAccelerated. Constant value position and orientation tracks were not being correctly handled.
• (internal) Fixed a doc typo in the LightInfo extraction example.
• (internal) Source code consistency pass.
• (internal) Restored a missing log message on GrannyReadEntireFile.

• Viewer will now search for more than just the first matching model for an animation. This allows partially exported files to be viewed together. (E.g., character and sword.) This only applies to "raw" animation files, i.e, files that contain no meshes. (Models are still allowed.) Files that contain both animations and meshes will bind internally without searching the larger scene.
• Viewer can now display vertex colors on Granny meshes. Only the first diffuse color is supported for now, and alpha is ignored. In the "Mesh Inspection" menu, select "Show Vertex Colors" to activate them. For clarity, when vertex colors are active, lighting and texturing are disabled.
• Viewer now accepts drag and drop from the explorer. You can drag one at a time, or in sets for quick file loading. Props to AndyG at Giant Bite for the suggestion!
• Exporter will now dump 3dsMax visibility tracks as vector tracks with the name "<NodeName>_visibility". The full floating point visibility range is exported, if you want to threshold this to a binary text track, this is easily accomplished using the preprocessor.
• Preprocessor now directly supports Animation LOD computations. Use with the new command "LODCalc".
• Preprocessor can combine elements from multiple Granny files to create composite files. For instance, a character.gr2 file might contain the models, meshs, and all the animations required for the game for that asset. You can now use the "CombineElements" preprocessor command to do this.
• PS3 basic sample converted to use the more efficient NoComposite granny_world_pose sampling path.
• Altivec optimized the NoComposites transpose path for the PS3.
• New Exporter script command "GrannyListValues" which has syntax similar to GrannySetValue, but allows you to get a string array representing the values Granny is storing at that node level. Also new is the command "GrannyListComboboxValues", which will give you a list of the valid settings for the multiple choice entries in the settings.
• New Exporter script command "GrannyChangeSettings", which allows you to interact with the settings dialog without actually exporting the file. Props to Ken Grey at Firaxis for pointing out this missing feature.
• Exporter will not cause the "Export Module Failure" dialog in Max when the user selects "Cancel" at the settings dialog.
• Added the ability to drag the split in the "Detailed Data View" of the Granny viewer. This should make it easier to examine long strings or transform data.
• Switched to using the newer "Alias" registry key for the Granny Exporter installer. The older "Alias|Wavefront" key may be missing or incorrect in newer installs.
• (internal) Stopped building Max 5 plugin by default.
• (internal) Fixed some Gamecube linking problems.
• (internal) Worked around a problem with Granny's use of the Max MeshNormalSpec interface. Non-explicit normals reported through this interface were not correctly mirroring the results expected from the smoothing groups.

• Fixed a missing flag in GrannySampleTrackUUULocal for animations with constant Scale/Shear.
• Optimized the granny_track_samplers for granny_transform_tracks with constant elements. These all use the LODTransform member of the granny_bound_transform_track they are sampling, which cuts down on cache misses, since they don't need to touch the (possibly non-contiguous) memory for the constant curve.
• Pushed back the practical limit on mesh size in the exporter again.
• New script commands "GrannyLockValue" and "GrannyUnlockValue" added to control value locks in the exporter settings.

• Major speed win on X360 and PS3 by careful prefetching in the sampling paths. You should definitely get this release before shipping a game on either platform. Our stress test sped up by over 25% as a result of these optimizations.
• The Granny Preprocessor has undergone a major rewrite. We've redesigned it so that it's much easier to add your own data processing functions to the tool, and easier to fit into an existing tool chain. The previewing functions have been entirely removed to encourage cross-platform use, and the tool is structured to perform simpler and more general operations. We'll be distributing the prebuilt version of the preprocessor with the exporter now, rather than the SDK, since it really is a part of the Granny toolkit. Over time, operations that previously were accomplished with exporter settings will be moved into the preprocessor. If you're not using the preprocessor yet, check out the documentation in The Granny Preprocessor, you may save yourself the trouble of writing a custom tool.
• GrannyNewWorldPose now has a sister function GrannyNewWorldPoseNoComposite that allows you to create a granny_world_pose without the Composite_4x4 array. This is intended to help you save memory by allowing you to specify the location in which the composite array will be computed. If you are working on a title for Xenon or a DX10 game, you'll want to look into this. (The distinguishing feature that sets these platforms apart is that constant buffers are preferred over register constants. This change allows you to build the constant buffers directly in place without memcpys or index marshalling.) Several functions have been slightly altered to indicate to Granny which pathway you want. (More details in Compatibility with Older Versions of Granny: Full List of Compile-Breaking Changes.) Some of the major function changes of which you should be aware: GrannyBuildCompositeFromWorldPose has been renamed GrannyBuildWorldPoseComposites to contrast with the new function GrannyBuildCompositeBuffer and GrannyBuildIndexedCompositeBuffer. More details can be found in Reducing the size of your data: Smaller World Poses and Notes on CPU and Memory Performance Optimization: Animation speed issues.
• Cell and Xenon paths for granny_world_poses without composite matrices optimized.
• Granny/Aegia physics examples added to the distribution.
• Added options to the vertex morph curve extraction process to allow exclusion of quantized formats, control of curve degree reduction, and selecting aggressive curve compression. These are essentially the same as the options for bones, but are separately controllable at the mesh level.
• New type introduced: granny_matrix_3x4. This allows the easy construction of skinning buffers for vertex shading that use only the necessary components of the composite matrices. (The last row is implicitly [0, 0, 0, 1].)
• Fixed a fencepost bug in the vertex animated curve extractor.
• Missing function GrannyBuildWorldPoseNoCompositeLOD added.
• New function: GrannyColumnMatrixMultiply4x3Transpose exposed.
• GrannyColumnMatrixMultiply4x3, GrannyColumnMatrixMultiply4x4, and GrannyColumnMatrixMultiply4x3Transpose assume that their IntoMatrix matrix argument does not overlap either of the source matrix arguments. (The source matrices may alias each other without error.) This allows the compiler to generate better code for the multiplication routine on platforms that support restricted, or noalias pointers. Incorrect results would have occurred had this convention been violated, so the new restriction is unlikely to affect older client code.
• granny_file now contains the granny_grn_file_magic_value it was determined to have at load time. GrannyReadPartialFileFromReader now passes that value back in the granny_file structure itself, so its second argument was removed.
• Added a handler for StringArray attributes in Maya. Helps fully support the HLSL plugins.
• GrannyBuildTangentSpace now operates on a granny_mesh_builder rather than a ill-defined set of arrays.
• granny_mesh_builder API changed to allow the building of meshes that previously could exhaust memory. This required renaming or removing several functions that allowed random access to the internals of the builder. For a full list, see the Compatibility with Older Versions of Granny: Full List of Compile-Breaking Changes.
• Modified granny_stack_allocator for better random access. If you pass a maximum number of units that the stack will hold, Granny builds a block directory for quick lookup.
• GrannyExport script commands can now suppress the progress window if you want. In Maya, this is done with "GrannyExport -showProgress off", in Max, you'd execute "GrannyExportSilent".
• Linux source-only distribution added. Currently we support the x86 platform. If you have an interest in PPC, or another little-endian Linux architecture, let us know!
• Release name convention change: "pre-release" is changed to "release", "release" changes to "final". This is to prevent confusion when obtaining newer versions of the Granny library. All versions of the SDK uploaded to the FTP site are stable enough for shipping products, but the names were confusing enough to prevent coders from picking up useful features or fixes in the latest version. The version of the SDK that you should download is always the highest numbered version on the website. If you are very close to shipping, and are concerned about source changes required for an upgrade, check the Compatibility with Older Versions of Granny: Full List of Compile-Breaking Changes, or write to us at granny3@rad.
• Fixed a bug in GrannyBuildRestWorldPose that would crash if passed a NULL offset.
• Fixed a Maxscript bug that prevented setting the exporter values for textures and materials.
• Demo build procedures updated to track the location of your DirectX SDK directory. We still can't be sure where you'll put the Granny SDK, so you may have to alter the project files to point to the installation directory. We've temporarily removed some of the examples while they undergo updating.
• (internal) fixed a bug in the keyframed data generator
• (internal) Reorder the curves in granny_transform_track for better cache performance.
• (internal) Remove spurious log message when calling GrannyGetWorldPoseComposite4x4 or GrannyGetWorldPoseComposite4x4Array on a "no-composites" granny_world_pose. This is a valid way to check if the composites need to be built.
• (internal) Changed the way the bool type is handled when granny.h is compiled as a C file, rather than C++. It was possible before for the size of the bool type to be incorrect with respect to the size used when the library itself was compiled, leading to incorrect generated code in a client application. Props to David Bradley from Heuristic Park for pointing this out.

• Major exporter change: the settings have been partitioned into "basic" and "detailed" sets. This doesn't affect scripted access to the options, but presents artists with a view that focuses only on the most commonly altered settings. For a few releases, we'll leave the default setting as checked to ease the transition.
• Altered the granny_mesh_deformer API to allow applications to ignore portions of the destination vertex type that don't match the source format. GrannyNewMeshDeformer changed to accept a granny_deformer_tail_flags to indicate which behavior is desired. For the old interface, pass GrannyDontAllowUncopiedTail. This is recommended unless you specifically want the tail of the formats to contain untouched entries.
• New setting available on the animation tracks: "Use Accumulator Neighborhood". This changes the blending behavior of a track if the runtime detects that the track needs to be neighborhooded to the rest pose. In certain rare cases, you want to disable this behavior, and neighborhood to the accumulation in progress. This changed the function signature of GrannyBeginTransformTrack to include a flags field. Altered the document section Advanced Animation: Local Pose Operations to help explain the issue.
• Reworked the Basic Model Setup and Animation document by breaking it up into smaller logical pieces. Refocused the Animated Mesh Deformation section to focus on shader-based deformation rather than software deformation through a granny_mesh_deformer.
• New documentation on creating a shader-based rendering pathway added: Animated Mesh Deformation: Shader Mesh Deformation.
• Fixed a thread-safety issue in the granny_mesh_deformer API. Match parameters are no longer stored in the static copies of the deformer table entry.
• Added GrannyUpdateWorldPoseChildren, which recomputes only the granny_world_pose matrices for bones that are children of the given bone. This is an optimization targeted especially at GrannyIKUpdate and GrannyIKUpdate2Bone, which require rebuilding only a small section of the overall granny_world_pose.
• Fixed a problem in the exporter that caused Max to not understand that changes to Granny settings require that the file be saved in order to preserve them. For various reasons having to do with the way Granny stores its settings in the .max file, the simplest way to accomplish this was to require a save whenever the export interface is interacted with. Scripted exports will not cause the "file modified" dialog to appear. Interactions with the settings through the GrannySetValue Maxscript command work as expected.
• granny_file_builder write out process altered to make loading a linear sequence of disk reads in all cases. Previously, certain section orderings could cause back-tracking in the files.
• Maya particle emitters were not properly registering as transform nodes. Fixed that problem. As a bonus, we now dump the emitter information into the extended data for the bone.
• Fixed a bug in the tangent space generator that could cause 0 length tangents in certain degenerate cases.
• Replace the remote control demo with a more interesting Gryphon model.
• GrannyGetBoneCountForLOD early out
• Granny works with PS3 SDK 090, including the basic sample app.
• (internal) Spline samplers, knot extractors, Xenon accelerated bone operations, etc. use the NOALIAS keyword to improve code generation.
• (internal) Added NOALIAS as a compiler define to help optimizations by picking out pointers that can't possibly alias each other.
• (internal) More warning cleanups.
• (internal) Added StringDifferenceOrCallback to forward difference operations to the user granny_string_comparison_callback where appropriate.

• So you say you want a Revolution? Wii do, too! Support for the new Nintendo console added.
• Exporter multithreads the curve compression stage on machines with more than one processor.
• Added a note to the GrannySetAllocator docs to specify expected behavior when Granny passes NULL to the deallocation callback.
• Fixed an alignment error in the platform conversion code. Internal array members and inline structure members were being improperly aligned.
• Fixed a pointer size bug in the 64 bit 'Blade' plugin.
• New sample scripts to quickly preview an animation from Max or Maya in the Granny Viewer. (Look for grannySimpleView.* in your distribution.)
• Added support for 32 and 64 bit versions of 'Blade'.
• Added support for 32 and 64 bit versions of 'Makalu'.
• Many functions and structure members with char* parameters or members changed to char const* for better const consistency. Some similar changes have been made in the curve API.
• MacOSX build uses x86 hand-optimized BuildWorldPose and Deformers.
• Reorganized the Overview and In-depth sections of the documentation to seperate out Coder and Artist documentation. Added So, you're the lead to serve as a starting point.
• Documented the Variant Builder API. (The Variant API)
• Added documentation on reducing memory and disk usage, Reducing the size of your data.
• Added documentation section How to Loop Animations to codify the correct way to loop animations with Granny, as a suppliment to Animation FAQ: Animation Frames.
• Added a summary section (Understanding Model World-space Movement: The Bottom Line) to the Root motion documentation to make it easier to pick up the most important points about Move To Origin and VDA.
• Switch the "Crowd Scene" demo to the Granny timer (from QPF) to reduce timing problems with XP SP2 on multiprocessor machines. Added a text warning about timing irregularities when the task manager is active. (Not observed on all machines.)
• Removed global sampling buffer in the spline solver. Replaced with a stack copy for thread safety.
• Fixed a multithreading bug with the granny_data_type_definition functions. The TraversalID member would be stomped if two threads tested the same static data type simultaneously.
• Added GrannyCameraOutputZNegativeOneToZero to support the Wii's idea of a projection transform.
• Very basic Wii example added. More complete example to follow.
• Distribute PDBs to help debug distributed libraries.
• (internal) Ensure section alignment to DWORDs on write. Note that this is an external alignment only, the internal alignment may still be whatever the user wants.
• (internal) GrannyGetWriterPosition shouldn't assert in the call to SeekWriter when the writer is CRC'ing.
• (internal) Changed the assertion mechanism
• (internal) Nodes with a Maya API type of kPluginTransformNode were being incorrectly ignored. They are now treated the same as any kTransform node. (Similar treatment given to kLodGroup nodes.)
• (internal) Removed rarely used precomputed animation deltas to reduce the size of the animation binding cache structures.
• (internal) Added SetPtrNULL convenience function to simplify setting up arrays of pointers.
• (internal) Adjusted the way Granny deals with structure packing settings. This was causing hiccups in various 64-bit applications that needed to match the Windows packing conventions.

• Added help to the plugin scripting commands. Documentation for Granny's commands is available by following any of the script commands with "-h" or "-help" in Maya, or "GrannyHelp [commandName]" in Max. A list of the available MEL/MaxScript commands can be found in Granny Exporting Overview: Using Scripts to Automate Exporting.
• Added script call GrannyGetValue that allows scripts to examine settings created either with the exporter interface, or with GrannySetValue.
• Help for GrannySetValue analogous to that available for GrannyCast added to the external website for easy reference from the plugin. (Also available as SetValueDocs in the Granny documentation.)
• Fixed an error in the Max exporter that could cause skinning modifiers to be missed if another modifier modified the mesh topology "above" the skinning modifier.
• Added support for the new Maya multiple color sets per mesh.
• Set the x87 control word to a known state before invoking the exporter in Max and Maya. If another plugin or user process has set the flag to a non-standard value, infinite loops can result when calling Maya functions.
• Fixed an incorrect error message in DAG free routines that could cause a memory leak when using auto-free node types.
• Restored standard options for model bones in the exporter.
• (internal) Fixed a distribution error in the Xenon target. (xenon_granny_* files were being left out of the sdksrc distribution.)

• Granny now supports Intel-based Macs. Currently, we use the Intel C++ Compiler for Mac OS to compile the target in order to make the best use of the optimizations we've made to the Win32 x86 target.
• Xenon, PS3, and DirectX9 samples updated to include HLSL shaders for skinning rather than a Granny deformer. If you are using a granny_mesh_deformer for skinning, it is strongly suggested that you evaluate these samples, using the hardware to do skinning math is better in almost every case.
• Curve API Changes. Many parts of the Granny curve compression API have been altered to support new compression types and to expose some useful functionality from the exporter in the general API. See the notes below for specfics. The documentation on curve fitting: Granny Utility Function Overview: Curve Creation, has been substantially updated to reflect these changes.
• VMX128 optimized paths added for GrannyBuildWorldPose in the Xenon target. Our tests show that the new routines only take about 40% of the time of the scalar routines.
• Altivec optimized paths added for GrannyBuildWorldPose in the PS3 target. Like the Xbox 360, the vectorized paths test out at around 40% of the time of the scalar paths.
• Added a new type of Synthetic Root Bone, "GrannyRootBoneLocal", which captures only those bones that are part of the same hierarchy. If you aren't familiar with SRB's, you should be! Check out Understanding Model World-space Movement: Move to Origin and the Synthetic Root Bone for more information.
• GrannyCompressCurve is moved from the exporter to the public interface. This allows people doing custom compression work to use the same interface that the exporter uses to get maximum benefit from the curve fitter. If you've previously been using GrannyFitBSplineToSamples to compress curves, you should certainly look at switching to this interface.
• New exporter option added "Quantized on missed tolerance." In certain extreme cases, the Granny spline fitter cannot maintain numerical stability and hit the tolerance goal set in the exporter. Previously, Granny would always use the largest, most precise curve format to represent these curves, even if there was a quantized format that could represent them almost as well at a substantial savings in space. Now, if this option is on, Granny will allow quantization in these cases, if the space savings is significant enough.
• New exporter option added "Aggressive animation compression". Allows Granny to run a post-processing step that eliminates knots that were made redundant during the fitting process. This option is disabled by default to preserve the meaning of existing animation settings. If you're using the curve fitting API, you can access this functionality by passing the new solver flag GrannyBSplineSolverAllowReduceKeys.
• GrannyFitBSplineToSamples now returns a result curve, rather than knot/control arrays. This allows much more flexibility in curve formats, in particular, it allows us to properly support dimension reduced orientation formats, which could not be cleanly implemented with the old interface.
• GrannyFitBSplineToSamples size tracking metrics have been changed from CurveDataSize to CurveSize. This allows Granny to take size of the curve header into account when deciding which format compresses your data best, which can be significant for short animations.
• GrannyPushVectorTrack, GrannySetTransformTrackPosition, GrannySetTransformTrackOrientation, and GrannySetTransformTrackScaleShear are removed. You should replace these with GrannyPushVectorTrackCurve, GrannySetTransformTrackPositionCurve, GrannySetTransformTrackOrientationCurve, and GrannySetTransformTrackScaleShearCurve. The older APIs couldn't properly support dimension reduced curves.
• Fixed a bug in GrannyModulationCompositeLocalPoseSparse that would prevent using GrannyIdentityTrackMask and GrannyNullTrackMask as parameters.
• Put a workaround in place for a compiler bug for the Xenon target relating to the proper sign extension of registers loaded from 16-bit signed datatypes. This was causing incorrect decompression of some Bink textures.
• Update the documentation to reflect the changed location of the Light and Camera Info. Affected doc sections: Granny Data Loading Overview: Parsing Extended Data and Granny Files, Raw Files, Compression, Sections, and All That Stuff: Using the ExtendedData field
• Const parameters introduced for GrannyModulationCompositeLocalPose, GrannyModulationCompositeLocalPoseSparse, and GrannyCopyLocalPose to more clearly indicate which are input and output parameters.
• Fixed an inconsistency in the exporter relating to exporting bones by name only. This caused the InitialPlacement field of granny_models to be incorrectly set to identity on export, and could crash the viewer when attempting to render the animation pane. Bone settings in the exporter have been reduced to the subset that makes sense. For example the "Move to Origin" settings that previously could be set bone-by-bone were completely ignored by the exporter.
• To help support extraction of Physics SDK parameters from gr2 files, spheres, boxes, and capsules are auto-detected in 3dsMax, and tagged with their analytic parameters.
• New utility computation function GrannyLocalPoseFromWorldPose, to help move results from external world-space APIs back into local space for further blending. Note that this function is fairly slow, since it has to decompose the 4x4 matrices into granny_transforms. If you have a restricted situation in which you know that there is no scale or shear in the world pose matrices (including the Offset4x4), then you should use GrannyLocalPoseFromWorldPoseNoScale instead, since the trip through GrannyPolarDecompose is unnecessary in that case.
• Fixed a bug exposed by the latest MacOSX compiler relating to the behavior of undefined pointer arithmetic.
• Added convenience function GrannyCurveGetSize.
• GrannyCurveIsReducible added, which is more practical than GrannyKnotsAreReducible in most cases.
• (documentation) Fixed a bug in the document generator that caused Granny constants to be referred to as objects, rather than pointers to the constants, which is how they are implemented.
• (internal) Added IntrinsicSinCos to take advantage of accelerated trig functions on platforms that have a fast fsincos instruction.
• (internal) NormalizeOrZero[34] functions return 0.0f when they are unable to normalize the input vector, rather than a random epsilon.
• (internal) Fixed alignment macro for non-MSVC platforms.

• This is the first "official" release in the 2.7 series. Note that if you are upgrading from 2.6 or 2.5, there will be some source changes required to compile with the new libraries. The required changes are minor, but you may want to wait if you have deadlines approaching.
• Dimension reduction for translation curves added. Where appropriate, Granny will reduce the translation curves to functions of one variable. New curve types granny_curve_data_d3i1_k32f_c32f, granny_curve_data_d3i1_k16u_c16u, and granny_curve_data_d3i1_k8u_c8u added to support this feature.
• Added Table of Contents: Support Policy and Feature Requests section to the help TOC page.
• Added Granny in a multithreaded environment and Targeting Granny Files to a Specific Platform to the docs.
• Added GrannySetAllowGlobalStateChanges, GrannyGetAllowGlobalStateChanges, GrannySetThreadIDCallback for thread safety checks.
• Added GrannySampleBlendDagTreeReentrant, GrannySampleBlendDagTreeLODReentrant, GrannySampleBlendDagTreeLODSparseReentrant, GrannyCreateDagPoseCache, GrannyFreeDagPoseCache, to provide a thread safe sampling api for the Blend DAG. New type: granny_dag_pose_cache.
• Added GrannyGetInMemoryFileCRC as a debugging aid. Checksums the section memory to help catch memory scribblers.
• Fixed a bug in the x64 version of GrannyRebasePointersStringCallback that would have prevented raw files from working with an external string table.
• Fixed a calculation error in GrannyKnotsAreReducible that was forcing orientation tracks to be represented as full curves when a constant value would have done just fine. This was exacerbated by a small amount of noise in the reported transforms from the modeling packages.
• granny_rebase_pointers_string_callback now takes a granny_uint32 as the second parameter to match the return value of granny_file_writer_string_callback.
• Fixed a bug in the viewer that could cause a crash if a model was exported from Max or Maya as "Name Only."
• GrannyComputeBasisConversion returns false if it can't compute a conversion due to missing granny_art_tool_info.
• Size computation corrected in data type io.
• GrannyGetMagicValueForPlatform in the public API now.
• Added GrannyAcquireMemorySpinlock and GrannyReleaseMemorySpinlock for threaded memory access. See Granny in a multithreaded environment: The Allocator Lock for the very limited circumstances in which you need to use these functions.
• PS3 target fixes: endian consistency, and compile settings changed to fix problems exposed in the wild. This change was back propagated to 2.6.0.16.
• Improved Granny's handling of the DirectX material in Max. Texture parameters were not being correctly encoded in the ExtendedData block for the material.
• Granny for Win32 is now built with Visual Studio .NET 2003 by default, rather than VC6. Granny source will still compile with VC6.
• Documentation fixes: cleaned up some bad references, added some sorting to the "Related" links for functions, types, etc. to make infrequently used APIs easier to find.
• Exporter will allow you to turn off the quantized curve types. This is not really recommended unless you really know what you're doing.
• GrannyKnotsAreReducible and GrannyGetVectorDifferences have changed signatures to more clearly express that EvaluateAsQuaternions and EvaluateAsVectors are mutually exclusive. granny_vector_diff_mode added to chose between the different difference metrics.
• (internal) Fixed function signature error in ConvertToStringList. (Affected PSP build)
• (internal) API generation tool accepts markup for indicating thread safety, and adds checks to the thunking layer for user debugging.
• (internal) AggrAllocate made thread-safe.
• (internal) Removed tiBufferGlobal and piBufferGlobal, which makes large swaths of the sampling API fully reentrant. Props to RichG@Ensemble for calling attention to this.
• (internal) Changed some manual calls to the Comparison callback to internal AreEqualOrCallback utilities. Fixed a namespacing bug that prevented these functions from being visible to the rest of Granny.
• (internal) Mac build ported to current shipping version of gcc. (Xcode 2.2, gcc 4.0.1 as of this writing.) Required a modification to a few internal macros, and some new warning cleanups.

• Note that this is a limited distribution beta for 2.7. We do not recommend that you upgrade to this release unless the x64 target is important to you. Non-trivial code modification may be required when upgrading from 2.6 or 2.5 to 2.7 depending on which parts of the API you are using. The primary thrust of the rather large group of changes in this release is to make Granny 64-bit clean, and to add the x64 build target. As a bonus consequence of these changes, it is now possible to output appropriately converted Granny files for any platform from any platform. I.e, you can write big-endian Granny files from x86, which don't require endian marshalling on load for platforms like Xbox360, PS3, or MacOSX.
• GrannyBeginFile, GrannyBeginFileInMemory, and GrannyWriteDataTreeToFile all take a PlatformMagicValue parameter that indicates the target platform to write to.
• Exporter file menu now has an option to write the file natively for any platform.
• Added GrannyCompressContentsOfMemory to the file compression API.
• Added documentation on granny_skeleton_lod_type, which was missing from Animation Level Of Detail: LOD Concepts: Skeletal.
• Added new System Dependent Types documentation section to hold info about the exported basic types.
• Updated the Undocumented Portions of the SDK documentation with functions and types that were been added since its last update.
• GrannyIsGrannyFile takes a new argument to indicate if the pointer size for a file is different than the current platform.
• granny_grn_file_magic_values updated. GrannyGRNFileMV is now called GrannyGRNFileMV_Old, GrannyReversedGRNFileMV is removed. The old magic values are no longer written to new data files, but are supported in the reader for backwards compatability. New magic values, GrannyGRNFileMV_32Bit_LittleEndian, GrannyGRNFileMV_32Bit_BigEndian, GrannyGRNFileMV_64Bit_LittleEndian, and GrannyGRNFileMV_64Bit_BigEndian explicitly encode both pointer size and endianess. Previously endianess was inferred as "opposite of this platform", now we can explicitly write one byte ordering or the other from the file IO routines. GrannyGRNFileMV_ThisPlatform added to indicate the native mode of the platform. This granny_grn_file_magic_value will match the appropriate magic numbers.
• Added GrannyBeginFileInMemory to complement GrannyBeginFile. This allows creation of granny_file assets without creating temporary files, at the cost of a greater memory footprint. Likewise, the Granny compression routine GrannyCompressContentsOfFile picks up a version that allows you to use memory file readers, or files that you open yourself, GrannyCompressContentsOfReader.
• granny_file_writer has been substantially overhauled to virtualize it in the style of granny_file_reader. This allows us to do things like add the GrannyCreateMemoryFileWriter. Which we did. In addition, you can now install your own platform-dependent file system writing routines if you would like to replace ours.
• Removed GrannyUnlinkFileReader.
• Added GrannyPlatformConvertReaderToWriter to allow conversions between platforms.
• GrannyReadPartialFileFromReader takes an optional pointer argument to pass back the file's granny_grn_file_magic_value. This is necessary to support platform conversions.
• Added granny_intaddrx and granny_uintaddrx types. These are integer types guaranteed to be large enough to hold a pointer on the target platform. These should never be written to disk.
• Added new granny_uint64x and granny_int64x types in the user type section of granny.h. Note that we do NOT support writing 64-bit values to .gr2 files, so there are no "non-x" versions of these types.
• Some fields have been renamed to conform more closely to Granny norms. For instance, the granny_texture_mip_level field Size was renamed to PixelByteCount, to match a change in the Pixels field to PixelBytes.
• Removed granny_real64 for consitency. This should be replaced with granny_real64x. granny_real64 types should never be persisted, which means that we should have only an "x" type.
• GrannyFixupFileSectionPhase1 and GrannyFixupFileSectionPhase2 now take a pointer to the fixup array for the section. This prevents double reads on byte reversed platforms.
• Oodle0 compression is no longer selectable in the exporter, or usable in the API. Decompression of Oodle0 compressed files is supported for backwards compatability, but you should switch to Oodle1, it's better on all axes. Oodle1 compression is the new default in the exporter.
• Removed undocumented SwitchableTypeMember from the granny_member_type enum. This was never used, and was a source of headaches in the 64-bit version of the library. If you were using this, and need it back, please let us know.
• GrannyModulationCompositeLocalPose and GrannyModulationCompositeLocalPoseSparse would return incorrect results if the weights passed in were greater than GrannyBlendEffectivelyOne.
• (internal) Added extra checks in the string callback replacement routines to make sure it works portably across 32/64 bit platforms.
• (internal) Added compile-time checking of the size of all exported Granny types, except for those that are explictly never intended to be written to disk. Provides error catching if the structure packing ever does something unexpected.
• (internal) GrannyFixupFileSectionPhase2 was unnecessarily refixing up pointers if no marshalling took place. This would issue an unnecessary read to the granny_file_reader passed in.
• (internal) Added ConcatentateFileReader to support in-memory granny_file_builder operation.
• (internal) GrannyPlayControlledAnimation wasn't properly copying the LOD errors from the source tracks.
• Fixed a rebasing bug that could cause bone lengths to be incorrect when retargeting animations.
• Fixed a bug in the viewer that prevented animation LOD from displaying properly
• granny_granny_head_bezier renamed to granny_head_bezier.
• Spring cleaning! Increased the warning level on all targets, and cleaned up large numbers of compiler/platform specific warnings.
• Removed code for old Borland compilers

Changes for 2.6, 2006/4/4 [Final build was 2.6.0.16]

Granny 2.6 saw dramatic improvements in the size of compressed curves, improvements to the Level of Detail system, several new supported platforms, the introduction of the preprocessor, and another changing of the guard.

Compressed curves, introduced early in the 2.6 series have dramatically improved Granny's runtime footprint. In many test cases, we've seen over 50% reduction in curve memory for the same error target, with no changes required by client code or in the exporter. Late in the series, we added curve types that reduce the space required to store curves that have only a uniform scale component or a scale with no shear component, making squash/stretch type animation much more practical.

The other big news is the introduction of the Granny Preprocessor which will help you integrate Granny into your production pipeline, and perform common transformations on your Granny data automatically, quickly, and scriptably. We'll be focusing a lot of development effort on the preprocessor in coming releases. We've all got more content to deal with these days, we need tools to make it easier.

The Animation LOD system received stability tweaks, and tighter integration with the sampling APIs. Towards the end of the release series, a new LOD option, Skeletal LOD was introduced, which can be used to good effect with very little effort in your pipeline. Both systems dovetail nicely, and the preprocessor will begin to help you handle LOD easily in coming releases.

Finally, on the "Granny Everywhere" front, we added support for the Xbox 360, PSP, Playstation 3, Maya 6.5 and 7, and 3DSMax 8.

2.6.0.16 final 2006/4/4

• Fixed a problem with the PS3 target. Type aliasing optimizations in the new GCC compiler can cause incorrect results in Granny.

• Maintenance release to fix a curve size bug and to workaround a problem in Maya.
• Fixed a crash in the OpenFile dialog of the viewer.

• Added support for the Playstation 3
• Added PSP support
• Light and camera info no longer inlined in granny_bone. Art tool specific camera and light info are still contained in ExtendedData if the option is checked for a bone.
• Viewer toggles/displays skeleton/animation lod independantly
• New function GrannyEndLocalPoseAccumulationLOD, smoothly blends to LOD skeleton if LOD enabled, and the granny_skeleton has error estimates.
• New function GrannyAddBoneWithInverse to support reprocessing of skeletons. Prevents numerical errors due to decomposing the InverseWorld4x4 member in granny_bone to pass into GrannyAddBone as a forward transform.
• Reworked the documentation on Animation Level Of Detail, to reflect new skeletal LOD code paths. Updated Granny File Processing Overview: Building Skeletons with LOD as well.
• Added GrannyBuildWorldPoseLOD, which allows you to specify the number of valid granny_local_pose bones. When the world pose must go outside this range, it uses the default transform for the granny_skeleton.
• GrannySampleModelAnimationsAcceleratedLOD will take skeletal LOD into account if it's present.
• GrannyEndSkeletonInPlace now attempts to compute something reasonable for the LOD parameters in the granny_skeleton. This is intended to be a "quick and dirty" estimate, for proper lod, you must take into account the actual animations played on the model, or artist controlled parameters. You do this by using the new GrannySetBoneLODError function on the granny_skeleton_builder.
• Added GrannyGetBoneCountForLOD, which computes the range of bones in the skeleton that are active for a given LOD parameter.
• Added LOD parameters to granny_skeleton and granny_bone. Allows animation-independant LOD selection to complement the animation specific LOD already in place.
• Bugfix for GrannyRayIntersectsBox and GrannyRayIntersectsBoxAt. The bug caused rays which are parallel to one of the axes of the tested box to return incorrect results.
• 64-bit rounding bugfix for the granny clock
• (internal) Added compile time checking of type sizes
• (internal) Small optimizations relating to extracting knots/controls from compresses orientation curves
• PS2 Library target changed to granny2.a, to match the other distributions.
• Fixed a distribution problem in which example code was being left out of the zips with the exception of win32.
• Changed the signature of GrannyGetSquaredErrorOverCurve, GrannyFindMatchingMember, GrannyGetDataTreeFromFile, GrannyWriteFileChunk, GrannyOffsetFileLocation, GrannyGetLogCallback, and GrannyGetSystemSeconds to return results in passed in memory locations, rather than returning a structure by value. This alleviates a problem with type aliasing on certain compilers in the thunking layer, and it's just the Right Thing To Do.

• Created native exporter plugin for 3DSMax 8
• Default degree for scale/shear curves was set to 1. Changed to quadratic for better default compression, and to match the other curve defaults.
• Fixed the GrannyGetSystemSeconds call on Win32 to account for bad behavior in WinXP SP2 on multicore systems.

• Added CompileAssert macro for checking compile time assumptions such as sizeof(void*) == sizeof(uint32).
• Fixed a bug in DaK32fC32f from the 2.6.0.11 refactor
• Fixed a bug exposed by the compressed scale/shear types that could cause the solver to scribble past the end of the knot array.

• Changed the default orientation tolerance to 0.1 degrees instead of 1 degree. This will not change any existing settings, just the ones used when you create a new object. 1 degree is actually a good value for most bones and most objects, but there was a bit of foot-sliding in some rigs which people objected to. Remember - for best results, adjust tolerance on a per-bone basis. You don't need 0.1 degrees of accuracy for finger bones, it's just wasting memory!
• The scale/shear curves for a granny_animation now support three types of data specication. In order of smallest to largest format, these are: Uniform Scale, Scale, and Scale/Shear. Previously, if there was a uniform scale applied to a bone, Granny would export a full 3x3 scale/shear matrix. Now, it looks at the data to see if a scalar or a vector is a sufficient representation. New curvetypes added to support this: granny_curve_data_d9i1_k16u_c16u, granny_curve_data_d9i3_k16u_c16u, granny_curve_data_d9i1_k8u_c8u, granny_curve_data_d9i3_k8u_c8u.
• Removed GrannyBSplineSolverInsertKnotsAtMaxError flag for the spline solver. This method in general requires more knots than the default heuristic to converge to any given tolerance, so it's just a Bad Idea.
• Granny Preprocessor can now export/supress skeletons separately from meshes and models (sometimes you want just the skeleton).
• Added doc sections Granny Exporting Overview: Animation Tolerances and Granny Exporting Overview: Motion Extraction.
• Removed LightWave documentation, as we no longer support Lightwave.
• Updated Animation FAQ: Move to Origin.
• Clarified some areas of Advanced Animation: Remapping and Rebasing Animations.
• Fixed a small formatting bug in the plugin installer stub.
• windows.h and math.h were getting accidentally included in some of the platform builds.

• Fixed a bug in the curve compressor that could cause an infinite loop with pathological data.
• GrannyFindAllowedLODError only worked for small values of CameraFOV. Specifically, as the FOV approached 90 degrees, it would get very wrong results. Fixed.
• Generating uncompressed curves (i.e. raw keyframe data) could cause a crash sometimes. Fixed. This was a rather academic bug, since uncompressed curves are gigantic, and should not be used by anyone.
• GrannySetTrackMatchRule now works even if one of the arguments is NULL. It previously only worked if both were NULL or both were non-NULL.
• Fixed minor bug in wildcard matching.
• Misc. buglets in Viewer graphics fixed.
• GrannyCalculateLODErrorValues now copes with "null" animation bindings that contain no tracks. It will also object in the error log for these bindings, as they almost certainly mean a bug in the app.
• Moved and updated material into its own section in Advanced Animation: Remapping and Rebasing Animations.

• Better memory handling for exports with a lot of meshes (>1024). Should fit in heavily-fragmented memory a bit better. There is a limit of 262144 on the total number of granny_file_info::VertexDatas, but this can now be used by either different meshes or morph-targets of the same mesh. It's still annoying to have an arbitrary limit like this, but until we have Win64 versions of everything, fragmentation is a big problem. The 65536 limit on the number of morph targets per mesh remains.
• If a granny_text_track_entry is outside the selected time range, it is not exported, just like all the other animation data.

• Fixed AnimationAccumulateLoopTransform (which is used by GrannyGetRootMotionVectors and GrannyUpdateModelMatrix) so that CME now works with animations that are clamped at one or both ends.
• Certain types of structures inside certain other structures (GrannyInlineMember embedded in a mixed-marshalling structure) caused file system marshalling (endian-swapping) to fail. Now fixed.
• GrannyFixupFileSection had to be split into two halves - GrannyFixupFileSectionPhase1 and GrannyFixupFileSectionPhase2. See the docs on them for more details.
• Tweaked the behaviour of Reverse16 - can now do odd-numbered and unaligned reverses.
• Xbox360 sample app copes with rigid meshes.
• Xbox360 library and sample app updated to the latest XDK (1881).

• Maya 7.0 exporter.
• New - The Granny Preprocessor.
• Slightly improved speed of PS2 version - "DEBUG" was defined by mistake!
• ConvertTo32BitNormalized alpha-channel fixed for out-of-range weight values.
• Rationalised use of "#if DEBUG" versus "#ifdef DEBUG" throughout the codebase (the first is more robust in most cases).
• Bumped the standard PC build to warning level 4 (was level 3), and fixed/disabled the warnings that popped up.
• Added GrannyRecenterAllModelInstanceControlClocks and GrannyRecenterControlClocks to allow finer control of clock recentering.
• Changed GrannyConvertVertexLayouts so it knows how to convert some of the more common compressed vertex format variants (such as storing normals as biased unsigned bytes) back to vanilla real32s. In practical terms, this means the Granny Viewer can correctly show more types of mesh.
• Ported all the D3D sample apps to DX9.0c (August 2005 update). This was basically just because the framework's "d3dfile.h" and "d3dfile.cpp" didn't work with the new headers - but those files were never needed anyway. There's no changes to any of the interesting code.

• Changes to granny_curve2 functions to improve debugging speed. No effect on the release build.

• set_log_file_example.ms fixed to be GrannyStopLogging() rather than GrannyStopLogging (you need the braces, or it doesn't actually get called!).

• The Granny Viewer now displays the names of inlined structures in the detailed view. For example, when viewing any of the granny_curve_data_ structures, they all contain an inlined granny_curve_data_header. Previously, it just printed out the Format and Degree parts as if they were part of the granny_curve_data_ structure itself, which while sort-of-true (they are part of the chunk of data), was confusing. Now, it prefixes them with the declared name of the structure itself. This is in fact doubly helpful for curves, because the name of the curve type is embedded in the nameing of the header (e.g. "CurveDataHeader_DaK32fC32f"), so you now know what sort of curve it is very easily.
• Prevented the exporter from ever using the "Identity" curve type for granny_vector_track curves, because Granny doesn't actually know what type of data these hold (only the application does), and so has no way of knowing what "identity" means.
• GrannyGetVectorDifferences can pass in NULL for the Identity argument, meaning that it doesn't care about comparisons to itentity.
• Added some epsilons to CheckLocalClockAndLoopIndex (internal function) to prevent annoying benign asserts when granny_control clocks get large.
• Animation LOD speedup by caching the LODed transform inside the granny_bound_transform_track itself, rather than going out to the granny_transform_track and sampling each of the component curves. This avoids a lot of cache misses, and a lot of extra function calls.
• Also sped up non-LOD sampling slightly because at anim-bind time, constant-value tracks have their LODError set to 0.0f (rather than the usual +inf), so even if you pass in an AllowedError of 0.0f (i.e. disable LOD), the two errors are equal, so it still does the cheap "LOD" lookup. Again, saves cache misses and extra calls.
• Added some internal utility string-handling functions.
• Removed the scary-looking warning in Animation Level Of Detail. It's had a decent amount of testing now, and the code is good for general public use. Also various tweaks to the animation LOD section.

• Initialised the ease in/out curve data for each control. This helps people track down bugs where they enable ease in/out curves without having actualy set the shape up properly.
• Added GrannySparseBoneArrayCreateSingleBone, GrannySparseBoneArrayAddBone and GrannySparseBoneArrayExpand. For more information, see Advanced Animation: Sparse Bone Arrays.
• Added functions GrannyBuildWorldPoseNoCompositeSparse, GrannySampleBlendDagTreeLODSparse, GrannyModulationCompositeLocalPoseSparse, GrannyAccumulateModelAnimationsLODSparse, GrannySampleModelAnimationsLODSparse and GrannySampleSingleModelAnimationLODSparse. These are the same as the previous similarly-named calls, except they can take a sparse bone array. For more information, see Advanced Animation: Sparse Bone Arrays.
• Changed functions GrannyBeginLocalPoseAccumulation, GrannyEndLocalPoseAccumulation, GrannyGetWorldMatrixFromLocalPose, GrannyGetAttachmentOffset and granny_blend_dag_leaf_callback_sample_callback to take a SparseBoneArray and/or a SparseBoneArrayReverse. Just pass in NULL if not using sparse bone arrays. For more information, see Advanced Animation: Sparse Bone Arrays.
• Renamed internal functions Build*WorldPoseResult* to Build*WorldPoseComposite* to make stuff a bit clearer.
• For each Build*WorldPoseComposite_Generic function, broke it into the corresponding new Build*WorldPoseOnly_Generic version and the new BuildSingleCompositeFromWorldPose_Generic. The SSE versions are unchanged.
• Added GrannyBuildWorldPoseNoComposite and GrannyBuildCompositeFromWorldPose. Handy for doing post-animation processing on your world poses (e.g. ragdoll, complex IK, etc). Note that there are currently no SSE versions of these, so there may not be much of a speed gain on PC or Xbox. If you are seeing these functions on your profiles, email us at RAD and we'll add them.
• Added docs on the above at Notes on CPU and Memory Performance Optimization: Animation speed issues
• Documented GrannyUpdateBlendDagTreeMatrix.
• Added two extra callbacks to Callback DAG nodes. These are used when GrannySetBlendDagTreeClock and GrannyGetBlendDagTreeMotionVectors are called. Either or both may be set to NULL if you don't need those callbacks. See The Animation Blending Directed Acyclic Graph [Deprecated]: The Callback Type for more details.
• GrannyGetBlendDagNodeCallbackCallback renamed to GrannyGetBlendDagNodeCallbackSampleCallback, as slightly more descriptive now that there is more than one callback.
• GrannyGetBlendDagNodeCallbackSetClockCallback and GrannyGetBlendDagNodeCallbackMotionVectorsCallback added.
• Added the AllowedError argument to the SampleCallback, which reflects the LOD value passed to GrannySampleBlendDagTreeLOD. If GrannySampleBlendDagTree was called, this will be 0.0f.
• Added TangentMergingMinCosine argument to GrannyBuildTangentSpace. This says how far apart the tangent or binormal of two coincident vertices need to be before they are NOT averaged together. This is typically around 0.25f (75 degrees), especially for tangent-spaces that are automatically generated. But for