More work in Command Buffers...

command_buffer/service/win/d3d9/effect_d3d9.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 186 matching lines @@
   return streams_.size();
 }
 
 // Retrieves the matching DataType from a D3D parameter description.
 static effect_param::DataType GetDataTypeFromD3D(
     const D3DXPARAMETER_DESC &desc) {
   switch (desc.Type) {
     case D3DXPT_FLOAT:
       switch (desc.Class) {
         case D3DXPC_SCALAR:
-          return effect_param::FLOAT1;
+          return effect_param::kFloat1;
         case D3DXPC_VECTOR:
           switch (desc.Columns) {
             case 2:
-              return effect_param::FLOAT2;
+              return effect_param::kFloat2;
             case 3:
-              return effect_param::FLOAT3;
+              return effect_param::kFloat3;
             case 4:
-              return effect_param::FLOAT4;
+              return effect_param::kFloat4;
             default:
-              return effect_param::UNKNOWN;
+              return effect_param::kUnknown;
           }
         case D3DXPC_MATRIX_ROWS:
         case D3DXPC_MATRIX_COLUMNS:
           if (desc.Columns == 4 && desc.Rows == 4) {
-            return effect_param::MATRIX4;
+            return effect_param::kMatrix4;
           } else {
-            return effect_param::UNKNOWN;
+            return effect_param::kUnknown;
           }
         default:
-          return effect_param::UNKNOWN;
+          return effect_param::kUnknown;
       }
     case D3DXPT_INT:
       if (desc.Class == D3DXPC_SCALAR) {
-        return effect_param::INT;
+        return effect_param::kInt;
       } else {
-        return effect_param::UNKNOWN;
+        return effect_param::kUnknown;
       }
     case D3DXPT_BOOL:
       if (desc.Class == D3DXPC_SCALAR) {
-        return effect_param::BOOL;
+        return effect_param::kBool;
       } else {
-        return effect_param::UNKNOWN;
+        return effect_param::kUnknown;
       }
     case D3DXPT_SAMPLER:
     case D3DXPT_SAMPLER2D:
     case D3DXPT_SAMPLER3D:
     case D3DXPT_SAMPLERCUBE:
       if (desc.Class == D3DXPC_OBJECT) {
-        return effect_param::SAMPLER;
+        return effect_param::kSampler;
       } else {
-        return effect_param::UNKNOWN;
+        return effect_param::kUnknown;
       }
     case D3DXPT_TEXTURE:
     case D3DXPT_TEXTURE1D:
     case D3DXPT_TEXTURE2D:
     case D3DXPT_TEXTURE3D:
     case D3DXPT_TEXTURECUBE:
       if (desc.Class == D3DXPC_OBJECT) {
-        return effect_param::TEXTURE;
+        return effect_param::kTexture;
       } else {
-        return effect_param::UNKNOWN;
+        return effect_param::kUnknown;
       }
     default:
-      return effect_param::UNKNOWN;
+      return effect_param::kUnknown;
   }
 }
 
 // Gets a handle to the selected parameter, and wraps it into an
 // EffectParamD3D9 if successful.
 EffectParamD3D9 *EffectD3D9::CreateParam(unsigned int index) {
   D3DXHANDLE handle = d3d_effect_->GetParameter(NULL, index);
   if (!handle) return NULL;
   return EffectParamD3D9::Create(this, handle);
 }
