domCOLLADA* ColladaShapeLoader::readColladaFile(const String& path)
{
// Check if this file is already loaded into the database
domCOLLADA* root = sDAE.getRoot(path.c_str());
if (root)
return root;
// Load the Collada file into memory
FileObject fo;
if (!fo.readMemory(path))
{
daeErrorHandler::get()->handleError(avar("Could not read %s into memory", path.c_str()));
return NULL;
}
root = sDAE.openFromMemory(path.c_str(), (const char*)fo.buffer());
if (!root || !root->getLibrary_visual_scenes_array().getCount()) {
daeErrorHandler::get()->handleError(avar("Could not parse %s", path.c_str()));
return NULL;
}
// Fixup issues in the model
ColladaUtils::applyConditioners(root);
// Recursively load external DAE references
TSShapeLoader::updateProgress(TSShapeLoader::Load_ExternalRefs, "Loading external references...");
for (S32 iRef = 0; iRef < root->getDocument()->getReferencedDocuments().getCount(); iRef++) {
String refPath = (daeString)root->getDocument()->getReferencedDocuments()[iRef];
if (refPath.endsWith(".dae") && !readColladaFile(refPath))
daeErrorHandler::get()->handleError(avar("Failed to load external reference: %s", refPath.c_str()));
}
return root;
}
//-----------------------------------------------------------------------------
/// Get the root collada DOM element for the given DAE file
domCOLLADA* ColladaShapeLoader::getDomCOLLADA(const Torque::Path& path)
{
daeErrorHandler::setErrorHandler(&sErrorHandler);
TSShapeLoader::updateProgress(TSShapeLoader::Load_ReadFile, path.getFullFileName().c_str());
// Check if we can use the last loaded file
FileTime daeModifyTime;
if (Platform::getFileTimes(path.getFullPath(), NULL, &daeModifyTime))
{
if ((path == sLastPath) && (Platform::compareFileTimes(sLastModTime, daeModifyTime) >= 0))
return sDAE.getRoot(path.getFullPath().c_str());
}
sDAE.clear();
sDAE.setBaseURI("");
TSShapeLoader::updateProgress(TSShapeLoader::Load_ParseFile, "Parsing XML...");
domCOLLADA* root = readColladaFile(path.getFullPath());
if (!root)
{
TSShapeLoader::updateProgress(TSShapeLoader::Load_Complete, "Import failed");
sDAE.clear();
return NULL;
}
sLastPath = path;
sLastModTime = daeModifyTime;
return root;
}
daeElementRef
domCOLLADA::create(DAE& dae)
{
domCOLLADARef ref = new domCOLLADA(dae);
ref->_meta = dae.getMeta(domCOLLADA::ID());
ref->setAttribute("version", COLLADA_VERSION );
ref->setAttribute("xmlns", COLLADA_NAMESPACE );
ref->_meta = NULL;
return ref;
}
using namespace std;
using namespace cdom;
// Demonstrates how to use the DOM to create a simple, textured Collada model
// and save it to disk.
testResult addAsset(daeElement* root);
testResult addGeometry(daeElement* root);
testResult addImage(daeElement* root);
testResult addEffect(daeElement* root);
testResult addMaterial(daeElement* root);
testResult addVisualScene(daeElement* root);
DefineTest(export) {
DAE dae;
string file = getTmpFile("export.dae");
domCOLLADA* root = dae.add(file);
CheckResult(root);
CheckTestResult(addAsset(root));
CheckTestResult(addGeometry(root));
CheckTestResult(addImage(root));
CheckTestResult(addEffect(root));
CheckTestResult(addMaterial(root));
CheckTestResult(addVisualScene(root));
dae.writeAll();
// As a very simple check for possible errors, make sure the document loads
// back in successfully.
int main(int argc, char **argv )
{
// describe command-line options
std::string scene_file; // input collada scene filename
std::string hdf5_file; // input hdf5 filename
std::string hdf5_group;
std::string file_out; // output collada animation filename
po::options_description desc("Allowed options");
desc.add_options()
("help", "produce help message")
("hdf5-file", po::value<std::string>(&hdf5_file),
"HDF5 input data file")
("hdf5-group", po::value<std::string>(&hdf5_group)->default_value("/"),
"subgroup within the HDF5 file")
("scene-file", po::value<std::string>(&scene_file),
"collada input scene file")
("output-file,o",
po::value<std::string>(&file_out)->default_value("out.dae"),
"output file")
;
po::positional_options_description p;
p.add("hdf5-file", 1);
p.add("scene-file", 1);
p.add("output-file", 1);
po::variables_map vm;
po::store(po::command_line_parser(argc, argv).
options(desc).positional(p).run(), vm);
po::notify(vm);
if (vm.count("help")) {
std::cout << desc << "\n";
return 1;
}
std::vector<std::string> elements;
DAE *dae = new DAE;
//daeElement *root = (daeElement*)dae->open(scene_file);
domCOLLADA *root = (domCOLLADA*)dae->open(scene_file);
H5RandomReader myReader(hdf5_file, hdf5_group);
FrameData fd = myReader.getFrame(0);
std::map <std::string, Matrix >::iterator it;
for (it = fd.matrices.begin(); it != fd.matrices.end(); ++it){
elements.push_back(std::string(it->first));
}
//printf("Found %i elements... \n", elements.size() );
domLibrary_animations *lib_anim;
if (elements.size()!=0) {
lib_anim = (domLibrary_animations*)root->add("library_animations");
}
//printf("Found %i steps...\n", (int)myReader.getNbSteps());
for (int j=0; j<elements.size(); j++){
AnimationExporter *matrix = new AnimationExporter(lib_anim, 16, elements[j].c_str(), "matrix");
for (int i=0; i<myReader.getNbSteps(); i++){
//printf("Step %i\n", i);
fd = myReader.getFrame(i);
std::map <std::string, Matrix >::iterator it;
for (it = fd.matrices.begin(); it != fd.matrices.end(); ++it){
if (elements[j] == (it->first).c_str()) {
//std::cout << "Key : " << it->first << std::endl;
//td::cout << ax << "\t" << ay << "\t" << az << std::endl;
matrix->add(myReader.getTime(i),
it->second[0 + 0*4], it->second[1 + 0*4], it->second[2 + 0*4], it->second[3 + 0*4],
it->second[0 + 1*4], it->second[1 + 1*4], it->second[2 + 1*4], it->second[3 + 1*4],
it->second[0 + 2*4], it->second[1 + 2*4], it->second[2 + 2*4], it->second[3 + 2*4],
it->second[0 + 3*4], it->second[1 + 3*4], it->second[2 + 3*4], it->second[3 + 3*4]);
}
}
}
}
dae->add(file_out);
dae->setRoot(file_out, (domCOLLADA*)root);
dae->write(file_out);
return 0;
}
void FrameBuffer::write(DAE &dae, const char *fn) {
const Matrix4 m_trans = Matrix4(0.707107, 0.408248, -0.57735, -100.f, -0.707107, 0.408248, -0.57735, -100.f, 0.f, 0.816497, 0.57735, 100.f, 0.f, 0.f, 0.f, 1.f)*rotX_mat(3.14159265358979323846264338327950288419716939937510582097494459230781640628620);
daeElement *root = dae.add(fn);
if (!root) {
if (fprintf(stderr, "Problem preparing to write to temporary file.\n") < 0)
perror("fprintf");
exit(0);
}
time_t now;
char date[256];
if (time(&now) == -1 || strftime(date, 256, "%Y-%m-%dT%H:%M:%SZ", gmtime(&now)) == 0) {
if (fprintf(stderr, "Getting time failed.\n") < 0)
perror("fprintf");
exit(0);
}
daeElement *asset = root->add("asset");
asset->add("contributor");
asset->add("created")->setCharData(date);
asset->add("modified")->setCharData(date);
daeElement *visualScene = root->add("library_visual_scenes visual_scene");
visualScene->setAttribute("id", "myscene");
daeElement *node = visualScene->add("node");
node->setAttribute("id", "mynode");
daeElement *instanceGeom = node->add("instance_geometry");
instanceGeom->setAttribute("url", "#mygeom");
daeElement *matbindings = instanceGeom->add("bind_material technique_common");
root->add("scene instance_visual_scene")->setAttribute("url", "#myscene");
daeElement *libMats = root->add("library_materials");
daeElement *libFx = root->add("library_effects");
for (size_t y = 0; y < dim; y++)
for (size_t x = 0; x < dim; x++) {
ostringstream matid;
matid << "mat" << dim * y + x;
ostringstream maturl;
maturl << "#mat" << dim * y + x;
ostringstream fxid;
fxid << "fx" << dim * y + x;
ostringstream fxurl;
fxurl << "#fx" << dim * y + x;
ostringstream matsymbol;
matsymbol << "MATSYMBOL" << dim * y + x;
ostringstream color;
color << R[dim * y + x] << ' ' << G[dim * y + x] << ' ' << B[dim * y + x] << " 1";
daeElement *mat = libMats->add("material");
mat->setAttribute("id", matid.str().c_str());
mat->add("instance_effect")->setAttribute("url", fxurl.str().c_str());
daeElement *fx = libFx->add("effect");
fx->setAttribute("id", fxid.str().c_str());
daeElement *technique = fx->add("profile_COMMON technique");
technique->setAttribute("sid", "common");
daeElement *phong = technique->add("phong");
phong->add("diffuse color")->setCharData(color.str());
phong->add("specular color")->setCharData("0 0 0 1");
daeElement *matbinding = matbindings->add("instance_material");
matbinding->setAttribute("symbol", matsymbol.str().c_str());
matbinding->setAttribute("target", maturl.str().c_str());
}
daeElement *geom = root->add("library_geometries geometry");
geom->setAttribute("id", "mygeom");
daeElement *mesh = geom->add("mesh");
daeElement *elt;
domFloat_array *fa;
domAccessor *acc;
domListOfFloats floatarray;
elt = mesh->add("source");
elt->setAttribute("id", "mypositions");
fa = daeSafeCast<domFloat_array>(elt->add("float_array"));
fa->setId("mypositions-array");
fa->setCount(12 * dim * dim);
floatarray.clear();
for (size_t y = 0; y < dim; y++)
for (size_t x = 0; x < dim; x++) {
Point3 p1 = m_trans * Point3((double)x /(double)dim, (double)y /(double)dim, depth[dim * y + x]);
Point3 p2 = m_trans * Point3((double)x /(double)dim, (double)(y+1)/(double)dim, depth[dim * y + x]);
Point3 p3 = m_trans * Point3((double)(x+1)/(double)dim, (double)(y+1)/(double)dim, depth[dim * y + x]);
Point3 p4 = m_trans * Point3((double)(x+1)/(double)dim, (double)y /(double)dim, depth[dim * y + x]);
floatarray.append3(p1.x,p1.y,p1.z);
floatarray.append3(p2.x,p2.y,p2.z);
floatarray.append3(p3.x,p3.y,p3.z);
floatarray.append3(p4.x,p4.y,p4.z);
}
fa->getValue() = floatarray;
acc = daeSafeCast<domAccessor>(elt->add("technique_common accessor"));
acc->setSource("#mypositions");
acc->setStride(3);
acc->setCount(4 * dim * dim);
elt = acc->add("param");
elt->setAttribute("name", "X");
elt->setAttribute("type", "float");
elt = acc->add("param");
elt->setAttribute("name", "Y");
elt->setAttribute("type", "float");
elt = acc->add("param");
elt->setAttribute("name", "Z");
elt->setAttribute("type", "float");
elt = mesh->add("source");
elt->setAttribute("id", "mynormals");
fa = daeSafeCast<domFloat_array>(elt->add("float_array"));
fa->setId("mynormals-array");
fa->setCount(3);
floatarray.clear();
Vector3 back = normalize(inverse(transpose(m_trans)) * Vector3(0.f, 0.f, -1.f));
floatarray.append3(back.x, back.y, back.z);
fa->getValue() = floatarray;
acc = daeSafeCast<domAccessor>(elt->add("technique_common accessor"));
acc->setSource("#mynormals");
acc->setStride(3);
acc->setCount(1);
elt = acc->add("param");
elt->setAttribute("name", "X");
elt->setAttribute("type", "float");
elt = acc->add("param");
elt->setAttribute("name", "Y");
elt->setAttribute("type", "float");
elt = acc->add("param");
elt->setAttribute("name", "Z");
elt->setAttribute("type", "float");
elt = mesh->add("vertices");
elt->setAttribute("id", "myvertices");
elt = elt->add("input");
elt->setAttribute("semantic", "POSITION");
elt->setAttribute("source", "#mypositions");
for (size_t y = 0; y < dim; y++)
for (size_t x = 0; x < dim; x++) {
ostringstream matsymbol;
matsymbol << "MATSYMBOL" << dim * y + x;
domInputLocalOffset *input;
domTriangles *triangles = daeSafeCast<domTriangles>(mesh->add("triangles"));
triangles->setCount(2);
triangles->setMaterial(matsymbol.str().c_str());
input = daeSafeCast<domInputLocalOffset>(triangles->add("input"));
input->setSemantic("VERTEX");
input->setOffset(0);
input->setSource("#myvertices");
input = daeSafeCast<domInputLocalOffset>(triangles->add("input"));
input->setSemantic("NORMAL");
input->setOffset(1);
input->setSource("#mynormals");
domP *p = daeSafeCast<domP>(triangles->add("p"));
domListOfUInts inds;
inds.append2(4 * (dim * y + x) , 0);
inds.append2(4 * (dim * y + x) + 1, 0);
inds.append2(4 * (dim * y + x) + 3, 0);
inds.append2(4 * (dim * y + x) + 1, 0);
inds.append2(4 * (dim * y + x) + 2, 0);
inds.append2(4 * (dim * y + x) + 3, 0);
p->getValue() = inds;
}
if (!dae.writeAll()) {
if (fprintf(stderr, "Problem writing to temporary file.\n") < 0)
perror("fprintf");
exit(0);
}
dae.clear();
}
int main(int argc, char* argv[])
{
if (argc < NUM_COMMAND_LINE_PARAMETERS)
{
printf("Usage : HierarchyPreservationChecking.exe file1.dae file2.dae\n");
exit(0);
}
DAE *dae;
dae = new DAE;
daeDocument *pDocuments[NUM_COMMAND_LINE_PARAMETERS - 1];
domCOLLADA *root[NUM_COMMAND_LINE_PARAMETERS - 1];
domCOLLADA::domScene *scene[NUM_COMMAND_LINE_PARAMETERS - 1];
domVisual_scene *visualScene[NUM_COMMAND_LINE_PARAMETERS - 1];
// loading files to DAE containers
for (int i = 0;i < NUM_COMMAND_LINE_PARAMETERS - 1;i++)
{
root[i] = dae->open(argv[i + PARAMETER_OFFSET]);
if (root[i] == NULL)
{
printf("DOM Load error at = %d\n", i);
printf("Filename = %s\n", argv[i]);
// clear memory if needed:
delete dae;
// report error code:
return -1;
}
// visual scene library for each
scene[i] = root[i]->getScene();
// Get visual scene
visualScene[i] = daeSafeCast <domVisual_scene> ( scene[i]->getInstance_visual_scene()->getUrl().getElement() );
// Check visual scene
if (visualScene[i] == NULL)
{
printf("Error: Visual Scene loading error at = %d\n", i);
printf("Filename = %s\n", argv[i]);
// clear memory if needed:
delete dae;
// report error code:
return -1;
}
// check documents
pDocuments[i] = dae->getDoc(argv[i + PARAMETER_OFFSET]);
if (pDocuments[i] == NULL)
{
printf("Documents Load error at = %d\n", i);
printf("Filename = %s\n", argv[i]);
// clear memory if needed:
delete dae;
// report error code:
return -1;
}
}
NodeHPChecker * pNChecker = new NodeHPChecker(pDocuments[0], pDocuments[1], visualScene[0], visualScene[1]);
if (pNChecker->IsPreserved())
{
#ifdef TESTING
printf("They are the same.\n");
#endif
return 1;
}
else
{
#ifdef TESTING
printf("They are not the same.\n");
#endif
return 0;
}
}
void processNode(domNodeRef node, DAE &dae, const char *cmdlntexfn) {
daeTArray<daeElementRef> nodeChildren = node->getChildren();
for (size_t j = 0; j < nodeChildren.getCount(); j++) {
const daeElementRef nodeChild = nodeChildren[j];
const daeString nodeChildKind = nodeChild->getElementName();
if (!strcmp(nodeChildKind, "node"))
processNode(daeSafeCast<domNode>(nodeChild), dae, cmdlntexfn);
else if (!strcmp(nodeChildKind, "instance_geometry")) {
const daeTArray<daeElementRef> geometryChildren =
daeSafeCast<domInstance_geometry>(nodeChild)->getUrl().getElement()->getChildren();
for (size_t k = 0; k < geometryChildren.getCount(); k++) {
const daeElementRef geometryChild = geometryChildren[k];
const daeString geometryChildKind = geometryChild->getElementName();
if (!strcmp(geometryChildKind, "mesh")) {
const domMeshRef mesh = daeSafeCast<domMesh>(geometryChild);
const domTriangles_Array trianglesArray = mesh->getTriangles_array();
for (size_t i = 0; i < trianglesArray.getCount(); i++) {
char *effect = NULL;
string windex;
string texturefnstr;
const char *texturefn = cmdlntexfn;
daeElement *squeegee = nodeChild->getChild("bind_material");
if (squeegee) {
squeegee = squeegee->getChild("technique_common");
if (squeegee) {
squeegee = squeegee->getChild("instance_material");
if (squeegee) {
windex = squeegee->getAttribute("target");
effect = (char*)malloc(windex.length()+1);
if (!effect) {
perror("malloc");
exit(0);
}
strcpy(effect, windex.c_str());
daeElement *effectel = daeSafeCast<domInstance_material>(squeegee)->getTarget().getElement();
if (effectel) {
daeElement *profile_COMMON = effectel->getChild("profile_COMMON");
if (profile_COMMON) {
daeElement *technique = profile_COMMON->getChild("technique");
if (technique) {
daeElement *phong = technique->getChild("phong");
if (phong) {
daeElement *diffuse = phong->getChild("diffuse");
if (diffuse) {
daeElement *texture = diffuse->getChild("texture");
if (texture) {
const string samplerSid = texture->getAttribute("texture");
daeElement *samplernewparam = daeSidRef(samplerSid, effectel, "COMMON").resolve().elt;
if (samplernewparam) {
daeElement *sampler2D = samplernewparam->getChild("sampler2D");
if (sampler2D) {
daeElement *samplersrcel = sampler2D->getChild("source");
daeElement *minfilterel = sampler2D->getChild("minfilter");
daeElement *magfilterel = sampler2D->getChild("magfilter");
if (samplersrcel && minfilterel && magfilterel) {
const string surfSid = samplersrcel->getCharData();
daeElement *surfnewparam = daeSidRef(surfSid, effectel, "COMMON").resolve().elt;
if (surfnewparam) {
daeElement *surface = surfnewparam->getChild("surface");
if (surface) {
daeElement *init_from = surface->getChild("init_from");
if (init_from) {
daeElement *imageel = dae.getDatabase()->idLookup(init_from->getCharData(), init_from->getDocument());
if (imageel) {
daeElement *imageinit_from = imageel->getChild("init_from");
if (imageinit_from) {
texturefnstr = imageinit_from->getCharData();
texturefn = texturefnstr.c_str();
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
TriangleMesh x(trianglesArray[i], effect);
x.transform(texturefn);
}
}
}
}
}
}
int main(int argc, const char *argv[]) {
if (argc != 6) {
if (fprintf(stderr, "Usage: %s [dimension] [bgR] [bgG] [bgB] [texture]\n", argv[0]) < 0)
perror("fprintf");
return 0;
}
buf = new FrameBuffer(atoi(argv[1]), atof(argv[2]), atof(argv[3]), atof(argv[4]));
#ifdef WIN32
const char *fn = _tempnam("C:\tmp", "transform");
if (!fn) {
perror("_tempnam");
return 0;
}
#else
const char *fn = tmpnam(NULL);
if (!fn) {
perror("tmpnam");
return 0;
}
#endif
FILE *tmpfile = fopen(fn, "w");
if (!tmpfile) {
perror("fopen");
return 0;
}
int c;
while ((c = getchar()) != EOF)
if (fputc(c, tmpfile) == EOF) {
perror("fputc");
return 0;
}
if (ferror(tmpfile)) {
perror("getchar");
return 0;
}
if (fclose(tmpfile) == EOF) {
perror("fclose");
return 0;
}
DAE dae;
daeElement *root = dae.open(fn);
if (!root) {
if (fprintf(stderr, "Problem opening temporary file.\n") < 0)
perror("fprintf");
return 0;
}
const daeTArray<daeElementRef> visualSceneChildren =
daeSafeCast<domInstanceWithExtra>(root->getChild("scene")->getChild("instance_visual_scene"))
->getUrl().getElement()->getChildren();
for (size_t i = 0; i < visualSceneChildren.getCount(); i++) {
const daeElementRef node = visualSceneChildren[i];
if (!strcmp(node->getElementName(), "node"))
processNode(daeSafeCast<domNode>(node), dae, argv[5]);
}
dae.clear();
buf->write(dae, fn);
tmpfile = fopen(fn, "r");
if (!tmpfile) {
perror("fopen");
return 0;
}
while ((c = fgetc(tmpfile)) != EOF)
if (putchar(c) == EOF) {
perror("putchar");
return 0;
}
if (ferror(tmpfile)) {
perror("fgetc");
return 0;
}
if (fclose(tmpfile) == EOF) {
perror("fclose");
return 0;
}
if (remove(fn)) {
perror("remove");
return 0;
}
}
void registerDomTypes(DAE& dae)
{
daeAtomicType* type = NULL;
daeAtomicTypeList& atomicTypes = dae.getAtomicTypes();
// TYPEDEF: Bool //check if this type has an existing base
type = atomicTypes.get("xsBoolean");
if ( type == NULL ) { //register as a raw type
type = new daeRawRefType(dae);
type->_nameBindings.append("Bool");
atomicTypes.append( type );
}
else { //add binding to existing type
type->_nameBindings.append("Bool");
}
// TYPEDEF: DateTime //check if this type has an existing base
type = atomicTypes.get("xsDateTime");
if ( type == NULL ) { //register as a raw type
type = new daeRawRefType(dae);
type->_nameBindings.append("DateTime");
atomicTypes.append( type );
}
else { //add binding to existing type
type->_nameBindings.append("DateTime");
}
// TYPEDEF: Float //check if this type has an existing base
type = atomicTypes.get("xsDouble");
if ( type == NULL ) { //register as a raw type
type = new daeRawRefType(dae);
type->_nameBindings.append("Float");
atomicTypes.append( type );
}
else { //add binding to existing type
type->_nameBindings.append("Float");
}
// TYPEDEF: Int //check if this type has an existing base
type = atomicTypes.get("xsLong");
if ( type == NULL ) { //register as a raw type
type = new daeRawRefType(dae);
type->_nameBindings.append("Int");
atomicTypes.append( type );
}
else { //add binding to existing type
type->_nameBindings.append("Int");
}
// TYPEDEF: Name //check if this type has an existing base
type = atomicTypes.get("xsName");
if ( type == NULL ) { //register as a raw type
type = new daeRawRefType(dae);
type->_nameBindings.append("Name");
atomicTypes.append( type );
}
else { //add binding to existing type
type->_nameBindings.append("Name");
}
// TYPEDEF: String //check if this type has an existing base
type = atomicTypes.get("xsString");
if ( type == NULL ) { //register as a raw type
type = new daeRawRefType(dae);
type->_nameBindings.append("String");
atomicTypes.append( type );
}
else { //add binding to existing type
type->_nameBindings.append("String");
}
// TYPEDEF: Token //check if this type has an existing base
type = atomicTypes.get("xsToken");
if ( type == NULL ) { //register as a raw type
type = new daeRawRefType(dae);
type->_nameBindings.append("Token");
atomicTypes.append( type );
}
else { //add binding to existing type
type->_nameBindings.append("Token");
}
// TYPEDEF: Uint //check if this type has an existing base
type = atomicTypes.get("xsUnsignedLong");
if ( type == NULL ) { //register as a raw type
type = new daeRawRefType(dae);
type->_nameBindings.append("Uint");
atomicTypes.append( type );
}
else { //add binding to existing type
type->_nameBindings.append("Uint");
}
// TYPEDEF: ListOfBools //check if this type has an existing base
type = atomicTypes.get("Bool");
if ( type == NULL ) { //register as a raw type
type = new daeRawRefType(dae);
type->_nameBindings.append("ListOfBools");
atomicTypes.append( type );
}
else { //add binding to existing type
type->_nameBindings.append("ListOfBools");
}
// TYPEDEF: ListOfFloats //check if this type has an existing base
type = atomicTypes.get("Float");
if ( type == NULL ) { //register as a raw type
type = new daeRawRefType(dae);
type->_nameBindings.append("ListOfFloats");
atomicTypes.append( type );
}
else { //add binding to existing type
type->_nameBindings.append("ListOfFloats");
}
// TYPEDEF: ListOfHexBinary //check if this type has an existing base
type = atomicTypes.get("xsHexBinary");
if ( type == NULL ) { //register as a raw type
type = new daeRawRefType(dae);
type->_nameBindings.append("ListOfHexBinary");
atomicTypes.append( type );
}
else { //add binding to existing type
type->_nameBindings.append("ListOfHexBinary");
}
// TYPEDEF: ListOfInts //check if this type has an existing base
type = atomicTypes.get("Int");
if ( type == NULL ) { //register as a raw type
type = new daeRawRefType(dae);
type->_nameBindings.append("ListOfInts");
atomicTypes.append( type );
}
else { //add binding to existing type
type->_nameBindings.append("ListOfInts");
}
// TYPEDEF: ListOfNames //check if this type has an existing base
type = atomicTypes.get("Name");
if ( type == NULL ) { //register as a raw type
type = new daeRawRefType(dae);
type->_nameBindings.append("ListOfNames");
atomicTypes.append( type );
}
else { //add binding to existing type
type->_nameBindings.append("ListOfNames");
}
// TYPEDEF: ListOfTokens //check if this type has an existing base
type = atomicTypes.get("Token");
if ( type == NULL ) { //register as a raw type
type = new daeRawRefType(dae);
type->_nameBindings.append("ListOfTokens");
atomicTypes.append( type );
}
else { //add binding to existing type
type->_nameBindings.append("ListOfTokens");
}
// TYPEDEF: ListOfUInts //check if this type has an existing base
type = atomicTypes.get("Uint");
if ( type == NULL ) { //register as a raw type
type = new daeRawRefType(dae);
type->_nameBindings.append("ListOfUInts");
atomicTypes.append( type );
}
else { //add binding to existing type
type->_nameBindings.append("ListOfUInts");
}
// TYPEDEF: Bool2 //check if this type has an existing base
type = atomicTypes.get("ListOfBools");
if ( type == NULL ) { //register as a raw type
type = new daeRawRefType(dae);
type->_nameBindings.append("Bool2");
atomicTypes.append( type );
}
else { //add binding to existing type
type->_nameBindings.append("Bool2");
}
// TYPEDEF: Bool3 //check if this type has an existing base
type = atomicTypes.get("ListOfBools");
if ( type == NULL ) { //register as a raw type
type = new daeRawRefType(dae);
type->_nameBindings.append("Bool3");
atomicTypes.append( type );
}
else { //add binding to existing type
type->_nameBindings.append("Bool3");
}
// TYPEDEF: Bool4 //check if this type has an existing base
type = atomicTypes.get("ListOfBools");
if ( type == NULL ) { //register as a raw type
type = new daeRawRefType(dae);
type->_nameBindings.append("Bool4");
atomicTypes.append( type );
}
else { //add binding to existing type
type->_nameBindings.append("Bool4");
}
// TYPEDEF: Float2 //check if this type has an existing base
type = atomicTypes.get("ListOfFloats");
if ( type == NULL ) { //register as a raw type
type = new daeRawRefType(dae);
type->_nameBindings.append("Float2");
atomicTypes.append( type );
}
else { //add binding to existing type
type->_nameBindings.append("Float2");
}
// TYPEDEF: Float3 //check if this type has an existing base
type = atomicTypes.get("ListOfFloats");
if ( type == NULL ) { //register as a raw type
type = new daeRawRefType(dae);
type->_nameBindings.append("Float3");
atomicTypes.append( type );
}
else { //add binding to existing type
type->_nameBindings.append("Float3");
}
// TYPEDEF: Float4 //check if this type has an existing base
type = atomicTypes.get("ListOfFloats");
if ( type == NULL ) { //register as a raw type
type = new daeRawRefType(dae);
type->_nameBindings.append("Float4");
atomicTypes.append( type );
}
else { //add binding to existing type
type->_nameBindings.append("Float4");
}
// TYPEDEF: Float7 //check if this type has an existing base
type = atomicTypes.get("ListOfFloats");
if ( type == NULL ) { //register as a raw type
type = new daeRawRefType(dae);
type->_nameBindings.append("Float7");
atomicTypes.append( type );
}
else { //add binding to existing type
type->_nameBindings.append("Float7");
}
// TYPEDEF: Float2x2 //check if this type has an existing base
type = atomicTypes.get("ListOfFloats");
if ( type == NULL ) { //register as a raw type
type = new daeRawRefType(dae);
type->_nameBindings.append("Float2x2");
atomicTypes.append( type );
}
else { //add binding to existing type
type->_nameBindings.append("Float2x2");
}
// TYPEDEF: Float3x3 //check if this type has an existing base
type = atomicTypes.get("ListOfFloats");
if ( type == NULL ) { //register as a raw type
type = new daeRawRefType(dae);
type->_nameBindings.append("Float3x3");
atomicTypes.append( type );
}
else { //add binding to existing type
type->_nameBindings.append("Float3x3");
}
// TYPEDEF: Float4x4 //check if this type has an existing base
type = atomicTypes.get("ListOfFloats");
if ( type == NULL ) { //register as a raw type
type = new daeRawRefType(dae);
type->_nameBindings.append("Float4x4");
atomicTypes.append( type );
}
else { //add binding to existing type
type->_nameBindings.append("Float4x4");
}
// TYPEDEF: Float2x3 //check if this type has an existing base
type = atomicTypes.get("ListOfFloats");
if ( type == NULL ) { //register as a raw type
type = new daeRawRefType(dae);
type->_nameBindings.append("Float2x3");
atomicTypes.append( type );
}
else { //add binding to existing type
type->_nameBindings.append("Float2x3");
}
// TYPEDEF: Float2x4 //check if this type has an existing base
type = atomicTypes.get("ListOfFloats");
if ( type == NULL ) { //register as a raw type
type = new daeRawRefType(dae);
type->_nameBindings.append("Float2x4");
atomicTypes.append( type );
}
else { //add binding to existing type
type->_nameBindings.append("Float2x4");
}
// TYPEDEF: Float3x2 //check if this type has an existing base
type = atomicTypes.get("ListOfFloats");
if ( type == NULL ) { //register as a raw type
type = new daeRawRefType(dae);
type->_nameBindings.append("Float3x2");
atomicTypes.append( type );
}
else { //add binding to existing type
type->_nameBindings.append("Float3x2");
}
// TYPEDEF: Float3x4 //check if this type has an existing base
type = atomicTypes.get("ListOfFloats");
if ( type == NULL ) { //register as a raw type
type = new daeRawRefType(dae);
type->_nameBindings.append("Float3x4");
atomicTypes.append( type );
}
else { //add binding to existing type
type->_nameBindings.append("Float3x4");
}
// TYPEDEF: Float4x2 //check if this type has an existing base
type = atomicTypes.get("ListOfFloats");
if ( type == NULL ) { //register as a raw type
type = new daeRawRefType(dae);
type->_nameBindings.append("Float4x2");
atomicTypes.append( type );
}
else { //add binding to existing type
type->_nameBindings.append("Float4x2");
}
// TYPEDEF: Float4x3 //check if this type has an existing base
type = atomicTypes.get("ListOfFloats");
if ( type == NULL ) { //register as a raw type
type = new daeRawRefType(dae);
type->_nameBindings.append("Float4x3");
atomicTypes.append( type );
}
else { //add binding to existing type
type->_nameBindings.append("Float4x3");
}
// TYPEDEF: Int2 //check if this type has an existing base
type = atomicTypes.get("ListOfInts");
if ( type == NULL ) { //register as a raw type
type = new daeRawRefType(dae);
type->_nameBindings.append("Int2");
atomicTypes.append( type );
}
else { //add binding to existing type
type->_nameBindings.append("Int2");
}
// TYPEDEF: Int3 //check if this type has an existing base
type = atomicTypes.get("ListOfInts");
if ( type == NULL ) { //register as a raw type
type = new daeRawRefType(dae);
type->_nameBindings.append("Int3");
atomicTypes.append( type );
}
else { //add binding to existing type
type->_nameBindings.append("Int3");
}
// TYPEDEF: Int4 //check if this type has an existing base
type = atomicTypes.get("ListOfInts");
if ( type == NULL ) { //register as a raw type
type = new daeRawRefType(dae);
type->_nameBindings.append("Int4");
atomicTypes.append( type );
}
else { //add binding to existing type
type->_nameBindings.append("Int4");
}
// TYPEDEF: Int2x2 //check if this type has an existing base
type = atomicTypes.get("ListOfInts");
if ( type == NULL ) { //register as a raw type
type = new daeRawRefType(dae);
type->_nameBindings.append("Int2x2");
atomicTypes.append( type );
}
else { //add binding to existing type
type->_nameBindings.append("Int2x2");
}
// TYPEDEF: Int3x3 //check if this type has an existing base
type = atomicTypes.get("ListOfInts");
if ( type == NULL ) { //register as a raw type
type = new daeRawRefType(dae);
type->_nameBindings.append("Int3x3");
atomicTypes.append( type );
}
else { //add binding to existing type
type->_nameBindings.append("Int3x3");
}
// TYPEDEF: Int4x4 //check if this type has an existing base
type = atomicTypes.get("ListOfInts");
if ( type == NULL ) { //register as a raw type
type = new daeRawRefType(dae);
type->_nameBindings.append("Int4x4");
atomicTypes.append( type );
}
else { //add binding to existing type
type->_nameBindings.append("Int4x4");
}
// ENUM: MorphMethodType
type = new daeEnumType(dae);
type->_nameBindings.append("MorphMethodType");
((daeEnumType*)type)->_strings = new daeStringRefArray;
((daeEnumType*)type)->_values = new daeEnumArray;
((daeEnumType*)type)->_strings->append("NORMALIZED");
((daeEnumType*)type)->_values->append(MORPHMETHODTYPE_NORMALIZED);
((daeEnumType*)type)->_strings->append("RELATIVE");
((daeEnumType*)type)->_values->append(MORPHMETHODTYPE_RELATIVE);
atomicTypes.append( type );
// ENUM: NodeType
type = new daeEnumType(dae);
type->_nameBindings.append("NodeType");
((daeEnumType*)type)->_strings = new daeStringRefArray;
((daeEnumType*)type)->_values = new daeEnumArray;
((daeEnumType*)type)->_strings->append("JOINT");
((daeEnumType*)type)->_values->append(NODETYPE_JOINT);
((daeEnumType*)type)->_strings->append("NODE");
((daeEnumType*)type)->_values->append(NODETYPE_NODE);
atomicTypes.append( type );
// TYPEDEF: URIFragmentType //check if this type has an existing base
type = atomicTypes.get("xsAnyURI");
if ( type == NULL ) { //register as a raw type
type = new daeRawRefType(dae);
type->_nameBindings.append("URIFragmentType");
atomicTypes.append( type );
}
else { //add binding to existing type
type->_nameBindings.append("URIFragmentType");
}
// ENUM: UpAxisType
type = new daeEnumType(dae);
type->_nameBindings.append("UpAxisType");
((daeEnumType*)type)->_strings = new daeStringRefArray;
((daeEnumType*)type)->_values = new daeEnumArray;
((daeEnumType*)type)->_strings->append("X_UP");
((daeEnumType*)type)->_values->append(UPAXISTYPE_X_UP);
((daeEnumType*)type)->_strings->append("Y_UP");
((daeEnumType*)type)->_values->append(UPAXISTYPE_Y_UP);
((daeEnumType*)type)->_strings->append("Z_UP");
((daeEnumType*)type)->_values->append(UPAXISTYPE_Z_UP);
atomicTypes.append( type );
// ENUM: VersionType
type = new daeEnumType(dae);
type->_nameBindings.append("VersionType");
((daeEnumType*)type)->_strings = new daeStringRefArray;
((daeEnumType*)type)->_values = new daeEnumArray;
((daeEnumType*)type)->_strings->append("1.4.0");
((daeEnumType*)type)->_values->append(VERSIONTYPE_1_4_0);
((daeEnumType*)type)->_strings->append("1.4.1");
((daeEnumType*)type)->_values->append(VERSIONTYPE_1_4_1);
atomicTypes.append( type );
// TYPEDEF: Fx_color_common //check if this type has an existing base
type = atomicTypes.get("Float4");
if ( type == NULL ) { //register as a raw type
type = new daeRawRefType(dae);
type->_nameBindings.append("Fx_color_common");
atomicTypes.append( type );
}
else { //add binding to existing type
type->_nameBindings.append("Fx_color_common");
}
// ENUM: Fx_opaque_enum
type = new daeEnumType(dae);
type->_nameBindings.append("Fx_opaque_enum");
((daeEnumType*)type)->_strings = new daeStringRefArray;
((daeEnumType*)type)->_values = new daeEnumArray;
((daeEnumType*)type)->_strings->append("A_ONE");
((daeEnumType*)type)->_values->append(FX_OPAQUE_ENUM_A_ONE);
((daeEnumType*)type)->_strings->append("RGB_ZERO");
((daeEnumType*)type)->_values->append(FX_OPAQUE_ENUM_RGB_ZERO);
atomicTypes.append( type );
// ENUM: Fx_surface_type_enum
type = new daeEnumType(dae);
type->_nameBindings.append("Fx_surface_type_enum");
((daeEnumType*)type)->_strings = new daeStringRefArray;
((daeEnumType*)type)->_values = new daeEnumArray;
((daeEnumType*)type)->_strings->append("UNTYPED");
((daeEnumType*)type)->_values->append(FX_SURFACE_TYPE_ENUM_UNTYPED);
((daeEnumType*)type)->_strings->append("1D");
((daeEnumType*)type)->_values->append(FX_SURFACE_TYPE_ENUM_1D);
((daeEnumType*)type)->_strings->append("2D");
((daeEnumType*)type)->_values->append(FX_SURFACE_TYPE_ENUM_2D);
((daeEnumType*)type)->_strings->append("3D");
((daeEnumType*)type)->_values->append(FX_SURFACE_TYPE_ENUM_3D);
((daeEnumType*)type)->_strings->append("RECT");
((daeEnumType*)type)->_values->append(FX_SURFACE_TYPE_ENUM_RECT);
((daeEnumType*)type)->_strings->append("CUBE");
((daeEnumType*)type)->_values->append(FX_SURFACE_TYPE_ENUM_CUBE);
((daeEnumType*)type)->_strings->append("DEPTH");
((daeEnumType*)type)->_values->append(FX_SURFACE_TYPE_ENUM_DEPTH);
atomicTypes.append( type );
// ENUM: Fx_surface_face_enum
type = new daeEnumType(dae);
type->_nameBindings.append("Fx_surface_face_enum");
((daeEnumType*)type)->_strings = new daeStringRefArray;
((daeEnumType*)type)->_values = new daeEnumArray;
((daeEnumType*)type)->_strings->append("POSITIVE_X");
((daeEnumType*)type)->_values->append(FX_SURFACE_FACE_ENUM_POSITIVE_X);
((daeEnumType*)type)->_strings->append("NEGATIVE_X");
((daeEnumType*)type)->_values->append(FX_SURFACE_FACE_ENUM_NEGATIVE_X);
((daeEnumType*)type)->_strings->append("POSITIVE_Y");
((daeEnumType*)type)->_values->append(FX_SURFACE_FACE_ENUM_POSITIVE_Y);
((daeEnumType*)type)->_strings->append("NEGATIVE_Y");
((daeEnumType*)type)->_values->append(FX_SURFACE_FACE_ENUM_NEGATIVE_Y);
((daeEnumType*)type)->_strings->append("POSITIVE_Z");
((daeEnumType*)type)->_values->append(FX_SURFACE_FACE_ENUM_POSITIVE_Z);
((daeEnumType*)type)->_strings->append("NEGATIVE_Z");
((daeEnumType*)type)->_values->append(FX_SURFACE_FACE_ENUM_NEGATIVE_Z);
atomicTypes.append( type );
// ENUM: Fx_surface_format_hint_channels_enum
type = new daeEnumType(dae);
type->_nameBindings.append("Fx_surface_format_hint_channels_enum");
((daeEnumType*)type)->_strings = new daeStringRefArray;
((daeEnumType*)type)->_values = new daeEnumArray;
((daeEnumType*)type)->_strings->append("RGB");
((daeEnumType*)type)->_values->append(FX_SURFACE_FORMAT_HINT_CHANNELS_ENUM_RGB);
((daeEnumType*)type)->_strings->append("RGBA");
((daeEnumType*)type)->_values->append(FX_SURFACE_FORMAT_HINT_CHANNELS_ENUM_RGBA);
((daeEnumType*)type)->_strings->append("L");
((daeEnumType*)type)->_values->append(FX_SURFACE_FORMAT_HINT_CHANNELS_ENUM_L);
((daeEnumType*)type)->_strings->append("LA");
((daeEnumType*)type)->_values->append(FX_SURFACE_FORMAT_HINT_CHANNELS_ENUM_LA);
((daeEnumType*)type)->_strings->append("D");
((daeEnumType*)type)->_values->append(FX_SURFACE_FORMAT_HINT_CHANNELS_ENUM_D);
((daeEnumType*)type)->_strings->append("XYZ");
((daeEnumType*)type)->_values->append(FX_SURFACE_FORMAT_HINT_CHANNELS_ENUM_XYZ);
((daeEnumType*)type)->_strings->append("XYZW");
((daeEnumType*)type)->_values->append(FX_SURFACE_FORMAT_HINT_CHANNELS_ENUM_XYZW);
atomicTypes.append( type );
// ENUM: Fx_surface_format_hint_precision_enum
type = new daeEnumType(dae);
type->_nameBindings.append("Fx_surface_format_hint_precision_enum");
((daeEnumType*)type)->_strings = new daeStringRefArray;
((daeEnumType*)type)->_values = new daeEnumArray;
((daeEnumType*)type)->_strings->append("LOW");
((daeEnumType*)type)->_values->append(FX_SURFACE_FORMAT_HINT_PRECISION_ENUM_LOW);
((daeEnumType*)type)->_strings->append("MID");
((daeEnumType*)type)->_values->append(FX_SURFACE_FORMAT_HINT_PRECISION_ENUM_MID);
((daeEnumType*)type)->_strings->append("HIGH");
((daeEnumType*)type)->_values->append(FX_SURFACE_FORMAT_HINT_PRECISION_ENUM_HIGH);
atomicTypes.append( type );
// ENUM: Fx_surface_format_hint_range_enum
type = new daeEnumType(dae);
type->_nameBindings.append("Fx_surface_format_hint_range_enum");
((daeEnumType*)type)->_strings = new daeStringRefArray;
((daeEnumType*)type)->_values = new daeEnumArray;
((daeEnumType*)type)->_strings->append("SNORM");
((daeEnumType*)type)->_values->append(FX_SURFACE_FORMAT_HINT_RANGE_ENUM_SNORM);
((daeEnumType*)type)->_strings->append("UNORM");
((daeEnumType*)type)->_values->append(FX_SURFACE_FORMAT_HINT_RANGE_ENUM_UNORM);
((daeEnumType*)type)->_strings->append("SINT");
((daeEnumType*)type)->_values->append(FX_SURFACE_FORMAT_HINT_RANGE_ENUM_SINT);
((daeEnumType*)type)->_strings->append("UINT");
((daeEnumType*)type)->_values->append(FX_SURFACE_FORMAT_HINT_RANGE_ENUM_UINT);
((daeEnumType*)type)->_strings->append("FLOAT");
((daeEnumType*)type)->_values->append(FX_SURFACE_FORMAT_HINT_RANGE_ENUM_FLOAT);
atomicTypes.append( type );
// ENUM: Fx_surface_format_hint_option_enum
type = new daeEnumType(dae);
type->_nameBindings.append("Fx_surface_format_hint_option_enum");
((daeEnumType*)type)->_strings = new daeStringRefArray;
((daeEnumType*)type)->_values = new daeEnumArray;
((daeEnumType*)type)->_strings->append("SRGB_GAMMA");
((daeEnumType*)type)->_values->append(FX_SURFACE_FORMAT_HINT_OPTION_ENUM_SRGB_GAMMA);
((daeEnumType*)type)->_strings->append("NORMALIZED3");
((daeEnumType*)type)->_values->append(FX_SURFACE_FORMAT_HINT_OPTION_ENUM_NORMALIZED3);
((daeEnumType*)type)->_strings->append("NORMALIZED4");
((daeEnumType*)type)->_values->append(FX_SURFACE_FORMAT_HINT_OPTION_ENUM_NORMALIZED4);
((daeEnumType*)type)->_strings->append("COMPRESSABLE");
((daeEnumType*)type)->_values->append(FX_SURFACE_FORMAT_HINT_OPTION_ENUM_COMPRESSABLE);
atomicTypes.append( type );
// ENUM: Fx_sampler_wrap_common
type = new daeEnumType(dae);
type->_nameBindings.append("Fx_sampler_wrap_common");
((daeEnumType*)type)->_strings = new daeStringRefArray;
((daeEnumType*)type)->_values = new daeEnumArray;
((daeEnumType*)type)->_strings->append("NONE");
((daeEnumType*)type)->_values->append(FX_SAMPLER_WRAP_COMMON_NONE);
((daeEnumType*)type)->_strings->append("WRAP");
((daeEnumType*)type)->_values->append(FX_SAMPLER_WRAP_COMMON_WRAP);
((daeEnumType*)type)->_strings->append("MIRROR");
((daeEnumType*)type)->_values->append(FX_SAMPLER_WRAP_COMMON_MIRROR);
((daeEnumType*)type)->_strings->append("CLAMP");
((daeEnumType*)type)->_values->append(FX_SAMPLER_WRAP_COMMON_CLAMP);
((daeEnumType*)type)->_strings->append("BORDER");
((daeEnumType*)type)->_values->append(FX_SAMPLER_WRAP_COMMON_BORDER);
atomicTypes.append( type );
// ENUM: Fx_sampler_filter_common
type = new daeEnumType(dae);
type->_nameBindings.append("Fx_sampler_filter_common");
((daeEnumType*)type)->_strings = new daeStringRefArray;
((daeEnumType*)type)->_values = new daeEnumArray;
((daeEnumType*)type)->_strings->append("NONE");
((daeEnumType*)type)->_values->append(FX_SAMPLER_FILTER_COMMON_NONE);
((daeEnumType*)type)->_strings->append("NEAREST");
((daeEnumType*)type)->_values->append(FX_SAMPLER_FILTER_COMMON_NEAREST);
((daeEnumType*)type)->_strings->append("LINEAR");
((daeEnumType*)type)->_values->append(FX_SAMPLER_FILTER_COMMON_LINEAR);
((daeEnumType*)type)->_strings->append("NEAREST_MIPMAP_NEAREST");
((daeEnumType*)type)->_values->append(FX_SAMPLER_FILTER_COMMON_NEAREST_MIPMAP_NEAREST);
((daeEnumType*)type)->_strings->append("LINEAR_MIPMAP_NEAREST");
((daeEnumType*)type)->_values->append(FX_SAMPLER_FILTER_COMMON_LINEAR_MIPMAP_NEAREST);
((daeEnumType*)type)->_strings->append("NEAREST_MIPMAP_LINEAR");
((daeEnumType*)type)->_values->append(FX_SAMPLER_FILTER_COMMON_NEAREST_MIPMAP_LINEAR);
((daeEnumType*)type)->_strings->append("LINEAR_MIPMAP_LINEAR");
((daeEnumType*)type)->_values->append(FX_SAMPLER_FILTER_COMMON_LINEAR_MIPMAP_LINEAR);
atomicTypes.append( type );
// ENUM: Fx_modifier_enum_common
type = new daeEnumType(dae);
type->_nameBindings.append("Fx_modifier_enum_common");
((dae
void TSRModelExporterDOM::ProcessModel( const char* _pSrcFileName, const char* _pDestFileName, eTSRExportPlatform _Platform )
{
DAE dae;
daeString DomVersion = dae.getDomVersion();
domCOLLADA* root = dae.open( _pSrcFileName );
#ifndef COLLADA14
if ( root == NULL )
{
ConvertToCollada15( file );
root = dae.open( file );
}
#endif
if ( root )
{
printf( "\nCollada Asset is OK..\n" );
}
else
{
throw "Asset cooking failed";
return;
}
domCOLLADA& _colladaRoot = *root;
m_Platform = _Platform;
m_SrcFileName = _pSrcFileName;
m_DestFileName = _pDestFileName;
string fullPath = _pDestFileName;
int slashPosition = ( int ) fullPath.find_last_of( "/" );
string dstFileNameHeader = "";
if( slashPosition > -1 )
{
dstFileNameHeader = fullPath.substr( 0, slashPosition );
}
TSRFileSystem::CreateFolder( dstFileNameHeader.c_str() );
m_ShadersNames.clear();
m_ShadersNames.push_back( "supershader.fx" );
/// up axis is Z or Y..?
CalculateFixupMatrixDOM( _colladaRoot );
/// process all images...
ProcessImagesLibraryDOM( _colladaRoot );
/// process all materials...
ProcessMaterialsLibraryDOM( _colladaRoot );
/// process all animations
ProcessAnimationsLibraryDOM( _colladaRoot );
domVisual_scene* visualScene = daeSafeCast< domVisual_scene >( _colladaRoot.getDescendant( "visual_scene" ) );
/// Now covert all the <node>s in the <visual_scene>. This is a recursive process,
// so any child nodes will also be converted.
domNode_Array& nodes = visualScene->getNode_array();
m_MatrixStack.Push();
m_MatrixStack.LoadMatrix( m_FixupMatrix.d );
/// generate the skeleton bones
for ( size_t i = 0; i < nodes.getCount(); i++ )
{
GenerateSkeletonRecDOM( nodes[ i ] );
}
/// generate the nodes and the render nodes..
for ( size_t i = 0; i < nodes.getCount(); i++ )
{
GenerateTwisterNodesRecDOM( nodes[ i ], m_FixupMatrix );
}
m_MatrixStack.Pop();
/// compute the whole aabb...
TSRBBox aabb;
for( unsigned int i = 0; i < nodes.getCount(); i++ )
{
domNode* pNode=nodes[ i ];
ComputeAABBDOM( pNode, aabb );
}
m_AABB.m_vMin = aabb.m_vMin * m_FixupMatrix;
m_AABB.m_vMax = aabb.m_vMax * m_FixupMatrix;
m_pDomRootNodes = &nodes;
/// ready to write
WriteProcessedModel( _pDestFileName );
}
