ColladaXML Class Reference

#include <ColladaTool.h>

Collaboration diagram for ColladaXML:
Collaboration graph
[legend]

List of all members.

Public Member Functions

 ColladaXML (double meter=1.0, int axis=COLLADA_Z_UP, const char *ver=NULL)
 ColladaXML (float meter, int axis=COLLADA_Z_UP, const char *ver=NULL)
virtual ~ColladaXML (void)
void init (double meter=1.0, int axis=COLLADA_Z_UP, const char *ver=NULL)
void init (float meter, int axis=COLLADA_Z_UP, const char *ver=NULL)
void clear (double meter=1.0, int axis=COLLADA_Z_UP, const char *ver=NULL)
void clear (float meter, int axis=COLLADA_Z_UP, const char *ver=NULL)
void free (void)
void print (FILE *fp, int mode=XML_INDENT_FORMAT)
void print_tree (FILE *fp)
void initCollada (double meter, int axis, const char *ver)
void initCollada (float meter, int axis, const char *ver)
void addObject (MeshObjectData *meshdata, bool collider)
char * addGeometry (MeshObjectData *meshdata)
void addScene (const char *geometry_id, MeshObjectData *meshdata, bool collider)
char * addVertexSource (tXML *mesh, MeshObjectData *meshdata)
char * addNormalSource (tXML *mesh, MeshObjectData *meshdata)
char * addTexcrdSource (tXML *mesh, MeshObjectData *meshdata)
char * addVerticesPos (tXML *mesh, const char *position_id)
void addPosTechniqueAccessor (tXML *source, const char *source_array_id, int count)
void addMapTechniqueAccessor (tXML *source, const char *source_array_id, int count)
void addPolylists (tXML *mesh, MeshObjectData *meshdata, const char *vertex_id, const char *normal_id=NULL, const char *texcrd_id=NULL)
char * addImage (const char *filename)
char * addMaterial (const char *material)
tXML * addEffect (const char *material_url, const char *file_id, MaterialParam param)
void addExtraBumpmap (tXML *effect, const char *bump_id)
bool existSameID (tXML *top, const char *tag, const char *id)
void setBlankTexture (const char *name)
bool isBlankTexture (const char *name)
void outputFile (const char *fn, const char *path=NULL, int mode=XML_INDENT_FORMAT)
void addCenterObject (void)
void addCenterScene (void)

Public Attributes

bool forUnity3D
tXML * xml
tXML * collada
tXML * asset
tXML * contributor
tXML * author
tXML * authoring_tool
tXML * created
tXML * modified
tXML * unit
tXML * up_axis
tXML * library_images
tXML * library_geometries
tXML * library_effects
tXML * library_materials
tXML * library_visual_scenes
tXML * library_physics_scenes
tXML * library_physics_models
tXML * instance_physics_model
tXML * visual_scene
tXML * physics_scene
tXML * physics_model
tXML * scene
tXML * instance_visual_scene
tXML * instance_physics_scene
Buffer blank_texture

Detailed Description

Definition at line 38 of file ColladaTool.h.

Constructor & Destructor Documentation

ColladaXML ( double  meter = 1.0,
int  axis = COLLADA_Z_UP,
const char *  ver = NULL 
) [inline]

Definition at line 41 of file ColladaTool.h.

References ColladaXML::init().

00041 { init(meter, axis, ver);}

Here is the call graph for this function:

ColladaXML ( float  meter,
int  axis = COLLADA_Z_UP,
const char *  ver = NULL 
) [inline]

Definition at line 42 of file ColladaTool.h.

References ColladaXML::init().

00042 { init(meter, axis, ver);}

Here is the call graph for this function:

~ColladaXML ( void   )  [virtual]

Definition at line 19 of file ColladaTool.cpp.

00020 { 
00021     //DEBUG_INFO("DESTRUCTOR: ColladaXML");
00022 }

Member Function Documentation

void addCenterObject ( void   ) 

Definition at line 892 of file ColladaTool.cpp.

References ColladaXML::addCenterScene().

00893 {
00894     addCenterScene();
00895     return;
00896 }

Here is the call graph for this function:

void addCenterScene ( void   ) 

Definition at line 901 of file ColladaTool.cpp.

References add_xml_attr_str(), add_xml_node(), append_xml_content(), AffineTrans< T >::computeMatrix(), dtostr(), Matrix< T >::element(), AffineTrans< T >::free(), AffineTrans< T >::matrix, and ColladaXML::visual_scene.

Referenced by ColladaXML::addCenterObject().

00902 {
00903     tXML* nodetag = add_xml_node(visual_scene, "node");
00904     add_xml_attr_str(nodetag, "id",   "#NODE_DUMMY");
00905     add_xml_attr_str(nodetag, "name", "center_origin");
00906     add_xml_attr_str(nodetag, "type", "NODE");
00907 
00908     // 回転行列
00909     AffineTrans<double> affine;
00910     affine.computeMatrix(false);
00911     tXML* matrix = add_xml_node(nodetag, "matrix");
00912     for (int i=1; i<=4; i++) {
00913         for (int j=1; j<=4; j++) {
00914             append_xml_content(matrix, dtostr(affine.matrix.element(i,j)));
00915         }
00916     }
00917     affine.free();
00918 
00919     return;
00920 }

Here is the call graph for this function:

Here is the caller graph for this function:

tXML * addEffect ( const char *  material_url,
const char *  file_id,
MaterialParam  param 
)

Definition at line 543 of file ColladaTool.cpp.

References _tochar, add_xml_attr_str(), add_xml_node(), append_xml_content(), Buffer::buf, cat_s2Buffer, dtostr(), ColladaXML::forUnity3D, free_Buffer(), MaterialParam::getBright(), TextureParam::getColor(), MaterialParam::getColor(), MaterialParam::getGlow(), MaterialParam::getShininess(), MaterialParam::getTextureName(), MaterialParam::getTransparent(), ColladaXML::isBlankTexture(), MaterialParam::isSetBright(), MaterialParam::isSetColor(), MaterialParam::isSetGlow(), MaterialParam::isSetShininess(), MaterialParam::isTransparency(), ColladaXML::library_effects, make_Buffer_randomstr, make_Buffer_str, Min, and MaterialParam::specmap.

Referenced by ColladaXML::addPolylists().

