Hi danothom:

Seems like you have a versioning problem, so let's break it
down a bit.

First problem, you want to load some old version model files.

In fact, most of the Havok Demos are using quite old version
data (3.0).Havok provides a way

to do this conversion.

1. Let havok patch the file for you while loading it.

Havok will do it automatically after you included
hkProductFeatures.cxx in your code. BUT,

because you want the system to do it, you SHOULD NOT have
those two defines

HK_EXCLUDE_FEATURE_SerializeDeprecatedPre700

HK_EXCLUDE_FEATURE_RegisterVersionPatches

in your code.

Because, obviously, those two defines will tell havok to not
patch the file for you (it strips all versioning-related code, which you'll
need).

2. Use Packfile Convert tool AssetCc2

This tool can update asset versions and can only save the
latest sdk version.If you use this tool to convert the asset and then load it,
it is not necessary for Havok topatch the data anymore. As the reason, you can enable those
two defines to exclude the featureand make your code size a bit small.

Here is the documentation you can refer to.

Common Havok Components / Serialization / File Formats

For now I'd suggest using option #1 from above since you
won't have to worry about using the AssetCc2 tool and can rule out the
possibility of your tool version being different from your runtime version.

For your second problem, you want to serialize HAVOK_PHYSICS
and HAVOK_ANIMATION objects in a binary file format.

To do that, you should make sure all the necessary classes
are registered and all the features youneed are included. This should get taken care of
automatically as a result of including keycode.cxx before hkProductFeatures.cxx
(you'll note that keycode.cxx should define HK_FEATURE_PRODUCT_ANIMATION and
HK_FEATURE_PRODUCT_PHYSICS to enable those products, and hkProductFeatures.cxx
should by default include hkKeyCodeClasses.h to define
HK_FEATURE_REFLECTION_PHYSICS/HK_FEATURE_REFLECTION_ANIMATION and setup which
classes can be serialized/loaded).

Hope this helps. And if you have any question, please attach
some of your code and let me know.

Thanks

Joe

Developer Support Engineer

Havok

www.havok.com

Hi danothom:

Very glad to see you've figured out how to convert the resources. Here are some advices for your new questions.

1.) Please refer to

http://software.intel.com/en-us/articles/how-to-attach-file-insert-code-into-forum-post/
It will tell you how to do it.

2.) Serialization problem. Here is a good documentation for you to understand the relationship between hkSerializeUtil and hkLoader Common Havok Components / Serialization / Basic Loading and Saving

Generally speaking, hkLoader is a thin wrapper on top of hkSerializeUtil. It is quite simple and easy to use but italways uses the "flattened loading style". Which mean all the resources you loaded, no matter you are going to useit or not, will keep in the memory until the game finished (hkLoader destroyed.) On the other side, if you directly use hkSerializeUtil, you can use the "object style". So you can load theresource temporally, grab and keep the necessary objects which you need in the memory, and then release the wholeresource. hkLoader is always used in Demos because we do not need to care too much about the memory usage.

3.) I guess you want to directly use graphic mesh data from Havok file and skin it by yourself. Actually most of users export .x or some other format to save the graphics mesh data, and skin it by themselves.Havok does not provide a commercial skinning solution. For demo purposes, the simple, internal graphics frameworkwhich uses DirectX is good enough.
To use Havok animation, you can only export skeleton and animation data through .hkx file, and then use them todrive your model.

Demo/Demos/Animation/Api/Blending/Normal/NormalBlendingDemo

shows you how to load and blend the animations. In NormalBlendingDemo.cpp, you can see we load rig data, some aniamtion data, and finally load "hkLowResSkin.hkx"which is havok skin mesh data. And then, we call

env->m_sceneConverter->convert( scene );

to convert the mesh data into graphics output buffers. If you want, you can dig into this function to figure outhow the vertex buffer created.

Also, the function

AnimationUtils::skinMesh(...);

is the main function how Havok skin the mesh. Hope the reply can give you a brief idea about how to use Havok animations. Let me know if you have any questions.

By the way, you probably can have a look this ticket as well

http://software.intel.com/en-us/forums/showthread.php?t=104148

Hi Dan:

1.) I think you've already read the Doc Common Havok Componets \ Serialization \ File Formats

Generally speaking, Tagfile is platform independent, smaller and slower to use. And packfile is platform dependent,bigger and much faster. We suggest user use tagfiles for development and use packfiles for release the game.Tagfiles are more malleable and much easier for programmer to analyze the problem.

Yes, we are using .hkx in Demo, since it is quite release ^_^

2.) I wonder which Version of Havok SDK you are using and how do you download it ? By default, the free Havok SDKyou can download from http://www.havok.com/try-havok

should include our lever_1 source file for common, phylsics, animation and demo related code. You can find hkgSceneDataConverter.cpp in the folder: Demo\Graphics\Bridge\SceneData

and the mesh converter related file is in hkgSceneDataMeshConverter.cpp

3.) hkSceneData is a project. It contains the data descriptions that are extracted from the toolchain. It has thesupport for Havok internal rendering module. (such as renderer for Demos, Visual Debugger...) It is a differentconcept. I think you want to understand the structure of "The Havok Scene Data". I suggest you can refer to Havok Content Tools \ Integrating with the Havok Content Tools \ The Havok Scene Data Format

And meanwhile, try to use "View XML" filter in content tools to have a look the data(try not use "Prune Types"filter at first.)

