Updates the o3dConverter to turn on filtering by default...

import/cross/collada.cc

 /*
  * Copyright 2009, Google Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 48 matching lines @@
 #define COLLADA_NAMESPACE_SEPARATOR "."
 
 // Macro to provide a uniform prefix for all string constants created by
 // COLLADA.
 #define COLLADA_STRING_CONSTANT(value)                  \
   (COLLADA_NAMESPACE COLLADA_NAMESPACE_SEPARATOR value)
 
 
 namespace o3d {
 
+const char* Collada::kLightingTypeParamName =
+    COLLADA_STRING_CONSTANT("lightingType");
+
+const char* Collada::kLightingTypeConstant = "constant";
+const char* Collada::kLightingTypePhong = "phong";
+const char* Collada::kLightingTypeBlinn = "blinn";
+const char* Collada::kLightingTypeLambert = "lambert";
+const char* Collada::kLightingTypeUnknown = "unknown";
+
+const char* Collada::kMaterialParamNameEmissive = "emissive";
+const char* Collada::kMaterialParamNameAmbient = "ambient";
+const char* Collada::kMaterialParamNameDiffuse = "diffuse";
+const char* Collada::kMaterialParamNameSpecular = "specular";
+const char* Collada::kMaterialParamNameShininess = "shininess";
+const char* Collada::kMaterialParamNameSpecularFactor = "specularFactor";
+const char* Collada::kMaterialParamNameEmissiveSampler = "emissiveSampler";
+const char* Collada::kMaterialParamNameAmbientSampler = "ambientSampler";
+const char* Collada::kMaterialParamNameDiffuseSampler = "diffuseSampler";
+const char* Collada::kMaterialParamNameSpecularSampler = "specularSampler";
+const char* Collada::kMaterialParamNameBumpSampler = "bumpSampler";
+
 class TranslationMap : public FCDGeometryIndexTranslationMap {
 };
 
 namespace {
 
 Vector3 FMVector3ToVector3(const FMVector3& fmvector3) {
   return Vector3(fmvector3.x, fmvector3.y, fmvector3.z);
 }
 
 Vector4 FMVector4ToVector4(const FMVector4& fmvector4) {
@@ skipping 127 matching lines @@
   file_util::AbsolutePath(&base_path_);
 
   bool status = false;
   if (ZipArchive::IsZipFile(FilePathToUTF8(filename))) {
     status = ImportZIP(filename, parent, animation_input);
   } else {
     status = ImportDAE(filename, parent, animation_input);
   }
 
   if (!status) {
-    // TODO: this could probably be the original URI instead of some
+    // TODO(o3d): this could probably be the original URI instead of some
     //     filename in the temp folder.
     O3D_ERROR(service_locator_) << "Unable to import: "
                                 << FilePathToUTF8(filename).c_str();
   }
 
   return status;
 }
 
 // Imports the given ZIP file into the given client.
 // Parameters:  see Import() above.
@@ skipping 107 matching lines @@
       Vector3 up_axis = options_.up_axis;
       FMVector3 up(up_axis.getX(), up_axis.getY(), up_axis.getZ());
       // Transform the document to the given up vector
 
       FCDocumentTools::StandardizeUpAxisAndLength(doc, up);
 
       // Import all the textures in the file. Even if they are not used by
       // materials or models the user put them in the file and might need them
       // at runtime.
       //
-      // TODO: Add option to skip this step if user just wants what's
+      // TODO(o3d): Add option to skip this step if user just wants what's
       // actually used by models. The rest of the code already deals with this.
       FCDImageLibrary* image_library = doc->GetImageLibrary();
       for (uint32 i = 0; i < image_library->GetEntityCount(); i++) {
         FCDEntity* entity = image_library->GetEntity(i);
         LOG_ASSERT(entity);
         LOG_ASSERT(entity->GetType() == FCDEntity::IMAGE);
         FCDImage* image = down_cast<FCDImage*>(entity);
         BuildTextureFromImage(image);
       }
 
       // Import all the materials in the file. Even if they are not used by
       // models the user put them in the file and might need them at runtime.
       //
-      // TODO: Add option to skip this step if user just wants what's
+      // TODO(o3d): Add option to skip this step if user just wants what's
       // actually used by models. The rest of the code already deals with this.
       FCDMaterialLibrary* material_library = doc->GetMaterialLibrary();
       for (uint32 i = 0; i < material_library->GetEntityCount(); i++) {
         FCDEntity* entity = material_library->GetEntity(i);
         LOG_ASSERT(entity);
         LOG_ASSERT(entity->GetType() == FCDEntity::MATERIAL);
         FCDMaterial* collada_material = down_cast<FCDMaterial*>(entity);
         BuildMaterial(doc, collada_material);
       }
 
@@ skipping 431 matching lines @@
   }
 
   Transform* transform = node_instance->transform();
   for (size_t i = 0; i < node->GetInstanceCount(); ++i) {
     FCDEntityInstance* instance = node->GetInstance(i);
     FCDCamera* camera(NULL);
     FCDGeometryInstance* geom_instance(NULL);
 
     LOG_ASSERT(instance != 0);
     // Import each node based on what kind of entity it is
-    // TODO: add more entity types as they are supported
+    // TODO(o3d): add more entity types as they are supported
     switch (instance->GetEntityType()) {
       case FCDEntity::CAMERA:
         // camera entity
         camera = down_cast<FCDCamera*>(instance->GetEntity());
         BuildCamera(doc, camera, transform, node);
         break;
       case FCDEntity::GEOMETRY: {
         // geometry entity
         geom_instance = static_cast<FCDGeometryInstance*>(instance);
         Shape* shape = GetShape(doc, geom_instance);
@@ skipping 193 matching lines @@
           transform->CreateParam<ParamFloat3>(
               COLLADA_STRING_CONSTANT("upVector"));
       Vector4 world_up = parent_world * Vector4(up.x, up.y, up.z, 0.0f);
       param_up_vector->set_value(Float3(world_up.getX(),
                                         world_up.getY(),
                                         world_up.getZ()));
 
       break;
     }
   }
-
 }
 
 Shape* Collada::GetShape(FCDocument* doc,
                          FCDGeometryInstance* geom_instance) {
   Shape* shape = NULL;
   FCDGeometry* geom = static_cast<FCDGeometry*>(geom_instance->GetEntity());
   if (geom) {
     fm::string geom_id = geom->GetDaeId();
     shape = shapes_[geom_id.c_str()];
     if (!shape) {
@@ skipping 206 matching lines @@
       // mesh.
       primitive->set_stream_bank(stream_bank);
     }
   }
   return shape;
 }
 
 Shape* Collada::BuildSkinnedShape(FCDocument* doc,
                                   FCDControllerInstance* instance,
                                   NodeInstance *parent_node_instance) {
-  // TODO: Handle chained controllers. Morph->Skin->...
+  // TODO(o3d): Handle chained controllers. Morph->Skin->...
   Shape* shape = NULL;
   LOG_ASSERT(doc && instance);
   FCDController* controller =
       static_cast<FCDController*>(instance->GetEntity());
   if (controller && controller->IsSkin()) {
     FCDSkinController* skin_controller = controller->GetSkinController();
     TranslationMap translationMap;
     shape = BuildShape(doc,
                        instance,
                        controller->GetBaseGeometry(),
@@ skipping 191 matching lines @@
           case Stream::NORMAL:
           case Stream::BINORMAL:
           case Stream::TANGENT: {
             copied = true;
             unsigned num_source_components = field.num_components();
             Field* new_field = new_fields[ii];
 
             std::vector<float> data(num_vertices * num_source_components);
             field.GetAsFloats(0, &data[0], num_source_components,
                               num_vertices);
-            // TODO: Remove this matrix multiply. I don't think it is
+            // TODO(o3d): Remove this matrix multiply. I don't think it is
             //     needed.
             for (unsigned vv = 0; vv < num_vertices; ++vv) {
               float* values = &data[vv * num_source_components];
               switch (field.num_components()) {
                 case 3: {
                   if (source_stream.semantic() == Stream::POSITION) {
                     Vector4 result(matrix * Point3(values[0],
                                                    values[1],
                                                    values[2]));
                     values[0] = result.getElem(0);
@@ skipping 204 matching lines @@
 
         // Set the texture on the sampler.
         if (tex) {
           o3d_sampler->set_texture(tex);
           rc = true;
         }
       }
       SetSamplerStates(sampler, o3d_sampler);
     }
   } else if (type == FCDEffectParameter::SURFACE) {
-    // TODO: This code is here to handle the NV_import profile
+    // TODO(o3d): This code is here to handle the NV_import profile
     // exported by Max's DirectX Shader materials, which references
     // only references texture params (not samplers).  Once we move
     // completely to using samplers and add sampler blocks to our
     // collada file then we should eliminate this codepath.
 
     FCDEffectParameterSurface* surface =
         static_cast<FCDEffectParameterSurface*>(fc_param);
 
     Texture* tex = BuildTexture(surface);
     if (tex) {
@@ skipping 34 matching lines @@
         COLLADA_STRING_CONSTANT("substituteForMissingOrBadMaterial"));
     dummy_material_->set_effect(GetDummyEffect());
   }
   return dummy_material_;
 }
 
 static const char* GetLightingType(FCDEffectStandard* std_profile) {
   FCDEffectStandard::LightingType type = std_profile->GetLightingType();
   switch (type) {
     case FCDEffectStandard::CONSTANT:
-      return "constant";
+      return Collada::kLightingTypeConstant;
     case FCDEffectStandard::PHONG:
-      return "phong";
+      return Collada::kLightingTypePhong;
     case FCDEffectStandard::BLINN:
-      return "blinn";
+      return Collada::kLightingTypeBlinn;
     case FCDEffectStandard::LAMBERT:
-      return "lambert";
+      return Collada::kLightingTypeLambert;
     default:
-      return "unknown";
+      return Collada::kLightingTypeUnknown;
   }
 }
 
 static FCDEffectProfileFX* FindProfileFX(FCDEffect* effect) {
   FCDEffectProfile* profile = effect->FindProfile(FUDaeProfileType::HLSL);
   if (!profile) {
     profile = effect->FindProfile(FUDaeProfileType::CG);
     if (!profile) {
       return NULL;
     }
@@ skipping 38 matching lines @@
             AddRenderState(pass->GetRenderState(i), state);
           }
           material->set_state(state);
         }
       }
     } else {
       FCDEffectStandard* std_profile = static_cast<FCDEffectStandard *>(
           collada_effect->FindProfile(FUDaeProfileType::COMMON));
       if (std_profile) {
         ParamString* type_tag = material->CreateParam<ParamString>(
-            COLLADA_STRING_CONSTANT("lightingType"));
+            kLightingTypeParamName);
         type_tag->set_value(GetLightingType(std_profile));
       }
     }
     materials_[material_id.c_str()] = material;
   }
   return material;
 }
 
 Effect* Collada::GetEffect(FCDocument* doc, FCDEffect* collada_effect) {
   Effect* effect = NULL;
@@ skipping 10 matching lines @@
 // (Cg/HLSL) effect is present, it will be used and a programmable
 // Effect generated.  If not, an attempt is made to use one of the fixed-
 // function profiles if present (eg., Constant, Lambert).
 // Parameters:
 //   doc:                The FCollada document from which to import nodes.
 //   collada_effect:     The COLLADA effect from which shaders will be taken.
 // Returns:
 //   the newly-created effect, or NULL or error.
 Effect* Collada::BuildEffect(FCDocument* doc, FCDEffect* collada_effect) {
   if (!doc || !collada_effect) return NULL;
-  // TODO: Remove all of this to be replaced by parsing Collada-FX
+  // TODO(o3d): Remove all of this to be replaced by parsing Collada-FX
   //    and profile_O3D only.
   Effect* effect = NULL;
   FCDEffectProfileFX* profile_fx = FindProfileFX(collada_effect);
   if (profile_fx) {
     if (profile_fx->GetCodeCount() > 0) {
       FCDEffectCode* code = profile_fx->GetCode(0);
       String effect_string;
       FilePath file_path;
       if (code->GetType() == FCDEffectCode::CODE) {
         fstring code_string = code->GetCode();
@@ skipping 18 matching lines @@
           if (effect_data) {
             effect_string = effect_data;
             free(effect_data);
           } else {
             O3D_ERROR(service_locator_)
                 << "Unable to read effect data for effect '"
                 << FilePathToUTF8(file_path) << "'";
             return NULL;
           }
         } else {
-          file_util::ReadFileToString(file_path, &effect_string);
+          FilePath temp_path = file_path;
+          GetRelativePathIfPossible(base_path_, temp_path, &temp_path);
+          file_util::ReadFileToString(temp_path, &effect_string);
         }
       }
       String collada_effect_name = WideToUTF8(
           collada_effect->GetName().c_str());
       effect = pack_->Create<Effect>();
       effect->set_name(collada_effect_name);
 
       ParamString* param = effect->CreateParam<ParamString>(
           O3D_STRING_CONSTANT("uri"));
       DCHECK(param != NULL);
@@ skipping 642 matching lines @@
     bool allow_none) {
   switch (filter_function) {
     case FUDaeTextureFilterFunction::NEAREST:
     case FUDaeTextureFilterFunction::NEAREST_MIPMAP_NEAREST:
     case FUDaeTextureFilterFunction::NEAREST_MIPMAP_LINEAR:
       return Sampler::POINT;
     case FUDaeTextureFilterFunction::LINEAR:
     case FUDaeTextureFilterFunction::LINEAR_MIPMAP_NEAREST:
     case FUDaeTextureFilterFunction::LINEAR_MIPMAP_LINEAR:
       return Sampler::LINEAR;
-      // TODO: Once FCollada supports COLLADA v1.5, turn this on:
+      // TODO(o3d): Once FCollada supports COLLADA v1.5, turn this on:
       // case FUDaeTextureFilterFunction::ANISOTROPIC:
       //   return Sampler::ANISOTROPIC;
     case FUDaeTextureFilterFunction::NONE:
       return allow_none ? Sampler::NONE : Sampler::LINEAR;
     default:
       return Sampler::LINEAR;
   }
 }
 
 
@@ skipping 32 matching lines @@
       wrap_t = FUDaeTextureWrapMode::CLAMP;
   }
 
   FUDaeTextureFilterFunction::FilterFunction min_filter =
       effect_sampler->GetMinFilter();
   FUDaeTextureFilterFunction::FilterFunction mag_filter =
       effect_sampler->GetMagFilter();
 
   FUDaeTextureFilterFunction::FilterFunction mip_filter =
       effect_sampler->GetMipFilter();
-  // TODO: Once FCollada supports COLLADA v1.5, turn this on:
+  // TODO(o3d): Once FCollada supports COLLADA v1.5, turn this on:
   // int max_anisotropy = effect_sampler->GetMaxAnisotropy();
 
   o3d_sampler->set_address_mode_u(ConvertSamplerAddressMode(wrap_s));
   o3d_sampler->set_address_mode_v(ConvertSamplerAddressMode(wrap_t));
 
   // The Collada spec allows for both DX-style and GL-style specification
   // of texture filtering modes.  In DX-style, Min, Mag and Mip filters
   // are specified separately, and may be Linear, Point or None.
   // In GL-style, only Min and Mag are specified, with the Mip filter
   // encoded as a combo setting in the Min filter.  E.g.,
@@ skipping 13 matching lines @@
 
   // If the mip filter is set to "UNKNOWN", we assume it's a GL-style
   // mode, and use the 2nd part of the Min filter for the mip type.  Otherwise,
   // we use the first part.
   if (mip_filter == FUDaeTextureFilterFunction::UNKNOWN) {
     o3d_sampler->set_mip_filter(ConvertMipmapFilter(min_filter));
   } else {
     o3d_sampler->set_mip_filter(ConvertFilterType(mip_filter, true));
   }
 
-  // TODO: Once FCollada supports COLLADA v1.5, turn this on:
+  // TODO(o3d): Once FCollada supports COLLADA v1.5, turn this on:
   // o3d_sampler->set_max_anisotropy(max_anisotropy);
 }
 
 // Sets the value of a Param on the given ParamObject from an FCollada
 // standard-profile effect parameter.  If the FCollada parameter
 // contains a texture, the sampler_param_name and channel is used to set
 // a Sampler Param in o3d from the surface.  If not, the
 // color_param_name is used to create set a vector Param value.
 // Parameters:
 //   effect_standard:      The fixed-function FCollada effect from which
@@ skipping 16 matching lines @@
     FCDEffectParameterSampler* sampler = texture->GetSampler();
     SetParamFromFCEffectParam(param_object, sampler_param_name, sampler);
   } else if (color_param) {
     SetParamFromFCEffectParam(param_object, color_param_name, color_param);
   }
 }
 
 // Sets the values of a ParamObject parameters from a given FCollada material
 // node. If a corresponding ParamObject parameter is not found, the FCollada
 // parameter is ignored.
-// TODO: Should we ignore params not found? Maybe the user wants those for
+// TODO(o3d): Should we ignore params not found? Maybe the user wants those for
 //    things other than rendering.
 // Parameters:
 //   material:  The FCollada material node from which to retrieve values.
 //   param_object:     The ParamObject on which parameters will be set.
 void Collada::SetParamsFromMaterial(FCDMaterial* material,
                                     ParamObject* param_object) {
   size_t pcount = material->GetEffectParameterCount();
-  // TODO:  This test (for determining if we used the
+  // TODO(o3d):  This test (for determining if we used the
   // programmable profile or the fixed-func profile) is not very robust.
   // Remove this once the Material changes are in.
   if (pcount > 0) {
     for (size_t i = 0; i < pcount; ++i) {
       FCDEffectParameter* p = material->GetEffectParameter(i);
       LOG_ASSERT(p);
       String param_name(p->GetReference());
       // Check for an effect binding
       FCDEffect* effect = material->GetEffect();
       FCDEffectProfileFX* profile_fx = FindProfileFX(material->GetEffect());
@@ skipping 14 matching lines @@
       }
       SetParamFromFCEffectParam(param_object, param_name, p);
     }
   } else {
     FCDEffect* effect = material->GetEffect();
     FCDEffectStandard* effect_standard;
     if (effect && (effect_standard = static_cast<FCDEffectStandard *>(
         effect->FindProfile(FUDaeProfileType::COMMON))) != NULL) {
       SetParamFromStandardEffectParam(effect_standard,
                                       param_object,
-                                      "emissive",
-                                      "emissiveSampler",
+                                      kMaterialParamNameEmissive,
+                                      kMaterialParamNameEmissiveSampler,
                                       effect_standard->GetEmissionColorParam(),
                                       FUDaeTextureChannel::EMISSION);
       SetParamFromStandardEffectParam(effect_standard,
                                       param_object,
-                                      "ambient",
-                                      "ambientSampler",
+                                      kMaterialParamNameAmbient,
+                                      kMaterialParamNameAmbientSampler,
                                       effect_standard->GetAmbientColorParam(),
                                       FUDaeTextureChannel::AMBIENT);
       SetParamFromStandardEffectParam(effect_standard,
                                       param_object,
-                                      "diffuse",
-                                      "diffuseSampler",
+                                      kMaterialParamNameDiffuse,
+                                      kMaterialParamNameDiffuseSampler,
                                       effect_standard->GetDiffuseColorParam(),
                                       FUDaeTextureChannel::DIFFUSE);
       SetParamFromStandardEffectParam(effect_standard,
                                       param_object,
-                                      "specular",
-                                      "specularSampler",
+                                      kMaterialParamNameSpecular,
+                                      kMaterialParamNameSpecularSampler,
                                       effect_standard->GetSpecularColorParam(),
                                       FUDaeTextureChannel::SPECULAR);
       SetParamFromStandardEffectParam(effect_standard,
                                       param_object,
                                       NULL,
-                                      "bumpSampler",
+                                      kMaterialParamNameBumpSampler,
                                       NULL,
                                       FUDaeTextureChannel::BUMP);
       SetParamFromFCEffectParam(param_object,
-                                "shininess",
+                                kMaterialParamNameShininess,
                                 effect_standard->GetShininessParam());
       SetParamFromFCEffectParam(param_object,
-                                "specularFactor",
+                                kMaterialParamNameSpecularFactor,
                                 effect_standard->GetSpecularFactorParam());
     }
   }
 }
 }  // namespace o3d