00544 {
00545     if (material_url==NULL || file_id==NULL) return NULL;
00546 
00547     Buffer fid = make_Buffer_str(file_id);
00548     Buffer srf = make_Buffer_str(file_id);
00549     Buffer smp = make_Buffer_str(file_id);
00550 
00551     Buffer randomstr = make_Buffer_randomstr(5);
00552     cat_s2Buffer("-", &srf);
00553     cat_s2Buffer("-", &smp);
00554     cat_s2Buffer(randomstr.buf, &srf);
00555     cat_s2Buffer(randomstr.buf, &smp);
00556     cat_s2Buffer("-surface", &srf);
00557     cat_s2Buffer("-sampler", &smp);
00558     free_Buffer(&randomstr);
00559 
00560     tXML* effect = add_xml_node(library_effects, "effect");
00561     add_xml_attr_str(effect, "id", material_url+1);
00562     tXML* profile = add_xml_node(effect, "profile_COMMON");
00563 
00564     if (!isBlankTexture(mparam.getTextureName())) {
00565         tXML* newparam;
00566         newparam = add_xml_node(profile, "newparam");
00567         add_xml_attr_str(newparam, "sid", _tochar(srf.buf));
00568         tXML* surface = add_xml_node(newparam, "surface");
00569         add_xml_attr_str(surface, "type", "2D");
00570         tXML* init_from = add_xml_node(surface, "init_from");
00571         append_xml_content(init_from, _tochar(fid.buf));
00572 
00573         newparam = add_xml_node(profile, "newparam");
00574         add_xml_attr_str(newparam, "sid", _tochar(smp.buf));
00575         tXML* sample = add_xml_node(newparam, "sampler2D");
00576         tXML* source = add_xml_node(sample, "source");
00577         append_xml_content(source, _tochar(srf.buf));
00578     }
00579 
00580     tXML* technique = add_xml_node(profile, "technique");
00581     add_xml_attr_str(technique, "sid", "common");
00582     tXML* phong   = add_xml_node(technique, "phong");
00583 
00584     // emission (glow)
00585     if (mparam.isSetGlow()) {
00586         tXML* emission = add_xml_node(phong, "emission");
00587         tXML* color = add_xml_node(emission, "color");
00588         for (int i=0; i<3; i++) append_xml_content(color, dtostr(mparam.getGlow()));
00589         append_xml_content(color, "1.0");   // alpha
00590     }
00591 
00592     // ambient (bright)
00593     if (mparam.isSetBright()) {
00594         tXML* ambient = add_xml_node(phong, "ambient");
00595         tXML* color = add_xml_node(ambient, "color");
00596         for (int i=0; i<3; i++) append_xml_content(color, dtostr(mparam.getBright()));
00597         append_xml_content(color, "1.0");   // alpha
00598     }
00599 
00600     // diffuse
00601     tXML* diffuse = NULL;
00602     if (!isBlankTexture(mparam.getTextureName())) {
00603         diffuse = add_xml_node(phong, "diffuse");
00604         tXML* texture = add_xml_node(diffuse, "texture");
00605         add_xml_attr_str(texture, "texture",  _tochar(smp.buf));
00606         add_xml_attr_str(texture, "texcoord", _tochar(fid.buf));
00607     }
00608 
00609     // color
00610     if (mparam.isSetColor()) {
00611         if (diffuse==NULL || forUnity3D) {
00612             // テクスチャがない場合(diffuse==NULL) または Unity3Dの場合は <diffuse>を新しく作成．
00613             // Unity3Dの場合は Colladaの規格には違反しているが，カラーを読むために必要．
00614             diffuse = add_xml_node(phong, "diffuse");
00615         }
00616         //
00617         tXML* color = add_xml_node(diffuse, "color");
00618         add_xml_attr_str(color, "sid", "diffuse");
00619         for (int i=0; i<4; i++) {
00620             double col = mparam.getColor(i);
00621             //if (forUnity3D && col==0.0) col = 0.0001;
00622             append_xml_content(color, dtostr(col));
00623         }
00624     }
00625 
00626     // transparency (alpha channel) 
00627     if (mparam.isTransparency()) {
00628         double alpha = Min(mparam.getTransparent(), mparam.getColor(3));
00629         if (forUnity3D && alpha<0.01) alpha = 0.01;
00630         tXML* transparency = add_xml_node(phong, "transparency");
00631         tXML* transfloat   = add_xml_node(transparency, "float");
00632         append_xml_content(transfloat, dtostr(alpha));
00633     }
00634 
00635     // shininess 
00636     if (mparam.isSetShininess()) {
00637         tXML* specular = add_xml_node(phong, "specular");
00638         tXML* color = add_xml_node(specular, "color");
00639         for (int i=0; i<4; i++) append_xml_content(color, dtostr(mparam.specmap.getColor(i)));
00640         //
00641         tXML* shininess = add_xml_node(phong, "shininess");
00642         tXML* shinfloat = add_xml_node(shininess, "float");
00643         append_xml_content(shinfloat, dtostr(mparam.getShininess()));
00644     }
00645 
00646     free_Buffer(&fid);
00647     free_Buffer(&srf);
00648     free_Buffer(&smp);
00649 
00650     return profile;
00651 }

Here is the call graph for this function:

Here is the caller graph for this function:

void addExtraBumpmap ( tXML *  effect,
const char *  bump_id 
)

Definition at line 655 of file ColladaTool.cpp.

References _tochar, add_xml_attr_str(), add_xml_node(), append_xml_content(), Buffer::buf, cat_s2Buffer, free_Buffer(), get_xml_node_bystr(), insert_xml_node(), make_Buffer_randomstr, and make_Buffer_str.

Referenced by ColladaXML::addPolylists().

00656 {
00657     if (profile==NULL || bump_id==NULL) return;
00658 
00659     Buffer fid = make_Buffer_str(bump_id);
00660     Buffer srf = make_Buffer_str(bump_id);
00661     Buffer smp = make_Buffer_str(bump_id);
00662 
00663     Buffer randomstr = make_Buffer_randomstr(5);
00664     cat_s2Buffer("-", &srf);
00665     cat_s2Buffer("-", &smp);
00666     cat_s2Buffer(randomstr.buf, &srf);
00667     cat_s2Buffer(randomstr.buf, &smp);
00668     cat_s2Buffer("-surface", &srf);
00669     cat_s2Buffer("-sampler", &smp);
00670     free_Buffer(&randomstr);
00671 
00672     tXML* newparam;
00673     newparam = insert_xml_node(profile, "newparam");
00674     add_xml_attr_str(newparam, "sid", _tochar(smp.buf));
00675     tXML* sample = add_xml_node(newparam, "sampler2D");
00676     tXML* source = add_xml_node(sample, "source");
00677     append_xml_content(source, _tochar(srf.buf));
00678 
00679     newparam = insert_xml_node(profile, "newparam");
00680     add_xml_attr_str(newparam, "sid", _tochar(srf.buf));
00681     tXML* surface = add_xml_node(newparam, "surface");
00682     add_xml_attr_str(surface, "type", "2D");
00683     tXML* init_from = add_xml_node(surface, "init_from");
00684     append_xml_content(init_from, _tochar(fid.buf));
00685 
00686     tXML* technique = get_xml_node_bystr(profile, "<technique>");
00687     tXML* extra = add_xml_node(technique, "extra");
00688     tXML* techbump = add_xml_node(extra, "technique");
00689     add_xml_attr_str(techbump, "profile", "BumpMap");
00690     tXML* bump = add_xml_node(techbump, "bump");
00691 
00692     tXML* texture = add_xml_node(bump, "texture");
00693     add_xml_attr_str(texture, "texture",  _tochar(smp.buf));
00694     add_xml_attr_str(texture, "texcoord", _tochar(fid.buf));
00695 
00696     free_Buffer(&fid);
00697     free_Buffer(&srf);
00698     free_Buffer(&smp);
00699 
00700     return;
00701 }

Here is the call graph for this function:

Here is the caller graph for this function:

char * addGeometry ( MeshObjectData *  meshdata  ) 

Definition at line 171 of file ColladaTool.cpp.

References _tochar, add_xml_attr_str(), add_xml_node(), ColladaXML::addNormalSource(), ColladaXML::addPolylists(), ColladaXML::addTexcrdSource(), ColladaXML::addVertexSource(), ColladaXML::addVerticesPos(), Buffer::buf, cat_Buffer(), MeshObjectData::data_name, dup_Buffer(), free_Buffer(), jbxl::freeNull(), ColladaXML::library_geometries, make_Buffer_randomstr, and make_Buffer_str.

Referenced by ColladaXML::addObject().