@@ skipping 100 matching lines @@
   if (effect_) effect_->UnlinkParam(this);
 }
 
 EffectParamD3D9 *EffectParamD3D9::Create(EffectD3D9 *effect,
                                          D3DXHANDLE handle) {
   DCHECK(effect);
   D3DXPARAMETER_DESC desc;
   HR(effect->d3d_effect_->GetParameterDesc(handle, &desc));
   effect_param::DataType data_type = GetDataTypeFromD3D(desc);
   EffectParamD3D9 *param = new EffectParamD3D9(data_type, effect, handle);
-  if (data_type == effect_param::SAMPLER) {
+  if (data_type == effect_param::kSampler) {
     ID3DXConstantTable *table = effect->fs_constant_table_;
     DCHECK(table);
     D3DXHANDLE sampler_handle = table->GetConstantByName(NULL, desc.Name);
     if (sampler_handle) {
       D3DXCONSTANT_DESC desc_array[kMaxSamplerUnits];
       unsigned int num_desc = kMaxSamplerUnits;
       table->GetConstantDesc(sampler_handle, desc_array, &num_desc);
       // We have no good way of querying how many descriptions would really be
       // returned as we're capping the number to kMaxSamplerUnits (which should
       // be more than sufficient). If however we do end up with the max number
@@ skipping 70 matching lines @@
 // Sets the data into the D3D effect parameter, using the appropriate D3D call.
 bool EffectParamD3D9::SetData(GAPID3D9 *gapi,
                               unsigned int size,
                               const void * data) {
   if (!effect_)
     return false;
   ID3DXEffect *d3d_effect = effect_->d3d_effect_;
   effect_param::DataType type = data_type();
   if (size < effect_param::GetDataSize(type)) return false;
   switch (type) {
-    case effect_param::FLOAT1:
+    case effect_param::kFloat1:
       HR(d3d_effect->SetFloat(handle_, *static_cast<const float *>(data)));
       break;
-    case effect_param::FLOAT2:
+    case effect_param::kFloat2:
       HR(d3d_effect->SetFloatArray(handle_, static_cast<const float *>(data),
                                    2));
       break;
-    case effect_param::FLOAT3:
+    case effect_param::kFloat3:
       HR(d3d_effect->SetFloatArray(handle_, static_cast<const float *>(data),
                                    3));
       break;
-    case effect_param::FLOAT4:
+    case effect_param::kFloat4:
       HR(d3d_effect->SetFloatArray(handle_, static_cast<const float *>(data),
                                    4));
       break;
-    case effect_param::MATRIX4:
+    case effect_param::kMatrix4:
       HR(d3d_effect->SetMatrix(handle_,
                                reinterpret_cast<const D3DXMATRIX *>(data)));
       break;
-    case effect_param::INT:
+    case effect_param::kInt:
       HR(d3d_effect->SetInt(handle_, *static_cast<const int *>(data)));
       break;
-    case effect_param::BOOL:
+    case effect_param::kBool:
       HR(d3d_effect->SetBool(handle_, *static_cast<const bool *>(data)?1:0));
       break;
-    case effect_param::SAMPLER: {
-      ResourceID id = *static_cast<const ResourceID *>(data);
+    case effect_param::kSampler: {
+      ResourceId id = *static_cast<const ResourceId *>(data);
       for (unsigned int i = 0; i < sampler_unit_count_; ++i) {
         effect_->samplers_[sampler_units_[i]] = id;
       }
       break;
     }
-    case effect_param::TEXTURE: {
+    case effect_param::kTexture: {
       // TODO(rlp): finish
       break;
     }
     default:
       DLOG(ERROR) << "Invalid parameter type.";
       return false;
   }
   if (effect_ == gapi->current_effect()) {
     effect_->sync_parameters_ = true;
   }
   return true;
 }
 
 // Calls EffectD3D9::Create, and assign the result to the resource ID.
 // If changing the current effect, dirty it.
 BufferSyncInterface::ParseError GAPID3D9::CreateEffect(
-    ResourceID id,
+    ResourceId id,
     unsigned int size,
     const void *data) {
   if (id == current_effect_id_) DirtyEffect();
   // Even though Assign would Destroy the effect at id, we do it explicitly in
   // case the creation fails.
   effects_.Destroy(id);
   // Data is vp_main \0 fp_main \0 effect_text.
   String vertex_program_entry;
   String fragment_program_entry;
   String effect_code;
   if (!ParseEffectData(size, data,
                        &vertex_program_entry,
                        &fragment_program_entry,
                        &effect_code)) {
     return BufferSyncInterface::kParseInvalidArguments;
   }
   EffectD3D9 * effect = EffectD3D9::Create(this, effect_code,
                                            vertex_program_entry,
                                            fragment_program_entry);
   if (!effect) return BufferSyncInterface::kParseInvalidArguments;
   effects_.Assign(id, effect);
   return BufferSyncInterface::kParseNoError;
 }
 
 // Destroys the Effect resource.
 // If destroying the current effect, dirty it.
-BufferSyncInterface::ParseError GAPID3D9::DestroyEffect(ResourceID id) {
+BufferSyncInterface::ParseError GAPID3D9::DestroyEffect(ResourceId id) {
   if (id == current_effect_id_) DirtyEffect();
   return effects_.Destroy(id) ?
       BufferSyncInterface::kParseNoError :
       BufferSyncInterface::kParseInvalidArguments;
 }
 
 // Sets the current effect ID, dirtying the current effect.
-BufferSyncInterface::ParseError GAPID3D9::SetEffect(ResourceID id) {
+BufferSyncInterface::ParseError GAPID3D9::SetEffect(ResourceId id) {
   DirtyEffect();
   current_effect_id_ = id;
   return BufferSyncInterface::kParseNoError;
 }
 
 // Gets the param count from the effect and store it in the memory buffer.
 BufferSyncInterface::ParseError GAPID3D9::GetParamCount(
-    ResourceID id,
+    ResourceId id,
     unsigned int size,
     void *data) {
   EffectD3D9 *effect = effects_.Get(id);
   if (!effect || size < sizeof(Uint32))  // NOLINT
     return BufferSyncInterface::kParseInvalidArguments;
   *static_cast<Uint32 *>(data) = effect->GetParamCount();
   return BufferSyncInterface::kParseNoError;
 }
 
 BufferSyncInterface::ParseError GAPID3D9::CreateParam(
-    ResourceID param_id,
-    ResourceID effect_id,
+    ResourceId param_id,
+    ResourceId effect_id,
     unsigned int index) {
   EffectD3D9 *effect = effects_.Get(effect_id);
   if (!effect) return BufferSyncInterface::kParseInvalidArguments;
   EffectParamD3D9 *param = effect->CreateParam(index);
   if (!param) return BufferSyncInterface::kParseInvalidArguments;
   effect_params_.Assign(param_id, param);
   return BufferSyncInterface::kParseNoError;
 }
 
 BufferSyncInterface::ParseError GAPID3D9::CreateParamByName(
-    ResourceID param_id,
-    ResourceID effect_id,
+    ResourceId param_id,
+    ResourceId effect_id,
     unsigned int size,
     const void *name) {
   EffectD3D9 *effect = effects_.Get(effect_id);
   if (!effect) return BufferSyncInterface::kParseInvalidArguments;
   std::string string_name(static_cast<const char *>(name), size);
   EffectParamD3D9 *param = effect->CreateParamByName(string_name.c_str());
   if (!param) return BufferSyncInterface::kParseInvalidArguments;
   effect_params_.Assign(param_id, param);
   return BufferSyncInterface::kParseNoError;
 }
 
-BufferSyncInterface::ParseError GAPID3D9::DestroyParam(ResourceID id) {
+BufferSyncInterface::ParseError GAPID3D9::DestroyParam(ResourceId id) {
   return effect_params_.Destroy(id) ?
       BufferSyncInterface::kParseNoError :
       BufferSyncInterface::kParseInvalidArguments;
 }
 
 BufferSyncInterface::ParseError GAPID3D9::SetParamData(
-    ResourceID id,
+    ResourceId id,
     unsigned int size,
     const void *data) {
   EffectParamD3D9 *param = effect_params_.Get(id);
   if (!param) return BufferSyncInterface::kParseInvalidArguments;
   return param->SetData(this, size, data) ?
       BufferSyncInterface::kParseNoError :
       BufferSyncInterface::kParseInvalidArguments;
 }
 
 BufferSyncInterface::ParseError GAPID3D9::GetParamDesc(
-    ResourceID id,
+    ResourceId id,
     unsigned int size,
     void *data) {
   EffectParamD3D9 *param = effect_params_.Get(id);
   if (!param) return BufferSyncInterface::kParseInvalidArguments;
   return param->GetDesc(size, data) ?
       BufferSyncInterface::kParseNoError :
       BufferSyncInterface::kParseInvalidArguments;
 }
 
 // Gets the stream count from the effect and stores it in the memory buffer.
 BufferSyncInterface::ParseError GAPID3D9::GetStreamCount(
-    ResourceID id,
+    ResourceId id,
     unsigned int size,
     void *data) {
   EffectD3D9 *effect = effects_.Get(id);
   if (!effect || size < sizeof(Uint32))  // NOLINT
     return BufferSyncInterface::kParseInvalidArguments;
   *static_cast<Uint32 *>(data) = effect->GetStreamCount();
   return BufferSyncInterface::kParseNoError;
 }
 
 BufferSyncInterface::ParseError GAPID3D9::GetStreamDesc(
-    ResourceID id,
+    ResourceId id,
     unsigned int index,
     unsigned int size,
     void *data) {
   EffectD3D9 *effect = effects_.Get(id);
   if (!effect) return BufferSyncInterface::kParseInvalidArguments;
   return effect->GetStreamDesc(index, size, data) ?
       BufferSyncInterface::kParseNoError :
       BufferSyncInterface::kParseInvalidArguments;
 }
 
@@ skipping 13 matching lines @@
   DCHECK(validate_effect_);
   DCHECK(!current_effect_);
   current_effect_ = effects_.Get(current_effect_id_);
   if (!current_effect_) return false;
   validate_effect_ = false;
   return current_effect_->Begin(this);
 }
 
 }  // namespace command_buffer
 }  // namespace o3d