More work in Command Buffers...

core/cross/command_buffer/param_cache_cb.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 29 matching lines @@
 #include "core/cross/command_buffer/param_cache_cb.h"
 #include "core/cross/command_buffer/sampler_cb.h"
 #include "command_buffer/common/cross/cmd_buffer_format.h"
 #include "command_buffer/client/cross/cmd_buffer_helper.h"
 
 namespace o3d {
 
 using command_buffer::CommandBufferEntry;
 using command_buffer::CommandBufferHelper;
 using command_buffer::EffectHelper;
-using command_buffer::ResourceID;
+using command_buffer::ResourceId;
 namespace effect_param = command_buffer::effect_param;
 
 // Base class for ParamHandlers.
 class ParamHandlerCB {
  public:
   virtual ~ParamHandlerCB() {}
   virtual void SetValue(CommandBufferHelper *helper) = 0;
 };
 
 // Template implementation of ParamHandlerCB.
 template <typename T>
 class TypedParamHandlerCB : public ParamHandlerCB {
  public:
-  TypedParamHandlerCB(T* param, ResourceID id)
+  TypedParamHandlerCB(T* param, ResourceId id)
       : param_(param),
         id_(id) {
   }
 
   // Sends the param value to the service.
   // This template definition only works for value types (floatn, matrix, int,
   // ..., but not textures or samplers).
   virtual void SetValue(CommandBufferHelper *helper) {
     typename T::DataType value = param_->value();
     helper->SetParamDataImmediate(id_, sizeof(value), &value);
   }
  private:
   T* param_;
-  ResourceID id_;
+  ResourceId id_;
 };
 
 // Matrices are expected in row major order in the command buffer, so
 // TypedParamHandlerCB<ParamMatrix4> works for row major, and we make a new
 // class for column major.
 typedef TypedParamHandlerCB<ParamMatrix4> MatrixParamHandlerRowsCB;
 
 class MatrixParamHandlerColumnsCB : public ParamHandlerCB {
  public:
-  MatrixParamHandlerColumnsCB(ParamMatrix4* param, ResourceID id)
+  MatrixParamHandlerColumnsCB(ParamMatrix4* param, ResourceId id)
       : param_(param),
         id_(id) {
   }
 
   // Sends the param value to the service.
   virtual void SetValue(CommandBufferHelper *helper) {
     Matrix4 value = transpose(param_->value());
     helper->SetParamDataImmediate(id_, sizeof(value), &value);
   }
  private:
   ParamMatrix4* param_;
-  ResourceID id_;
+  ResourceId id_;
 };
 
 class SamplerParamHandlerCB : public ParamHandlerCB {
  public:
-  SamplerParamHandlerCB(ParamSampler* param, ResourceID id)
+  SamplerParamHandlerCB(ParamSampler* param, ResourceId id)
       : param_(param),
         id_(id) {
   }
 
   // Sends the param value to the service.
   virtual void SetValue(CommandBufferHelper *helper) {
     SamplerCB *sampler = down_cast<SamplerCB *>(param_->value());
     uint32 value;
     if (!sampler) {
       // TODO: use error sampler
       value = command_buffer::kInvalidResource;
     } else {
       sampler->SetTextureAndStates();
       value = sampler->resource_id();
     }
     helper->SetParamDataImmediate(id_, sizeof(value), &value);
   }
  private:
   ParamSampler* param_;
-  ResourceID id_;
+  ResourceId id_;
 };
 
 static ParamHandlerCB *GetHandlerFromParamAndDesc(
     Param *param,
     const EffectHelper::EffectParamDesc &desc,
     Effect::MatrixLoadOrder matrix_load_order) {
   switch (desc.data_type) {
-    case effect_param::MATRIX4:
+    case effect_param::kMatrix4:
       if (param->IsA(ParamMatrix4::GetApparentClass())) {
         DCHECK_EQ(sizeof(ParamMatrix4::DataType), desc.data_size);
         ParamMatrix4 *matrix_param = down_cast<ParamMatrix4*>(param);
         if (matrix_load_order == Effect::ROW_MAJOR) {
           return new MatrixParamHandlerRowsCB(matrix_param, desc.id);
         } else {
           return new MatrixParamHandlerColumnsCB(matrix_param, desc.id);
         }
       }
       break;
-    case effect_param::FLOAT1:
+    case effect_param::kFloat1:
       if (param->IsA(ParamFloat::GetApparentClass())) {
         DCHECK_EQ(sizeof(ParamFloat::DataType), desc.data_size);
         return new TypedParamHandlerCB<ParamFloat>(
             down_cast<ParamFloat*>(param), desc.id);
       }
       break;
-    case effect_param::FLOAT2:
+    case effect_param::kFloat2:
       if (param->IsA(ParamFloat2::GetApparentClass())) {
         DCHECK_EQ(sizeof(ParamFloat2::DataType), desc.data_size);
         return new TypedParamHandlerCB<ParamFloat2>(
             down_cast<ParamFloat2*>(param), desc.id);
       }
       break;
-    case effect_param::FLOAT3:
+    case effect_param::kFloat3:
       if (param->IsA(ParamFloat3::GetApparentClass())) {
         DCHECK_EQ(sizeof(ParamFloat3::DataType), desc.data_size);
         return new TypedParamHandlerCB<ParamFloat3>(
             down_cast<ParamFloat3*>(param), desc.id);
       }
       break;
-    case effect_param::FLOAT4:
+    case effect_param::kFloat4:
       if (param->IsA(ParamFloat4::GetApparentClass())) {
         DCHECK_EQ(sizeof(ParamFloat4::DataType), desc.data_size);
         return new TypedParamHandlerCB<ParamFloat4>(
             down_cast<ParamFloat4*>(param), desc.id);
       }
       break;
-    case effect_param::INT:
+    case effect_param::kInt:
       if (param->IsA(ParamInteger::GetApparentClass())) {
         DCHECK_EQ(sizeof(ParamInteger::DataType), desc.data_size);
         return new TypedParamHandlerCB<ParamInteger>(
             down_cast<ParamInteger*>(param), desc.id);
       }
       break;
-    case effect_param::BOOL:
+    case effect_param::kBool:
       if (param->IsA(ParamBoolean::GetApparentClass())) {
         DCHECK_EQ(sizeof(ParamBoolean::DataType), desc.data_size);
         return new TypedParamHandlerCB<ParamBoolean>(
             down_cast<ParamBoolean*>(param), desc.id);
       }
       break;
-    case effect_param::SAMPLER:
+    case effect_param::kSampler:
       if (param->IsA(ParamSampler::GetApparentClass())) {
-        DCHECK_EQ(sizeof(ResourceID), desc.data_size);
+        DCHECK_EQ(sizeof(ResourceId), desc.data_size);
         return new SamplerParamHandlerCB(down_cast<ParamSampler*>(param),
                                          desc.id);
       }
       break;
     default:
       break;
   }
   // Do not report an error, it may be valid that the Param didn't match the
   // desc, we may still be looking for another match in other nodes.
   return NULL;
@@ skipping 78 matching lines @@
   handlers_.clear();
 }
 
 void ParamCacheCB::RunHandlers(CommandBufferHelper *helper) {
   for (unsigned int i = 0; i < handlers_.size(); ++i) {
     handlers_[i]->SetValue(helper);
   }
 }
 
 }  // namespace o3d