00172 {
00173     if (meshdata==NULL) return NULL;
00174 
00175     // ID String
00176     Buffer randomstr = make_Buffer_randomstr(8);
00177     Buffer geometry_id = make_Buffer_str("#GEOMETRY_");
00178     cat_Buffer(&randomstr, &geometry_id);
00179 
00180     Buffer geometry_name = dup_Buffer(meshdata->data_name);
00181     if (geometry_name.buf==NULL) geometry_name = make_Buffer_str(geometry_id.buf+1);
00182 
00183     // library_geometries
00184     tXML* geomrtry = add_xml_node(library_geometries, "geometry");
00185     add_xml_attr_str(geomrtry, "id",   _tochar(geometry_id.buf+1));
00186     add_xml_attr_str(geomrtry, "name", _tochar(geometry_name.buf));
00187     tXML* mesh = add_xml_node(geomrtry, "mesh");
00188 
00189     // Source & Vertices
00190     char* psitin_id = addVertexSource(mesh, meshdata);
00191     char* normal_id = addNormalSource(mesh, meshdata);
00192     char* texcrd_id = addTexcrdSource(mesh, meshdata);
00193     char* vertex_id = addVerticesPos (mesh, psitin_id);
00194 
00195     // Polylist
00196     addPolylists(mesh, meshdata, vertex_id, normal_id, texcrd_id);
00197 
00198     freeNull(psitin_id);
00199     freeNull(normal_id);
00200     freeNull(vertex_id);
00201     freeNull(texcrd_id);
00202 
00203     free_Buffer(&randomstr);
00204     free_Buffer(&geometry_name);
00205 
00206     return _tochar(geometry_id.buf);
00207 }

Here is the call graph for this function:

Here is the caller graph for this function:

char * addImage ( const char *  filename  ) 

Definition at line 497 of file ColladaTool.cpp.

References _tochar, add_xml_attr_int(), add_xml_attr_str(), add_xml_node(), append_xml_content(), Buffer::buf, ColladaXML::existSameID(), free_Buffer(), ColladaXML::library_images, make_Buffer_str, and replace_sBuffer_str.

Referenced by ColladaXML::addPolylists().

00498 {
00499     if (fn==NULL) return NULL;
00500 
00501     Buffer filename = make_Buffer_str(fn);
00502     Buffer temp_id  = replace_sBuffer_str(filename, ".", "_");
00503     Buffer file_id  = replace_sBuffer_str(temp_id , " ", "_");
00504     free_Buffer(&temp_id);
00505 
00506     bool exist_same_image = existSameID(library_images, "<library_images><image>", _tochar(file_id.buf));
00507     if (!exist_same_image) {
00508         tXML* image = add_xml_node(library_images, "image");
00509         add_xml_attr_str(image, "id",   _tochar(file_id.buf));
00510         add_xml_attr_str(image, "name", _tochar(file_id.buf));
00511         add_xml_attr_int(image, "height", 0);
00512         add_xml_attr_int(image, "width",  0);
00513 
00514         tXML* init_from = add_xml_node(image, "init_from");
00515         append_xml_content(init_from, _tochar(filename.buf));
00516     }
00517 
00518     free_Buffer(&filename);
00519 
00520     return _tochar(file_id.buf);
00521 }

Here is the call graph for this function:

Here is the caller graph for this function:

void addMapTechniqueAccessor ( tXML *  source,
const char *  source_array_id,
int  count 
)

Definition at line 392 of file ColladaTool.cpp.

References add_xml_attr_int(), add_xml_attr_str(), and add_xml_node().

Referenced by ColladaXML::addTexcrdSource().

00393 {
00394     if (source==NULL || source_array_id==NULL) return;
00395 
00396     tXML* technique_common = add_xml_node(source, "technique_common");
00397     tXML* accessor = add_xml_node(technique_common, "accessor");
00398     add_xml_attr_str(accessor, "source", source_array_id);
00399     add_xml_attr_int(accessor, "count", count);
00400     add_xml_attr_int(accessor, "stride", 2);
00401 
00402     tXML* param_s = add_xml_node(accessor, "param");
00403     tXML* param_t = add_xml_node(accessor, "param");
00404     add_xml_attr_str(param_s, "name", "S");
00405     add_xml_attr_str(param_t, "name", "T");
00406     add_xml_attr_str(param_s, "type", "float");
00407     add_xml_attr_str(param_t, "type", "float");
00408 
00409     return;
00410 }

Here is the call graph for this function:

Here is the caller graph for this function:

char * addMaterial ( const char *  material  ) 

Definition at line 525 of file ColladaTool.cpp.

References _tochar, add_xml_attr_str(), add_xml_node(), Buffer::buf, cat_s2Buffer, ColladaXML::library_materials, and make_Buffer_str.

Referenced by ColladaXML::addPolylists().

00526 {
00527     if (material_id==NULL) return NULL;
00528 
00529     Buffer material_url = make_Buffer_str("#");
00530     cat_s2Buffer(material_id, &material_url);
00531     cat_s2Buffer("_URL", &material_url);
00532 
00533     tXML* material = add_xml_node(library_materials, "material");
00534     add_xml_attr_str(material, "id", material_id);
00535     tXML* instance_effect = add_xml_node(material, "instance_effect");
00536     add_xml_attr_str(instance_effect, "url", _tochar(material_url.buf));
00537 
00538     return _tochar(material_url.buf);
00539 }

Here is the call graph for this function:

Here is the caller graph for this function:

char * addNormalSource ( tXML *  mesh,
MeshObjectData *  meshdata 
)

Definition at line 251 of file ColladaTool.cpp.

References _tochar, add_xml_attr_int(), add_xml_attr_str(), add_xml_content_area(), add_xml_node(), ColladaXML::addPosTechniqueAccessor(), append_xml_content(), Buffer::buf, cat_Buffer(), dtostr(), free_Buffer(), make_Buffer_randomstr, make_Buffer_str, MeshObjectNode::next, MeshObjectData::nodelist, MeshObjectNode::normal_value, MeshObjectNode::num_vertex, and MeshObjectData::ttl_vertex.

Referenced by ColladaXML::addGeometry().

00252 {
00253     if (mesh==NULL || meshdata==NULL) return NULL;
00254 
00255     int vnum = meshdata->ttl_vertex;
00256     MeshObjectNode* node = meshdata->nodelist;
00257 
00258     Buffer randomstr = make_Buffer_randomstr(8);
00259     Buffer source_id = make_Buffer_str("#SOURCE_NORMAL_");
00260     Buffer source_array_id = make_Buffer_str("#SOURCE_NORMAL_ARRAY_");
00261     cat_Buffer(&randomstr, &source_id);
00262     cat_Buffer(&randomstr, &source_array_id);
00263 
00264     tXML* source = add_xml_node(mesh, "source");
00265     add_xml_attr_str(source, "id", _tochar(source_id.buf+1));
00266     tXML* source_array = add_xml_node(source, "float_array");
00267     add_xml_attr_str(source_array, "id", _tochar(source_array_id.buf+1));
00268     add_xml_attr_int(source_array, "count", vnum*3);                            // 3 -> X, Y, Z の次元数
00269     //
00270     if (add_xml_content_area(source_array, meshdata->ttl_vertex*10)) {
00271         while (node!=NULL) {
00272             Vector<double>* vect = node->normal_value;
00273             for (int i=0; i<node->num_vertex; i++) {
00274                 append_xml_content(source_array, dtostr(vect[i].x));
00275                 append_xml_content(source_array, dtostr(vect[i].y));
00276                 append_xml_content(source_array, dtostr(vect[i].z));
00277             }
00278             node = node->next;
00279         }
00280     }
00281     addPosTechniqueAccessor(source, _tochar(source_array_id.buf), vnum);
00282     
00283     free_Buffer(&randomstr);
00284     free_Buffer(&source_array_id);
00285 
00286     return _tochar(source_id.buf);
00287 }