In fact, both hkxScene and hkaAnimationContainer CAN export hkxMesh data and they are actually point to the sameone.And if your exported the mesh data into the animation container(which mean you did not use "Prune Types" todelete the Mesh Binding data), you definitely can find those data under AnimationContainer->MeshBindings->Mesh->MeshSections Again, I still want to mentioned that havok mesh data(hkxMesh, hkxMaterial...) is mostly used for havok internalgraphic lib. If you want to use havok graphic (mesh,material) data to pass into your own render pipeline, you need to convert them by yourself. Surely, you have all necessary raw data after loading, and if you can step into the ConvertMesh function, it should be a very good reference.

Thank you havok_Joe, that's more useful then any of the answers previously given on the forums...

So I understand it's all a confidentiality thing, you can't tell us how to get the vertex format of the buffer... and you can't tell us how to get any of the vertex/indices/material infos from the hkaAnimationContainer. You just pointed us at a cpp file that is wrapped in the lib and we can't reach the code.

Yes, we want to convert the data by ourselves, but where do we find it and why should it be a quest to find it? I thought Havok Animation liscence approved of us implementing it within our game engines... so my guess would be it should have the slightest information(in either demo or docs) about where the data required for a graphics pipeline is to be found so we can collect it and arrange it convert it to conform to the graphics device.

Otherwise, forgive me I love you guys a lot and these are great quality products. The only thing being dissapointing is how we find numerous people asking for the same thing yet nothing is done about it when it's not breaking the confidentiality of information policy you have.

Hi aresthegod:
I do apologize. I downloaded the SDK from the website and there IS NO source code which I menetioned in the last reply. I should make sure by myself at first. Sorry again.

Havok do not have documentation about the detail format of the graphic datas which exported for skinmesh from content tools. BUT, there is the way you can easily figure it out by yourself.

For example, we provided 3dmax file for havok girls in the free SDK located in:
Demo\Demos\Resources\Animation\HavokGirl Please openhkLowResSkin.max in 3DMax, it is the file used to output thehkLowResSkin.hkx which loaded in NormalBlendingDemo.cpp. It has all skined mesh and material data.

Then use havok content tools to export the file. By default, you can see there is "Write to Platform" filter after "Prune Types" filter. Remove all"Write to Platform" filter, instead, add "View XML" filter into the list. And the list will look like:

Convert To Png Transform Scene Create Skeletons Create Skins Preview Tool Prune Types View XML

Then Run Configuration, the preview tool will be opened with a skined havok girl rendered , as well as a View XML window.And then, go to

hkRootLevelContainer -> Animation Container -> hkaAnimationContainer

It is quite simple because there is no animation data inside. The section
0x5e63c520 0x48415e60 0x48416580 0x5e63ce20

told you there are 4 skin mesh in the container. (hkaAnimationContainer.m_skins)Let's open one of them , for example "LowBody", and expand them all. The structure should be pretty clear now. There are hkxVertexBuffer (with hkxVertexDescription as the description of the vertex buffer you might need to look deeply inside), hkxIndexBuffer,hkxMaterial("yellow")...

And also you can find the detail info about those classes in the documentations.

OK, let's back to the code.In NormalBlendingDemo.cpp

{

	const char* skinFile = "Resources/Animation/HavokGirl/hkLowResSkin.hkx";

	hkStringBuf assetFile(skinFile); hkAssetManagementUtil::getFilePath(assetFile);

	hkRootLevelContainer* container = m_loader->load( assetFile.cString() );

	HK_ASSERT2(0x27343437, container != HK_NULL , "Could not load asset");
	hkxScene* scene = reinterpret_cast( container->findObjectByType( hkxSceneClass.getName() ));

	HK_ASSERT2(0x27343435, scene , "No scene loaded");
	hkaAnimationContainer* ac = reinterpret_cast( container->findObjectByType( hkaAnimationContainerClass.getName() ));

	HK_ASSERT2(0x27343435, ac && (ac->m_skins.getSize() > 0), "No skins loaded");
	m_skinBindings = ac->m_skins;
	// Make graphics output buffers for the skins

	env->m_sceneConverter->convert( scene );
}

"ac" will have all the data you saw in thehkaAnimationContainer section inXML above, and also, m_skinBindings contained all those 4 skin meshes.

By the way, with "Write to Platform" filter, you also can output a XML format file can be opened in any text editor. Also, you can try to do the same thing forhkIdle.max ... to see the structure with no skined mesh, but animation datas.

I hope it can help you figure out the info what you want and try to use it for your own rendering pipeline.

Cheers.

Again, thank you for the rich answers.

Yet, we are looking for something like:
how to access the verices:
ac->potato[0] and explanation... you have to itarate through potato collect all the vertices from potato[i]->verticesVector[j] or... get the pointer to the vector pool with potato[i]->vertexpoolpointer()

This kind of information should be in the docs but is not... thanks

Hi Dan:
For the question about how to load tagfiles / packfiles ,hkSerializeUtil will handle it for you. No matter what kind of file you passed in,hkSerializeUtil will figure it out by analyzing the header of the file and load it for you.

For deciding which file you should use. I still suggest you can use tagfile at first because it causes less problems. It's platform independent, so you can load the same tagfile on both 32bit PC , 64bit PC , or XBox... It's not versioned, which mean the SDK will always patch it to the newest version on run time. For example, you export both tagfile and packfile for the same asset in SDK 2011 and compare them. You will find tagfile will be smaller than packfile. But tagfile will take more loading time in the game than packfile do (because system need to patch the tagfile but packfile need not). Later, you decided to upgrade to SDK 2012 and try to load those two files you made before in SDK 2011. You will find you still can load them. The tagfile will take almost the same time to load as it loaded in the old SDK, but the packfile will take much longer loading time than before. (because the system will also patch the packfile into the new version in run time) Unless you useAssetCC2 to manually patch the packfile offline. Hope it is clear enough. Cheers