Panda3D
 All Classes Functions Variables Enumerations
eggToFlt.cxx
00001 // Filename: eggToFlt.cxx
00002 // Created by:  drose (01Oct03)
00003 //
00004 ////////////////////////////////////////////////////////////////////
00005 //
00006 // PANDA 3D SOFTWARE
00007 // Copyright (c) Carnegie Mellon University.  All rights reserved.
00008 //
00009 // All use of this software is subject to the terms of the revised BSD
00010 // license.  You should have received a copy of this license along
00011 // with this source code in a file named "LICENSE."
00012 //
00013 ////////////////////////////////////////////////////////////////////
00014 
00015 #include "eggToFlt.h"
00016 #include "fltHeader.h"
00017 #include "fltBead.h"
00018 #include "fltGroup.h"
00019 #include "fltFace.h"
00020 #include "fltVertexList.h"
00021 #include "fltVertex.h"
00022 #include "fltTexture.h"
00023 #include "fltTransformTranslate.h"
00024 #include "fltTransformRotateAboutEdge.h"
00025 #include "fltTransformScale.h"
00026 #include "fltTransformGeneralMatrix.h"
00027 #include "eggPolygon.h"
00028 #include "eggPoint.h"
00029 #include "eggPrimitive.h"
00030 #include "eggExternalReference.h"
00031 #include "eggGroup.h"
00032 #include "eggGroupNode.h"
00033 #include "eggTexture.h"
00034 #include "eggTransform.h"
00035 #include "dcast.h"
00036 #include "string_utils.h"
00037 #include "vector_string.h"
00038 #include "pystub.h"
00039 
00040 ////////////////////////////////////////////////////////////////////
00041 //     Function: EggToFlt::Constructor
00042 //       Access: Public
00043 //  Description: 
00044 ////////////////////////////////////////////////////////////////////
00045 EggToFlt::
00046 EggToFlt() :
00047   EggToSomething("MultiGen", ".flt", true, false)
00048 {
00049   set_binary_output(true);
00050   set_program_description
00051     ("egg2lt converts files from egg format to MultiGen .flt "
00052      "format.  It attempts to be as robust as possible, and matches "
00053      "the capabilities of flt2egg.  Generally, converting a model "
00054      "from egg2lt and then back via flt2egg will result in essentially "
00055      "the same egg file, within the limitations of what can be "
00056      "represented in flt.");
00057 
00058   add_option
00059     ("attr", "none/new/all", 0,
00060      "Specifies whether to write (or rewrite) .attr files for each "
00061      "texture image.  MultiGen stores texture properties like mipmapping "
00062      "in a separate .attr file for each different texture image.  "
00063      "If this parameter is \"none\", these files will not be generated; "
00064      "if this is \"new\", these files will only be generated if they "
00065      "do not already exist (even if the properties have changed).  "
00066      "Specifying \"all\" causes these to be rewritten every time.",
00067      &EggToFlt::dispatch_attr, NULL, &_auto_attr_update);
00068 
00069   // Flt files are always in the z-up coordinate system.  Don't
00070   // confuse the user with this meaningless option.
00071   remove_option("cs");
00072   _coordinate_system = CS_zup_right;
00073   _got_coordinate_system = true;
00074   _auto_attr_update = FltHeader::AU_if_missing;
00075 }
00076 
00077 ////////////////////////////////////////////////////////////////////
00078 //     Function: EggToFlt::run
00079 //       Access: Public
00080 //  Description:
00081 ////////////////////////////////////////////////////////////////////
00082 void EggToFlt::
00083 run() {
00084   _flt_header = new FltHeader(_path_replace);
00085   _flt_header->set_auto_attr_update(_auto_attr_update);
00086 
00087   traverse(_data, _flt_header, FltGeometry::BT_none);
00088 
00089   // Finally, write the resulting file out.
00090   FltError result = _flt_header->write_flt(get_output());
00091   if (result != FE_ok) {
00092     nout << "Cannot write " << get_output_filename() << "\n";
00093     exit(1);
00094   }
00095 }
00096 
00097 ////////////////////////////////////////////////////////////////////
00098 //     Function: EggToFlt::dispatch_attr
00099 //       Access: Protected, Static
00100 //  Description: Dispatch function for the -attr parameter.
00101 ////////////////////////////////////////////////////////////////////
00102 bool EggToFlt::
00103 dispatch_attr(const string &opt, const string &arg, void *var) {
00104   FltHeader::AttrUpdate *ip = (FltHeader::AttrUpdate *)var;
00105 
00106   if (cmp_nocase(arg, "none") == 0) {
00107     *ip = FltHeader::AU_none;
00108 
00109   } else if (cmp_nocase(arg, "new") == 0) {
00110     *ip = FltHeader::AU_if_missing;
00111 
00112   } else if (cmp_nocase(arg, "all") == 0) {
00113     *ip = FltHeader::AU_always;
00114 
00115   } else {
00116     nout << "-" << opt
00117          << " requires either \"none\", \"new\", or \"all\".\n";
00118     return false;
00119   }
00120    
00121   return true;
00122 }
00123 
00124 ////////////////////////////////////////////////////////////////////
00125 //     Function: EggToFlt::traverse
00126 //       Access: Private
00127 //  Description:
00128 ////////////////////////////////////////////////////////////////////
00129 void EggToFlt::
00130 traverse(EggNode *egg_node, FltBead *flt_node, 
00131          FltGeometry::BillboardType billboard) {
00132   if (egg_node->is_of_type(EggPolygon::get_class_type()) ||
00133       egg_node->is_of_type(EggPoint::get_class_type())) {
00134     // It's a polygon or point light.
00135     EggPrimitive *egg_primitive = DCAST(EggPrimitive, egg_node);
00136     convert_primitive(egg_primitive, flt_node, billboard);
00137 
00138   } else if (egg_node->is_of_type(EggExternalReference::get_class_type())) {
00139     // Convert external references.
00140 
00141   } else if (egg_node->is_of_type(EggGroup::get_class_type())) {
00142     // An EggGroup creates a fltBead, and recurses.
00143     EggGroup *egg_group = DCAST(EggGroup, egg_node);
00144 
00145     if (egg_group->get_group_type() == EggGroup::GT_joint) {
00146       // Ignore joints and their children.
00147       return;
00148     }
00149 
00150     convert_group(egg_group, flt_node, billboard);
00151 
00152   } else if (egg_node->is_of_type(EggGroupNode::get_class_type())) {
00153     // Some kind of grouping node other than an EggGroup.  Just recurse.
00154     EggGroupNode *egg_group = DCAST(EggGroupNode, egg_node);
00155     EggGroupNode::iterator ci;
00156     for (ci = egg_group->begin(); ci != egg_group->end(); ++ci) {
00157       traverse(*ci, flt_node, billboard);
00158     }
00159   }
00160 }
00161 
00162 ////////////////////////////////////////////////////////////////////
00163 //     Function: EggToFlt::convert_primitive
00164 //       Access: Private
00165 //  Description: Converts an egg polygon or series of light points to
00166 //               the corresponding Flt geometry, and adds it to the
00167 //               indicated flt_node.
00168 ////////////////////////////////////////////////////////////////////
00169 void EggToFlt::
00170 convert_primitive(EggPrimitive *egg_primitive, FltBead *flt_node,
00171                   FltGeometry::BillboardType billboard) {
00172   FltFace *flt_face = new FltFace(_flt_header);
00173   flt_node->add_child(flt_face);
00174 
00175   flt_face->_billboard_type = billboard;
00176 
00177   if (egg_primitive->has_color()) {
00178     flt_face->set_color(egg_primitive->get_color());
00179   }
00180 
00181   if (egg_primitive->is_of_type(EggPoint::get_class_type())) {
00182     // A series of points, instead of a polygon.
00183     flt_face->_draw_type = FltFace::DT_omni_light;
00184       
00185   } else if (egg_primitive->get_bface_flag()) {
00186     // A polygon whose backface is visible.
00187     flt_face->_draw_type = FltFace::DT_solid_no_cull;
00188       
00189   } else {
00190     // A normal polygon.
00191     flt_face->_draw_type = FltFace::DT_solid_cull_backface;
00192   }
00193 
00194   if (egg_primitive->has_texture()) {
00195     EggTexture *egg_texture = egg_primitive->get_texture();
00196     FltTexture *flt_texture = get_flt_texture(egg_texture);
00197     flt_face->set_texture(flt_texture);
00198   }
00199 
00200   // Create a vertex list representing the vertices in the
00201   // primitive, and add it as a child of the face bead.  This is how
00202   // Flt files associate vertices with faces.
00203   FltVertexList *flt_vertices = new FltVertexList(_flt_header);
00204   flt_face->add_child(flt_vertices);
00205 
00206   EggPrimitive::iterator vi;
00207   bool all_verts_have_color = true;
00208   bool all_verts_have_normal = true;
00209   for (vi = egg_primitive->begin(); vi != egg_primitive->end(); ++vi) {
00210     EggVertex *egg_vertex = (*vi);
00211     FltVertex *flt_vertex = get_flt_vertex(egg_vertex, egg_primitive);
00212     flt_vertices->add_vertex(flt_vertex);
00213 
00214     if (!egg_vertex->has_color()) {
00215       all_verts_have_color = false;
00216     }
00217     if (!egg_vertex->has_normal()) {
00218       all_verts_have_normal = false;
00219     }
00220   }
00221   if (all_verts_have_color) {
00222     // If all the vertices of the face have a color specification,
00223     // then we specify per-vertex color on the face.
00224     if (all_verts_have_normal) {
00225       // And similarly with the normals.
00226       flt_face->_light_mode = FltFace::LM_vertex_with_normal;
00227     } else {
00228       flt_face->_light_mode = FltFace::LM_vertex_no_normal;
00229     }
00230   } else {
00231     if (all_verts_have_normal) {
00232       flt_face->_light_mode = FltFace::LM_face_with_normal;
00233     } else {
00234       flt_face->_light_mode = FltFace::LM_face_no_normal;
00235     }
00236   }
00237 }
00238 
00239 ////////////////////////////////////////////////////////////////////
00240 //     Function: EggToFlt::convert_group
00241 //       Access: Private
00242 //  Description: Converts an egg group to the corresponding flt group,
00243 //              and adds it to the indicated parent node.  Also
00244 //              recurses on the children of the egg group.
00245 ////////////////////////////////////////////////////////////////////
00246 void EggToFlt::
00247 convert_group(EggGroup *egg_group, FltBead *flt_node, 
00248               FltGeometry::BillboardType billboard) {
00249   ostringstream egg_syntax;
00250 
00251   FltGroup *flt_group = new FltGroup(_flt_header);
00252   flt_node->add_child(flt_group);
00253   
00254   flt_group->set_id(egg_group->get_name());
00255 
00256   switch (egg_group->get_billboard_type()) {
00257     // MultiGen represents billboarding at the polygon level, so we
00258     // have to remember this flag for later.
00259   case EggGroup::BT_axis:
00260     billboard = FltGeometry::BT_axial;
00261     break;
00262 
00263   case EggGroup::BT_point_world_relative:
00264     billboard = FltGeometry::BT_point;
00265     break;
00266 
00267   case EggGroup::BT_point_camera_relative:
00268     // Not sure if this is the right flag for MultiGen.
00269     billboard = FltGeometry::BT_fixed;
00270     break;
00271 
00272   default:
00273     break;
00274   }
00275   
00276   if (egg_group->has_transform()) {
00277     apply_transform(egg_group, flt_group);
00278   }
00279   
00280   if (egg_group->get_switch_flag()) {
00281     if (egg_group->get_switch_fps() != 0.0) {
00282       // A sequence animation.
00283       flt_group->_flags |= FltGroup::F_forward_animation;
00284       egg_syntax
00285         << "  <Scalar> fps { " << egg_group->get_switch_fps() << " }\n";
00286     } else {
00287       // Just a switch node.
00288       egg_group->write_switch_flags(egg_syntax, 2);
00289     }
00290   }
00291 
00292   // Pick up any additional egg attributes that MultiGen doesn't
00293   // support; these will get written to the comment field where
00294   // flt2egg will find it.
00295   egg_group->write_collide_flags(egg_syntax, 2);
00296   egg_group->write_model_flags(egg_syntax, 2);
00297   egg_group->write_object_types(egg_syntax, 2);
00298   egg_group->write_decal_flags(egg_syntax, 2);
00299   egg_group->write_tags(egg_syntax, 2);
00300   egg_group->write_render_mode(egg_syntax, 2);
00301 
00302   apply_egg_syntax(egg_syntax.str(), flt_group);
00303   
00304   EggGroup::iterator ci;
00305   for (ci = egg_group->begin(); ci != egg_group->end(); ++ci) {
00306     traverse(*ci, flt_group, billboard);
00307   }
00308 }
00309 
00310 ////////////////////////////////////////////////////////////////////
00311 //     Function: EggToFlt::apply_transform
00312 //       Access: Private
00313 //  Description: Applies the indicated egg transform to the indicated
00314 //               flt bead.
00315 ////////////////////////////////////////////////////////////////////
00316 void EggToFlt::
00317 apply_transform(EggTransform *egg_transform, FltBead *flt_node) {
00318   flt_node->clear_transform();
00319 
00320   bool components_ok = true;
00321   int num_components = egg_transform->get_num_components();
00322   for (int i = num_components - 1; i >= 0 && components_ok; i--) {
00323     switch (egg_transform->get_component_type(i)) {
00324     case EggTransform::CT_translate2d:
00325       {
00326         FltTransformTranslate *translate = 
00327           new FltTransformTranslate(_flt_header);
00328         LVector2d v2 = egg_transform->get_component_vec2(i);
00329         translate->set(LPoint3d::zero(), LVector3d(v2[0], v2[1], 0.0));
00330         flt_node->add_transform_step(translate);
00331       }
00332       break;
00333 
00334     case EggTransform::CT_translate3d:
00335       {
00336         FltTransformTranslate *translate = 
00337           new FltTransformTranslate(_flt_header);
00338         translate->set(LPoint3d::zero(), egg_transform->get_component_vec3(i));
00339         flt_node->add_transform_step(translate);
00340       }
00341       break;
00342 
00343     case EggTransform::CT_rotate2d:
00344       {
00345         FltTransformRotateAboutEdge *rotate = 
00346           new FltTransformRotateAboutEdge(_flt_header);
00347         rotate->set(LPoint3d::zero(), LPoint3d(0.0, 0.0, 1.0),
00348                     egg_transform->get_component_number(i));
00349         flt_node->add_transform_step(rotate);
00350       }
00351       break;
00352 
00353     case EggTransform::CT_rotx:
00354       {
00355         FltTransformRotateAboutEdge *rotate = 
00356           new FltTransformRotateAboutEdge(_flt_header);
00357         rotate->set(LPoint3d::zero(), LPoint3d(1.0, 0.0, 0.0),
00358                     egg_transform->get_component_number(i));
00359         flt_node->add_transform_step(rotate);
00360       }
00361       break;
00362 
00363     case EggTransform::CT_roty:
00364       {
00365         FltTransformRotateAboutEdge *rotate = 
00366           new FltTransformRotateAboutEdge(_flt_header);
00367         rotate->set(LPoint3d::zero(), LPoint3d(0.0, 1.0, 0.0),
00368                     egg_transform->get_component_number(i));
00369         flt_node->add_transform_step(rotate);
00370       }
00371       break;
00372 
00373     case EggTransform::CT_rotz:
00374       {
00375         FltTransformRotateAboutEdge *rotate = 
00376           new FltTransformRotateAboutEdge(_flt_header);
00377         rotate->set(LPoint3d::zero(), LPoint3d(0.0, 0.0, 1.0),
00378                     egg_transform->get_component_number(i));
00379         flt_node->add_transform_step(rotate);
00380       }
00381       break;
00382 
00383     case EggTransform::CT_rotate3d:
00384       {
00385         FltTransformRotateAboutEdge *rotate = 
00386           new FltTransformRotateAboutEdge(_flt_header);
00387         rotate->set(LPoint3d::zero(), egg_transform->get_component_vec3(i),
00388                     egg_transform->get_component_number(i));
00389         flt_node->add_transform_step(rotate);
00390       }
00391       break;
00392 
00393     case EggTransform::CT_scale2d:
00394       {
00395         FltTransformScale *scale = new FltTransformScale(_flt_header);
00396         LVector2d v2 = egg_transform->get_component_vec2(i);
00397         scale->set(LPoint3d::zero(), LVector3(v2[0], v2[1], 1.0f));
00398         flt_node->add_transform_step(scale);
00399       }
00400       break;
00401 
00402     case EggTransform::CT_scale3d:
00403       {
00404         FltTransformScale *scale = new FltTransformScale(_flt_header);
00405         scale->set(LPoint3d::zero(), LCAST(PN_stdfloat, egg_transform->get_component_vec3(i)));
00406         flt_node->add_transform_step(scale);
00407       }
00408       break;
00409 
00410     case EggTransform::CT_uniform_scale:
00411       {
00412         FltTransformScale *scale = new FltTransformScale(_flt_header);
00413         PN_stdfloat factor = (PN_stdfloat)egg_transform->get_component_number(i);
00414         scale->set(LPoint3d::zero(), LVecBase3(factor, factor, factor));
00415         flt_node->add_transform_step(scale);
00416       }
00417       break;
00418 
00419     case EggTransform::CT_matrix3:
00420       {
00421         FltTransformGeneralMatrix *matrix = 
00422           new FltTransformGeneralMatrix(_flt_header);
00423         const LMatrix3d &m = egg_transform->get_component_mat3(i);
00424         LMatrix4d mat4(m(0, 0), m(0, 1), 0.0, m(0, 2),
00425                        m(1, 0), m(1, 1), 0.0, m(1, 2),
00426                        0.0, 0.0, 1.0, 0.0,
00427                        m(2, 0), m(2, 1), 0.0, m(2, 2));
00428         matrix->set_matrix(mat4);
00429         flt_node->add_transform_step(matrix);
00430       }
00431       break;
00432 
00433     case EggTransform::CT_matrix4:
00434       {
00435         FltTransformGeneralMatrix *matrix = 
00436           new FltTransformGeneralMatrix(_flt_header);
00437         matrix->set_matrix(egg_transform->get_component_mat4(i));
00438         flt_node->add_transform_step(matrix);
00439       }
00440       break;
00441 
00442     default:
00443       // Don't know how to convert this component.
00444       components_ok = false;
00445     }
00446   }
00447 
00448   if (components_ok) {
00449     // Verify that the transform was computed correctly.
00450     if (!flt_node->get_transform().almost_equal(egg_transform->get_transform3d())) {
00451       nout << "Incorrect transform!  Expected:\n";
00452       egg_transform->get_transform3d().write(nout, 2);
00453       nout << "Computed:\n";
00454       flt_node->get_transform().write(nout, 2);
00455       nout << "\n";
00456       components_ok = false;
00457     }
00458   }
00459 
00460   if (!components_ok) {
00461     // Just store the overall transform.
00462     flt_node->set_transform(egg_transform->get_transform3d());
00463   }
00464 }
00465 
00466 ////////////////////////////////////////////////////////////////////
00467 //     Function: EggToFlt::apply_egg_syntax
00468 //       Access: Private
00469 //  Description: Adds the indicated sequence of egg syntax lines
00470 //               (presumably representing egg features not directly
00471 //               supported by MultiGen) to the flt record as a
00472 //               comment, so that flt2egg will reapply it to the egg
00473 //               groups.
00474 ////////////////////////////////////////////////////////////////////
00475 void EggToFlt::
00476 apply_egg_syntax(const string &egg_syntax, FltRecord *flt_record) {
00477   if (!egg_syntax.empty()) {
00478     ostringstream out;
00479     out << "<egg> {\n" 
00480         << egg_syntax
00481         << "}";
00482     flt_record->set_comment(out.str());
00483   }
00484 }
00485 
00486 ////////////////////////////////////////////////////////////////////
00487 //     Function: EggToFlt::get_flt_vertex
00488 //       Access: Private
00489 //  Description: Returns a FltVertex corresponding to the indicated
00490 //               EggVertex.  If the vertex has not been seen before
00491 //               (in this particular vertex frame), creates a new one.
00492 ////////////////////////////////////////////////////////////////////
00493 FltVertex *EggToFlt::
00494 get_flt_vertex(EggVertex *egg_vertex, EggNode *context) {
00495   const LMatrix4d *frame = context->get_vertex_to_node_ptr();
00496   VertexMap &vertex_map = _vertex_map_per_frame[frame];
00497 
00498   VertexMap::iterator vi = vertex_map.find(egg_vertex);
00499   if (vi != vertex_map.end()) {
00500     return (*vi).second;
00501   }
00502   FltVertex *flt_vertex = new FltVertex(_flt_header);
00503   flt_vertex->_pos = egg_vertex->get_pos3();
00504 
00505   if (egg_vertex->has_color()) {
00506     flt_vertex->set_color(egg_vertex->get_color());
00507   }
00508   if (egg_vertex->has_normal()) {
00509     flt_vertex->_normal = LCAST(PN_stdfloat, egg_vertex->get_normal());
00510     flt_vertex->_has_normal = true;
00511   }
00512   if (egg_vertex->has_uv()) {
00513     flt_vertex->_uv = LCAST(PN_stdfloat, egg_vertex->get_uv());
00514     flt_vertex->_has_uv = true;
00515   }
00516 
00517   if (frame != (const LMatrix4d *)NULL) {
00518     flt_vertex->_pos = flt_vertex->_pos * (*frame);
00519     flt_vertex->_normal = flt_vertex->_normal * LCAST(PN_stdfloat, (*frame));
00520   }
00521 
00522   _flt_header->add_vertex(flt_vertex);
00523   vertex_map[egg_vertex] = flt_vertex;
00524 
00525   return flt_vertex;
00526 }
00527 
00528 ////////////////////////////////////////////////////////////////////
00529 //     Function: EggToFlt::get_flt_texture
00530 //       Access: Private
00531 //  Description: Returns a FltTexture corresponding to the indicated
00532 //               EggTexture.  If the texture has not been seen before,
00533 //               creates a new one.
00534 ////////////////////////////////////////////////////////////////////
00535 FltTexture *EggToFlt::
00536 get_flt_texture(EggTexture *egg_texture) {
00537   // We have to maintain this map based on the filename, not the egg
00538   // pointer, because there may be multiple EggTextures with the same
00539   // filename, and we have to collapse them together.
00540   Filename filename = egg_texture->get_filename();
00541   TextureMap::iterator vi = _texture_map.find(filename);
00542   if (vi != _texture_map.end()) {
00543     return (*vi).second;
00544   }
00545   FltTexture *flt_texture = new FltTexture(_flt_header);
00546   flt_texture->set_texture_filename(filename);
00547 
00548   switch (egg_texture->get_minfilter()) {
00549   case EggTexture::FT_nearest:
00550     flt_texture->_min_filter = FltTexture::MN_point;
00551     break;
00552 
00553   case EggTexture::FT_linear:
00554     flt_texture->_min_filter = FltTexture::MN_bilinear;
00555     break;
00556 
00557   case EggTexture::FT_nearest_mipmap_nearest:
00558     flt_texture->_min_filter = FltTexture::MN_mipmap_point;
00559     break;
00560 
00561   case EggTexture::FT_nearest_mipmap_linear:
00562     flt_texture->_min_filter = FltTexture::MN_mipmap_linear;
00563     break;
00564 
00565   case EggTexture::FT_linear_mipmap_nearest:
00566     flt_texture->_min_filter = FltTexture::MN_mipmap_bilinear;
00567     break;
00568 
00569   case EggTexture::FT_linear_mipmap_linear:
00570     flt_texture->_min_filter = FltTexture::MN_mipmap_trilinear;
00571     break;
00572 
00573   default:
00574     break;
00575   }
00576 
00577   switch (egg_texture->get_magfilter()) {
00578   case EggTexture::FT_nearest:
00579     flt_texture->_mag_filter = FltTexture::MG_point;
00580     break;
00581 
00582   case EggTexture::FT_linear:
00583     flt_texture->_mag_filter = FltTexture::MG_bilinear;
00584     break;
00585 
00586   default:
00587     break;
00588   }
00589 
00590   switch (egg_texture->get_wrap_mode()) {
00591   case EggTexture::WM_repeat:
00592     flt_texture->_repeat = FltTexture::RT_repeat;
00593     break;
00594 
00595   case EggTexture::WM_clamp:
00596     flt_texture->_repeat = FltTexture::RT_clamp;
00597     break;
00598 
00599   default:
00600     break;
00601   }
00602 
00603   switch (egg_texture->get_wrap_u()) {
00604   case EggTexture::WM_repeat:
00605     flt_texture->_repeat_u = FltTexture::RT_repeat;
00606     break;
00607 
00608   case EggTexture::WM_clamp:
00609     flt_texture->_repeat_u = FltTexture::RT_clamp;
00610     break;
00611 
00612   default:
00613     break;
00614   }
00615 
00616   switch (egg_texture->get_wrap_v()) {
00617   case EggTexture::WM_repeat:
00618     flt_texture->_repeat_v = FltTexture::RT_repeat;
00619     break;
00620 
00621   case EggTexture::WM_clamp:
00622     flt_texture->_repeat_v = FltTexture::RT_clamp;
00623     break;
00624 
00625   default:
00626     break;
00627   }
00628 
00629   switch (egg_texture->get_env_type()) {
00630   case EggTexture::ET_modulate:
00631     flt_texture->_env_type = FltTexture::ET_modulate;
00632     break;
00633 
00634   case EggTexture::ET_decal:
00635     flt_texture->_env_type = FltTexture::ET_decal;
00636     break;
00637 
00638   default:
00639     break;
00640   }
00641 
00642   switch (egg_texture->get_format()) {
00643   case EggTexture::F_luminance_alpha:
00644   case EggTexture::F_luminance_alphamask:
00645     flt_texture->_internal_format = FltTexture::IF_ia_8;
00646     break;
00647 
00648   case EggTexture::F_rgb5:
00649   case EggTexture::F_rgb332:
00650     flt_texture->_internal_format = FltTexture::IF_rgb_5;
00651     break;
00652 
00653   case EggTexture::F_rgba4:
00654   case EggTexture::F_rgba5:
00655     flt_texture->_internal_format = FltTexture::IF_rgba_4;
00656     break;
00657 
00658   case EggTexture::F_rgba8:
00659   case EggTexture::F_rgba:
00660   case EggTexture::F_rgbm:
00661   case EggTexture::F_rgb:
00662   case EggTexture::F_rgb8:
00663     flt_texture->_internal_format = FltTexture::IF_rgba_8;
00664     break;
00665 
00666   case EggTexture::F_rgba12:
00667     flt_texture->_internal_format = FltTexture::IF_rgba_12;
00668     break;
00669 
00670   case EggTexture::F_alpha:
00671     flt_texture->_internal_format = FltTexture::IF_i_16;
00672     flt_texture->_intensity_is_alpha = true;
00673     break;
00674 
00675   case EggTexture::F_luminance:
00676     flt_texture->_internal_format = FltTexture::IF_i_16;
00677     break;
00678 
00679   case EggTexture::F_rgb12:
00680     flt_texture->_internal_format = FltTexture::IF_rgb_12;
00681     break;
00682 
00683   default:
00684     break;
00685   }
00686 
00687   _flt_header->add_texture(flt_texture);
00688   _texture_map[filename] = flt_texture;
00689 
00690   return flt_texture;
00691 }
00692 
00693 
00694 
00695 int main(int argc, char *argv[]) {
00696   // A call to pystub() to force libpystub.so to be linked in.
00697   pystub();
00698 
00699   EggToFlt prog;
00700   prog.parse_command_line(argc, argv);
00701   prog.run();
00702   return 0;
00703 }
 All Classes Functions Variables Enumerations