Here is the call graph for this function:

Here is the caller graph for this function:

void addObject ( MeshObjectData *  meshdata,
bool  collider 
)

Definition at line 156 of file ColladaTool.cpp.

References ColladaXML::addGeometry(), ColladaXML::addScene(), and ColladaXML::free().

00157 {
00158     if (meshdata==NULL) return;
00159 
00160     char* geom_id = addGeometry(meshdata);
00161     if (geom_id==NULL) return;
00162 
00163     addScene(geom_id, meshdata, collider);
00164 
00165     ::free(geom_id);
00166     return;
00167 }

Here is the call graph for this function:

void addPolylists ( tXML *  mesh,
MeshObjectData *  meshdata,
const char *  vertex_id,
const char *  normal_id = NULL,
const char *  texcrd_id = NULL 
)

Definition at line 415 of file ColladaTool.cpp.

References _tochar, add_xml_attr_int(), add_xml_attr_str(), add_xml_content_area(), add_xml_node(), ColladaXML::addEffect(), ColladaXML::addExtraBumpmap(), ColladaXML::addImage(), ColladaXML::addMaterial(), append_xml_content(), Buffer::buf, MeshObjectNode::data_index, MaterialParam::enable, ColladaXML::existSameID(), ColladaXML::free(), MaterialParam::getBumpMapName(), MaterialParam::getTextureName(), itostr(), ColladaXML::library_materials, MeshObjectNode::material_id, MeshObjectNode::material_param, MeshObjectNode::next, MeshObjectData::nodelist, MeshObjectNode::num_polygon, MeshObjectData::num_vcount, MeshObjectNode::num_vertex, and MeshObjectNode::same_material.

Referenced by ColladaXML::addGeometry().

00416 {
00417     if (vertex_id==NULL || meshdata==NULL) return;
00418 
00419     int pnum = 0;
00420     MeshObjectNode* node = meshdata->nodelist;
00421 
00422     while (node!=NULL) {
00423         //
00424         tXML* polylist = add_xml_node(mesh, "polylist");
00425         add_xml_attr_int(polylist, "count", node->num_polygon);
00426 
00427         // Material
00428         if (node->material_param.enable && node->material_id.buf!=NULL) {
00429             //
00430             add_xml_attr_str(polylist, "material", _tochar(node->material_id.buf+1));
00431             if (!node->same_material) {
00432                 char* material = _tochar(node->material_id.buf+1);
00433                 bool exist_same_material = existSameID(library_materials, "<library_materials><material>", material);
00434                 if (!exist_same_material) { // 一番最初
00435                     char* material_url = addMaterial(_tochar(node->material_id.buf+1));
00436                     char* file_id = addImage(node->material_param.getTextureName());
00437                     tXML* profile = addEffect(material_url, file_id, node->material_param);
00438                     ::free(material_url);
00439                     ::free(file_id);
00440                     // Bumpmap
00441                     char* bump_id = addImage(node->material_param.getBumpMapName());
00442                     if (bump_id!=NULL) {
00443                         addExtraBumpmap(profile, bump_id);
00444                         ::free(bump_id);
00445                     }
00446                 }
00447             }
00448         }
00449 
00450         //
00451         tXML* vertex_input = add_xml_node(polylist, "input");
00452         add_xml_attr_str(vertex_input, "semantic", "VERTEX");
00453         add_xml_attr_str(vertex_input, "source", vertex_id);
00454         add_xml_attr_int(vertex_input, "offset", 0);
00455 
00456         if (normal_id!=NULL) {
00457             tXML* normal_input = add_xml_node(polylist, "input");
00458             add_xml_attr_str(normal_input, "semantic", "NORMAL");
00459             add_xml_attr_str(normal_input, "source", normal_id);
00460             add_xml_attr_int(normal_input, "offset", 0);
00461         }
00462     
00463         if (texcrd_id!=NULL) {
00464             tXML* normal_input = add_xml_node(polylist, "input");
00465             add_xml_attr_str(normal_input, "semantic", "TEXCOORD");
00466             add_xml_attr_str(normal_input, "source", texcrd_id);
00467             add_xml_attr_int(normal_input, "offset", 0);
00468         }
00469     
00470         tXML* vcount = add_xml_node(polylist, "vcount");
00471         if (add_xml_content_area(vcount, node->num_polygon*10)) {
00472             for (int i=0; i<node->num_polygon; i++) {
00473                 append_xml_content(vcount, itostr(meshdata->num_vcount));
00474             }
00475         }
00476 
00477         tXML* p_data = add_xml_node(polylist, "p");
00478         if (add_xml_content_area(p_data, meshdata->num_vcount*10)) {
00479             for (int i=0; i<node->num_polygon; i++) {
00480                 int n = i*meshdata->num_vcount;
00481                 for (int j=0; j<meshdata->num_vcount; j++) {
00482                     append_xml_content(p_data, itostr(node->data_index[n+j] + pnum));
00483                 }
00484                 append_xml_content(p_data, "");
00485             }
00486         }
00487 
00488         pnum += node->num_vertex;
00489         node = node->next;
00490     }
00491 
00492     return;
00493 }

Here is the call graph for this function:

Here is the caller graph for this function:

void addPosTechniqueAccessor ( tXML *  source,
const char *  source_array_id,
int  count 
)

Definition at line 367 of file ColladaTool.cpp.

References add_xml_attr_int(), add_xml_attr_str(), and add_xml_node().

Referenced by ColladaXML::addNormalSource(), and ColladaXML::addVertexSource().

00368 {
00369     if (source==NULL || source_array_id==NULL) return;
00370 
00371     tXML* technique_common = add_xml_node(source, "technique_common");
00372     tXML* accessor = add_xml_node(technique_common, "accessor");
00373     add_xml_attr_str(accessor, "source", source_array_id);
00374     add_xml_attr_int(accessor, "count", count);
00375     add_xml_attr_int(accessor, "stride", 3);
00376 
00377     tXML* param_x = add_xml_node(accessor, "param");
00378     tXML* param_y = add_xml_node(accessor, "param");
00379     tXML* param_z = add_xml_node(accessor, "param");
00380     add_xml_attr_str(param_x, "name", "X");
00381     add_xml_attr_str(param_y, "name", "Y");
00382     add_xml_attr_str(param_z, "name", "Z");
00383     add_xml_attr_str(param_x, "type", "float");
00384     add_xml_attr_str(param_y, "type", "float");
00385     add_xml_attr_str(param_z, "type", "float");
00386 
00387     return;
00388 }

Here is the call graph for this function:

Here is the caller graph for this function:

void addScene ( const char *  geometry_id,
MeshObjectData *  meshdata,
bool  collider 
)

Definition at line 706 of file ColladaTool.cpp.

References _tochar, add_xml_attr_str(), add_xml_content(), add_xml_node(), MeshObjectData::affine_trans, append_xml_content(), Buffer::buf, cat_Buffer(), AffineTrans< T >::computeMatrix(), MeshObjectData::data_name, dtostr(), dup_Buffer(), Matrix< T >::element(), AffineTrans< T >::free(), free_Buffer(), ColladaXML::instance_physics_model, make_Buffer_randomstr, make_Buffer_str, MeshObjectNode::material_id, AffineTrans< T >::matrix, MeshObjectNode::next, MeshObjectData::nodelist, ColladaXML::physics_model, MeshObjectNode::same_material, AffineTrans< T >::scale, ColladaXML::visual_scene, Vector< T >::x, Vector< T >::y, and Vector< T >::z.

Referenced by ColladaXML::addObject().

00707 {
00708     if (geometry_id==NULL || meshdata==NULL) return;
00709 
00710     bool local_affine = true;
00711     AffineTrans<double> affine;
00712     if (meshdata->affine_trans!=NULL) {
00713         local_affine = false;
00714         affine.free();
00715         affine = *(meshdata->affine_trans);
00716     }
00717 
00718     Buffer geometry_name = dup_Buffer(meshdata->data_name);
00719     if (geometry_name.buf==NULL) geometry_name = make_Buffer_str(geometry_id+1);
00720 
00721     //
00722     Buffer randomstr = make_Buffer_randomstr(8);
00723     Buffer node_id = make_Buffer_str("#NODE_");
00724     cat_Buffer(&randomstr, &node_id);
00725 
00726     tXML* nodetag = add_xml_node(visual_scene, "node");
00727     //add_xml_attr_str(nodetag, "id",   _tochar(node_id.buf));
00728     add_xml_attr_str(nodetag, "id",   _tochar(node_id.buf+1));
00729     add_xml_attr_str(nodetag, "name", _tochar(geometry_name.buf));
00730     add_xml_attr_str(nodetag, "type", "NODE");
00731 
00732     // Collider
00733     tXML* rigid_body = NULL;
00734     tXML* instance_rigid_body = NULL;
00735     if (collider) {
00736         rigid_body = add_xml_node(physics_model, "rigid_body");
00737         add_xml_attr_str(rigid_body, "sid",  _tochar(node_id.buf+1));
00738         add_xml_attr_str(rigid_body, "name", _tochar(geometry_name.buf));
00739         //
00740         instance_rigid_body = add_xml_node(instance_physics_model, "instance_rigid_body");
00741         add_xml_attr_str(instance_rigid_body, "body",   _tochar(node_id.buf+1));
00742         add_xml_attr_str(instance_rigid_body, "target", _tochar(node_id.buf));
00743     }
00744 
00745     free_Buffer(&randomstr);
00746     free_Buffer(&node_id);
00747 
00748     // 回転行列
00749     affine.computeMatrix(false);
00750     tXML* matrix = add_xml_node(nodetag, "matrix");
00751     for (int i=1; i<=4; i++) {
00752         for (int j=1; j<=4; j++) {
00753             append_xml_content(matrix, dtostr(affine.matrix.element(i,j)));
00754         }
00755     }
00756 
00757     // オイラー角
00758 /*
00759     tXML* translate = add_xml_node(nodetag, "translate");
00760     add_xml_attr_str(translate, "sid", "location");
00761     append_xml_content(translate, dtostr(affine.shift.x));
00762     append_xml_content(translate, dtostr(affine.shift.y));
00763     append_xml_content(translate, dtostr(affine.shift.z));
00764     //
00765     Vector<double> euler = affine.rotate.getEulerZYX();
00766     tXML* rotate_z = add_xml_node(nodetag, "rotate");
00767     add_xml_attr_str(rotate_z, "sid", "rotationZ");
00768     append_xml_content(rotate_z, "0 0 1");
00769     append_xml_content(rotate_z, dtostr(euler.x));
00770 
00771     tXML* rotate_y = add_xml_node(nodetag, "rotate");
00772     add_xml_attr_str(rotate_y, "sid", "rotationY");
00773     append_xml_content(rotate_y, "0 1 0");
00774     append_xml_content(rotate_y, dtostr(euler.y));
00775 
00776     tXML* rotate_x = add_xml_node(nodetag, "rotate");
00777     add_xml_attr_str(rotate_x, "sid", "rotationX");
00778     append_xml_content(rotate_x, "1 0 0");
00779     append_xml_content(rotate_x, dtostr(euler.z));
00780 */
00781     
00782     tXML* scale = add_xml_node(nodetag, "scale");
00783     add_xml_attr_str(scale, "sid", "scale");
00784     append_xml_content(scale, dtostr(affine.scale.x));
00785     append_xml_content(scale, dtostr(affine.scale.y));
00786     append_xml_content(scale, dtostr(affine.scale.z));
00787 
00788     tXML* instance = add_xml_node(nodetag, "instance_geometry");
00789     add_xml_attr_str(instance, "url", geometry_id);
00790 
00791     tXML* bind_material = add_xml_node(instance, "bind_material");
00792     tXML* technique_common = add_xml_node(bind_material, "technique_common");
00793     
00794     tXML* instance_material;
00795     MeshObjectNode* node = meshdata->nodelist;
00796     while(node!=NULL) {
00797         if (!node->same_material) {
00798             instance_material = add_xml_node(technique_common, "instance_material");
00799             add_xml_attr_str(instance_material, "symbol", _tochar(node->material_id.buf+1));
00800             add_xml_attr_str(instance_material, "target", _tochar(node->material_id.buf));
00801         }
00802         node = node->next;
00803     }
00804 
00805     // Collider: physics_model
00806     if (collider) {
00807         technique_common = add_xml_node(rigid_body, "technique_common");
00808         tXML* dynamic = add_xml_node(technique_common, "dynamic");
00809         tXML* mass    = add_xml_node(technique_common, "mass");
00810         add_xml_content(dynamic, "false");
00811         add_xml_content(mass, "0");
00812         tXML* shape   = add_xml_node(technique_common, "shape");
00813         instance      = add_xml_node(shape, "instance_geometry");
00814         add_xml_attr_str(instance, "url", geometry_id);
00815     }
00816 
00817     //
00818     free_Buffer(&geometry_name);
00819     if (local_affine) affine.free();
00820 
00821     return;
00822 }

Here is the call graph for this function:

Here is the caller graph for this function:

char * addTexcrdSource ( tXML *  mesh,
MeshObjectData *  meshdata 
)

Definition at line 293 of file ColladaTool.cpp.

References _tochar, add_xml_attr_int(), add_xml_attr_str(), add_xml_content_area(), add_xml_node(), ColladaXML::addMapTechniqueAccessor(), MeshObjectData::affine_trans, append_xml_content(), Buffer::buf, cat_Buffer(), dtostr(), MeshObjectNode::execAffineTrans(), ColladaXML::free(), free_Buffer(), MeshObjectNode::generatePlanarUVMap(), make_Buffer_randomstr, make_Buffer_str, MaterialParam::mapping, MATERIAL_MAPPING_PLANAR, MeshObjectNode::material_param, MeshObjectNode::next, MeshObjectData::nodelist, MeshObjectNode::num_texcrd, AffineTrans< T >::scale, MeshObjectNode::texcrd_value, MeshObjectData::ttl_texcrd, and MeshObjectData::ttl_vertex.

Referenced by ColladaXML::addGeometry().

00294 {
00295     if (mesh==NULL || meshdata==NULL) return NULL;
00296 
00297     int vnum = meshdata->ttl_vertex;
00298     MeshObjectNode* node = meshdata->nodelist;
00299 
00300     Buffer randomstr = make_Buffer_randomstr(8);
00301     Buffer source_id = make_Buffer_str("#SOURCE_MAP_");
00302     Buffer source_array_id = make_Buffer_str("#SOURCE_MAP_ARRAY_");
00303     cat_Buffer(&randomstr, &source_id);
00304     cat_Buffer(&randomstr, &source_array_id);
00305 
00306     tXML* source = add_xml_node(mesh, "source");
00307     add_xml_attr_str(source, "id", _tochar(source_id.buf+1));
00308     tXML* source_array = add_xml_node(source, "float_array");
00309     add_xml_attr_str(source_array, "id", _tochar(source_array_id.buf+1));
00310     add_xml_attr_int(source_array, "count", vnum*2);                            // 2 -> S,T (U, V) の次元数
00311     //
00312     if (add_xml_content_area(source_array, meshdata->ttl_texcrd*10)) {
00313         while (node!=NULL) {
00314             size_t len = node->num_texcrd*sizeof(UVMap<double>);
00315             UVMap<double>* uvmap = (UVMap<double>*)malloc(len);
00316             if (uvmap!=NULL) {
00317                 memcpy(uvmap, node->texcrd_value, len);
00318                 // PLANAR Texture
00319                 if (node->material_param.mapping==MATERIAL_MAPPING_PLANAR) {
00320                     Vector<double> scale(1.0, 1.0, 1.0);
00321                     if (meshdata->affine_trans!=NULL) scale = meshdata->affine_trans->scale;
00322                     node->generatePlanarUVMap(scale, uvmap);
00323                 }
00324                 node->execAffineTrans(uvmap, node->num_texcrd);
00325 
00326                 for (int i=0; i<node->num_texcrd; i++) {
00327                     append_xml_content(source_array, dtostr(uvmap[i].u));
00328                     append_xml_content(source_array, dtostr(uvmap[i].v));
00329                 }
00330                 ::free(uvmap);
00331             }
00332             node = node->next;
00333         }
00334     }
00335     addMapTechniqueAccessor(source, _tochar(source_array_id.buf), vnum);
00336     
00337     free_Buffer(&randomstr);
00338     free_Buffer(&source_array_id);
00339 
00340     return _tochar(source_id.buf);
00341 }

Here is the call graph for this function:

Here is the caller graph for this function:

char * addVertexSource ( tXML *  mesh,
MeshObjectData *  meshdata 
)

Definition at line 211 of file ColladaTool.cpp.

References _tochar, add_xml_attr_int(), add_xml_attr_str(), add_xml_content_area(), add_xml_node(), ColladaXML::addPosTechniqueAccessor(), append_xml_content(), Buffer::buf, cat_Buffer(), dtostr(), free_Buffer(), make_Buffer_randomstr, make_Buffer_str, MeshObjectNode::next, MeshObjectData::nodelist, MeshObjectNode::num_vertex, MeshObjectData::ttl_vertex, and MeshObjectNode::vertex_value.

Referenced by ColladaXML::addGeometry().

00212 {
00213     if (mesh==NULL || meshdata==NULL) return NULL;
00214 
00215     int vnum = meshdata->ttl_vertex;
00216     MeshObjectNode* node = meshdata->nodelist;
00217 
00218     Buffer randomstr = make_Buffer_randomstr(8);
00219     Buffer source_id = make_Buffer_str("#SOURCE_POS_");
00220     Buffer source_array_id = make_Buffer_str("#SOURCE_POS_ARRAY_");
00221     cat_Buffer(&randomstr, &source_id);
00222     cat_Buffer(&randomstr, &source_array_id);
00223 
00224     tXML* source = add_xml_node(mesh, "source");
00225     add_xml_attr_str(source, "id", _tochar(source_id.buf+1));
00226     tXML* source_array = add_xml_node(source, "float_array");
00227     add_xml_attr_str(source_array, "id", _tochar(source_array_id.buf+1));
00228     add_xml_attr_int(source_array, "count", vnum*3);                            // 3 -> X, Y, Z の次元数
00229     //
00230     if (add_xml_content_area(source_array, meshdata->ttl_vertex*10)) {
00231         while (node!=NULL) {
00232             Vector<double>* vect = node->vertex_value;
00233             for (int i=0; i<node->num_vertex; i++) {
00234                 append_xml_content(source_array, dtostr(vect[i].x));
00235                 append_xml_content(source_array, dtostr(vect[i].y));
00236                 append_xml_content(source_array, dtostr(vect[i].z));
00237             }
00238             node = node->next;
00239         }   
00240     }
00241     addPosTechniqueAccessor(source, _tochar(source_array_id.buf), vnum);
00242     
00243     free_Buffer(&randomstr);
00244     free_Buffer(&source_array_id);
00245 
00246     return _tochar(source_id.buf);
00247 }

Here is the call graph for this function:

Here is the caller graph for this function:

char * addVerticesPos ( tXML *  mesh,
const char *  position_id 
)

Definition at line 345 of file ColladaTool.cpp.

References _tochar, add_xml_attr_str(), add_xml_node(), Buffer::buf, cat_Buffer(), free_Buffer(), make_Buffer_randomstr, and make_Buffer_str.

Referenced by ColladaXML::addGeometry().

00346 {
00347     if (mesh==NULL || position_id==NULL) return NULL;
00348 
00349     Buffer randomstr = make_Buffer_randomstr(8);
00350     Buffer vertex_id = make_Buffer_str("#VERTEX_");
00351     cat_Buffer(&randomstr, &vertex_id);
00352 
00353     // Vertices
00354     tXML* vertices = add_xml_node(mesh, "vertices");
00355     add_xml_attr_str(vertices, "id", _tochar(vertex_id.buf+1));
00356     tXML* position_input = add_xml_node(vertices, "input");
00357     add_xml_attr_str(position_input, "semantic", "POSITION");
00358     add_xml_attr_str(position_input, "source", position_id);
00359 
00360     free_Buffer(&randomstr);
00361 
00362     return _tochar(vertex_id.buf);
00363 }

Here is the call graph for this function:

Here is the caller graph for this function:

void clear ( float  meter,
int  axis = COLLADA_Z_UP,
const char *  ver = NULL 
) [inline]

Definition at line 49 of file ColladaTool.h.

References ColladaXML::clear().

Referenced by ColladaXML::clear().

00049 { clear((double)meter, axis, ver); }

Here is the call graph for this function:

Here is the caller graph for this function:

void clear ( double  meter = 1.0,
int  axis = COLLADA_Z_UP,
const char *  ver = NULL 
)

Definition at line 45 of file ColladaTool.cpp.

References del_xml, ColladaXML::init(), and ColladaXML::xml.

00046 {
00047     del_xml(&xml);
00048     init(meter, axis, ver);
00049 }

Here is the call graph for this function:

bool existSameID ( tXML *  top,
const char *  tag,
const char *  id 
)

Definition at line 826 of file ColladaTool.cpp.

References _tochar, Buffer::buf, cat_s2Buffer, del_xml, free_Buffer(), get_xml_node_list(), make_Buffer_str, ColladaXML::xml, xml_get_node_attr(), and xml_parse().

Referenced by ColladaXML::addImage(), and ColladaXML::addPolylists().

00827 {
00828     bool ret = false;
00829 
00830     tXML* xml = xml_parse((char*)tag);
00831     tXML* lst = get_xml_node_list(top, xml);
00832 
00833     Buffer cmpid = make_Buffer_str("\"");
00834     cat_s2Buffer(id, &cmpid);
00835     cat_s2Buffer("\"", &cmpid);
00836 
00837     while (lst!=NULL) {
00838         char* attr_id = xml_get_node_attr(lst->altp, "id");
00839         if (!strcmp(attr_id, _tochar(cmpid.buf))) {
00840             ret = true;
00841             break;
00842         }
00843         lst = lst->next;
00844     }
00845 
00846     del_xml(&xml);
00847     del_xml(&lst);
00848     free_Buffer(&cmpid);
00849 
00850     return ret;
00851 }

Here is the call graph for this function:

Here is the caller graph for this function:

void free ( void   ) 

Definition at line 37 of file ColladaTool.cpp.

References ColladaXML::blank_texture, del_xml, free_Buffer(), and ColladaXML::xml.

Referenced by ColladaXML::addObject(), ColladaXML::addPolylists(), ColladaXML::addTexcrdSource(), jbxl::freeColladaXML(), ColladaXML::initCollada(), and ColladaXML::outputFile().

00038 {
00039     free_Buffer(&blank_texture);
00040     del_xml(&xml);
00041 }

Here is the call graph for this function:

Here is the caller graph for this function:

void init ( float  meter,
int  axis = COLLADA_Z_UP,
const char *  ver = NULL 
) [inline]

Definition at line 47 of file ColladaTool.h.

References ColladaXML::init().

Referenced by ColladaXML::init().

00047 { init((double)meter, axis, ver); }

Here is the call graph for this function:

Here is the caller graph for this function:

void init ( double  meter = 1.0,
int  axis = COLLADA_Z_UP,
const char *  ver = NULL 
)

Definition at line 26 of file ColladaTool.cpp.

References ColladaXML::blank_texture, ColladaXML::forUnity3D, init_Buffer(), and ColladaXML::initCollada().

Referenced by ColladaXML::clear(), and ColladaXML::ColladaXML().

00027 {
00028     initCollada(meter, axis, ver);
00029     blank_texture = init_Buffer();
00030 
00031     forUnity3D = false;
00032 }

Here is the call graph for this function:

Here is the caller graph for this function:

void initCollada ( float  meter,
int  axis,
const char *  ver 
) [inline]

Definition at line 57 of file ColladaTool.h.

References ColladaXML::initCollada().

Referenced by ColladaXML::initCollada().

00057 { initCollada((double)meter, axis, ver); }

Here is the call graph for this function:

Here is the caller graph for this function:

void initCollada ( double  meter,
int  axis,
const char *  ver 
)

Definition at line 67 of file ColladaTool.cpp.

References _tochar, add_xml_attr_float(), add_xml_attr_str(), add_xml_content(), add_xml_node(), ColladaXML::asset, ColladaXML::author, ColladaXML::authoring_tool, Buffer::buf, ColladaXML::collada, COLLADA_STR_AUTHOR, COLLADA_STR_TOOL, COLLADA_STR_XMLNS, COLLADA_X_UP, COLLADA_Y_UP, ColladaXML::contributor, ColladaXML::created, ColladaXML::free(), free_Buffer(), get_local_timestamp(), init_xml_doc(), ColladaXML::instance_physics_model, ColladaXML::instance_physics_scene, ColladaXML::instance_visual_scene, ColladaXML::library_effects, ColladaXML::library_geometries, ColladaXML::library_images, ColladaXML::library_materials, ColladaXML::library_physics_models, ColladaXML::library_physics_scenes, ColladaXML::library_visual_scenes, make_Buffer_str, ColladaXML::modified, ColladaXML::physics_model, ColladaXML::physics_scene, ColladaXML::scene, ColladaXML::unit, ColladaXML::up_axis, ColladaXML::visual_scene, and ColladaXML::xml.

Referenced by ColladaXML::init().

00068 {
00069     Buffer buf;
00070     if (ver!=NULL) buf = make_Buffer_str(ver);
00071     else           buf = make_Buffer_str("1.4.1");
00072 
00073     // COLLADA
00074     xml     = init_xml_doc();
00075     collada = add_xml_node(xml, "COLLADA");
00076     //
00077     add_xml_attr_str(collada, "xmlns",   COLLADA_STR_XMLNS);
00078     add_xml_attr_str(collada, "version", _tochar(buf.buf));
00079 
00080     // asset
00081     asset          = add_xml_node(collada, "asset");
00082     contributor    = add_xml_node(asset, "contributor");
00083     author         = add_xml_node(contributor, "author");
00084     authoring_tool = add_xml_node(contributor, "authoring_tool");
00085     created        = add_xml_node(asset, "created");
00086     modified       = add_xml_node(asset, "modified");
00087     unit           = add_xml_node(asset, "unit");
00088     up_axis        = add_xml_node(asset, "up_axis");
00089     
00090     //char* ltime = get_localtime('-', 'T', ':', 'Z');
00091     char* ltime = get_local_timestamp(time(0), "%Y-%m-%dT%H:%M:%SZ");
00092     //
00093     add_xml_content(author, COLLADA_STR_AUTHOR);
00094     add_xml_content(authoring_tool, COLLADA_STR_TOOL);
00095     add_xml_content(created,  ltime);
00096     add_xml_content(modified, ltime);
00097     add_xml_attr_str(unit, "name", "meter");
00098     add_xml_attr_float(unit, "meter", (float)meter);
00099     ::free(ltime);
00100 
00101     if      (axis==COLLADA_X_UP) add_xml_content(up_axis, "X_UP");
00102     else if (axis==COLLADA_Y_UP) add_xml_content(up_axis, "Y_UP");
00103     else                         add_xml_content(up_axis, "Z_UP");
00104 
00105     // library_images
00106     library_images = add_xml_node(collada, "library_images");
00107 
00108     // library_materials
00109     library_materials = add_xml_node(collada, "library_materials");
00110 
00111     // library_geometries
00112     library_geometries = add_xml_node(collada, "library_geometries");
00113 
00114     // library_effects
00115     library_effects = add_xml_node(collada, "library_effects");
00116 
00117     // library_materials
00118     //library_materials = add_xml_node(collada, "library_materials");
00119 
00120     // library_physics_models
00121     library_physics_models = add_xml_node(collada, "library_physics_models");
00122     physics_model          = add_xml_node(library_physics_models, "physics_model");
00123     add_xml_attr_str(physics_model, "id",   "Physics_Model");
00124     add_xml_attr_str(physics_model, "name", "Physics_Model");
00125 
00126     // library_physics_scenes
00127     library_physics_scenes = add_xml_node(collada, "library_physics_scenes");
00128     physics_scene          = add_xml_node(library_physics_scenes, "physics_scene");
00129     add_xml_attr_str(physics_scene, "id",   "Physics_Scene");
00130     add_xml_attr_str(physics_scene, "name", "Physics_Scene");
00131     instance_physics_model = add_xml_node(physics_scene, "instance_physics_model");
00132     add_xml_attr_str(instance_physics_model, "url", "#Physics_Model");
00133     //tXML* technique = add_xml_node(physics_scene, "technique_common");
00134     //tXML* gravity = add_xml_node(technique, "gravity");
00135     //add_xml_content(gravity, "0.000000 -9.810000 0.000000");
00136 
00137     // library_visual_scenes
00138     library_visual_scenes = add_xml_node(collada, "library_visual_scenes");
00139     visual_scene          = add_xml_node(library_visual_scenes, "visual_scene");
00140     add_xml_attr_str(visual_scene, "id",   "Scene");
00141     add_xml_attr_str(visual_scene, "name", "Scene");
00142 
00143     // scence
00144     scene = add_xml_node(collada, "scene");
00145     instance_physics_scene = add_xml_node(scene, "instance_physics_scene");
00146     add_xml_attr_str(instance_physics_scene, "url", "#Physics_Scene");
00147     instance_visual_scene = add_xml_node(scene, "instance_visual_scene");
00148     add_xml_attr_str(instance_visual_scene, "url", "#Scene");
00149 
00150     //
00151     free_Buffer(&buf);
00152 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool isBlankTexture ( const char *  name  ) 

Definition at line 53 of file ColladaTool.cpp.

References _tochar, ColladaXML::blank_texture, Buffer::buf, and strncasecmp.

Referenced by ColladaXML::addEffect().

00054 {
00055     if (blank_texture.buf==NULL) return false;
00056     if (strncasecmp(_tochar(blank_texture.buf), name, strlen(_tochar(blank_texture.buf)))) return false;
00057 
00058     return true;
00059 }

Here is the caller graph for this function:

void outputFile ( const char *  fn,
const char *  path = NULL,
int  mode = XML_INDENT_FORMAT 
)

Definition at line 855 of file ColladaTool.cpp.

References Buffer::buf, cat_Buffer(), change_file_extension_Buffer(), ColladaXML::free(), free_Buffer(), get_file_name(), make_Buffer_bystr, pack_head_tail_char(), ColladaXML::print(), and rewrite_sBuffer_bystr().

00856 {
00857     char* packname = pack_head_tail_char(get_file_name(fname), ' ');
00858     Buffer file_name = make_Buffer_bystr(packname);
00859     ::free(packname);
00860 
00861     rewrite_sBuffer_bystr(&file_name, ":", "_");
00862     rewrite_sBuffer_bystr(&file_name, "*", "_");
00863     rewrite_sBuffer_bystr(&file_name, "?", "_");
00864     rewrite_sBuffer_bystr(&file_name, "\"", "_");
00865     rewrite_sBuffer_bystr(&file_name, "<", "_");
00866     rewrite_sBuffer_bystr(&file_name, ">", "_");
00867     if (file_name.buf[0]=='.') file_name.buf[0] = '_';
00868     //
00869     Buffer out_path;
00870     if (path==NULL) out_path = make_Buffer_bystr("./");
00871     else            out_path = make_Buffer_bystr(path);
00872     cat_Buffer(&file_name, &out_path);
00873     change_file_extension_Buffer(&out_path, ".dae");
00874     //
00875     FILE* fp = fopen((char*)out_path.buf, "wb");
00876     if (fp!=NULL) {
00877         print(fp, mode);
00878         fclose(fp);
00879     }
00880     free_Buffer(&file_name);
00881     free_Buffer(&out_path);
00882 
00883     return;
00884 }

Here is the call graph for this function:

void print ( FILE *  fp,
int  mode = XML_INDENT_FORMAT 
) [inline]

Definition at line 52 of file ColladaTool.h.

References print_xml(), and ColladaXML::xml.

Referenced by ColladaXML::outputFile().

00052 { print_xml(fp, xml, mode);}

Here is the call graph for this function:

Here is the caller graph for this function:

void print_tree ( FILE *  fp  )  [inline]

Definition at line 53 of file ColladaTool.h.

References print_xml_tree(), and ColladaXML::xml.

00053 { print_xml_tree(fp, xml, "    ");}

Here is the call graph for this function:

void setBlankTexture ( const char *  name  )  [inline]

Definition at line 79 of file ColladaTool.h.

References ColladaXML::blank_texture, and make_Buffer_bystr.

00079 { if(name!=NULL) blank_texture = make_Buffer_bystr(name);}

Member Data Documentation

tXML* asset

Definition at line 95 of file ColladaTool.h.

Referenced by ColladaXML::initCollada().

tXML* author

Definition at line 97 of file ColladaTool.h.

Referenced by ColladaXML::initCollada().

tXML* authoring_tool

Definition at line 98 of file ColladaTool.h.

Referenced by ColladaXML::initCollada().

Buffer blank_texture

Definition at line 122 of file ColladaTool.h.

Referenced by ColladaXML::free(), ColladaXML::init(), ColladaXML::isBlankTexture(), and ColladaXML::setBlankTexture().

tXML* collada

Definition at line 93 of file ColladaTool.h.

Referenced by ColladaXML::initCollada().

tXML* contributor

Definition at line 96 of file ColladaTool.h.

Referenced by ColladaXML::initCollada().

tXML* created

Definition at line 99 of file ColladaTool.h.

Referenced by ColladaXML::initCollada().

bool forUnity3D

Definition at line 85 of file ColladaTool.h.

Referenced by ColladaXML::addEffect(), and ColladaXML::init().

tXML* instance_physics_model

Definition at line 112 of file ColladaTool.h.

Referenced by ColladaXML::addScene(), and ColladaXML::initCollada().

tXML* instance_physics_scene

Definition at line 120 of file ColladaTool.h.

Referenced by ColladaXML::initCollada().

tXML* instance_visual_scene

Definition at line 119 of file ColladaTool.h.

Referenced by ColladaXML::initCollada().

tXML* library_effects

Definition at line 106 of file ColladaTool.h.

Referenced by ColladaXML::addEffect(), and ColladaXML::initCollada().

tXML* library_geometries

Definition at line 105 of file ColladaTool.h.

Referenced by ColladaXML::addGeometry(), and ColladaXML::initCollada().

tXML* library_images

Definition at line 104 of file ColladaTool.h.

Referenced by ColladaXML::addImage(), and ColladaXML::initCollada().

tXML* library_materials

Definition at line 107 of file ColladaTool.h.

Referenced by ColladaXML::addMaterial(), ColladaXML::addPolylists(), and ColladaXML::initCollada().

tXML* library_physics_models

Definition at line 110 of file ColladaTool.h.

Referenced by ColladaXML::initCollada().

tXML* library_physics_scenes

Definition at line 109 of file ColladaTool.h.

Referenced by ColladaXML::initCollada().

tXML* library_visual_scenes

Definition at line 108 of file ColladaTool.h.

Referenced by ColladaXML::initCollada().

tXML* modified

Definition at line 100 of file ColladaTool.h.

Referenced by ColladaXML::initCollada().

tXML* physics_model

Definition at line 116 of file ColladaTool.h.

Referenced by ColladaXML::addScene(), and ColladaXML::initCollada().

tXML* physics_scene

Definition at line 115 of file ColladaTool.h.

Referenced by ColladaXML::initCollada().

tXML* scene

Definition at line 118 of file ColladaTool.h.

Referenced by ColladaXML::initCollada().

tXML* unit

Definition at line 101 of file ColladaTool.h.

Referenced by ColladaXML::initCollada().

tXML* up_axis

Definition at line 102 of file ColladaTool.h.

Referenced by ColladaXML::initCollada().

tXML* visual_scene

Definition at line 114 of file ColladaTool.h.

Referenced by ColladaXML::addCenterScene(), ColladaXML::addScene(), and ColladaXML::initCollada().

tXML* xml

Definition at line 92 of file ColladaTool.h.

Referenced by ColladaXML::clear(), ColladaXML::existSameID(), ColladaXML::free(), ColladaXML::initCollada(), ColladaXML::print(), and ColladaXML::print_tree().

The documentation for this class was generated from the following files:
Generated on 15 Nov 2023 for JunkBox_Lib++ (for Windows) by  doxygen 1.6.1