Adding GetStreamInfo functionality (and passing corresponding unit test).

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 51 matching lines @@
                   reinterpret_cast<wchar_t*>(&hLocal),
                   0,
                   NULL);
     wchar_t* msg = reinterpret_cast<wchar_t*>(LocalLock(hLocal));
     LOG(ERROR) << "Failed to compile effect: " << msg;
     LocalFree(hLocal);
   }
 }
 
 EffectD3D9::EffectD3D9(ID3DXEffect *d3d_effect,
-                       ID3DXConstantTable *fs_constant_table)
+                       ID3DXConstantTable *fs_constant_table,
+                       IDirect3DVertexShader9 *d3d_vertex_shader)
     : d3d_effect_(d3d_effect),
       fs_constant_table_(fs_constant_table),
+      d3d_vertex_shader_(d3d_vertex_shader),
       sync_parameters_(false) {
   for (unsigned int i = 0; i < kMaxSamplerUnits; ++i) {
     samplers_[i] = kInvalidResource;
   }
+  SetStreams();
 }
 // Releases the D3D effect.
 EffectD3D9::~EffectD3D9() {
   for (ParamList::iterator it = params_.begin(); it != params_.end(); ++it) {
     (*it)->ResetEffect();
   }
   DCHECK(d3d_effect_);
   d3d_effect_->Release();
   DCHECK(fs_constant_table_);
   fs_constant_table_->Release();
+  DCHECK(d3d_vertex_shader_);
+  d3d_vertex_shader_->Release();
 }
 
 // Compiles the effect, and checks that the effect conforms to what we expect
 // (no extra technique or pass in the effect code, since one is implicitly added
 // using the program entry points) and that it validates. If successful, wrap
 // the D3D effect into a new EffectD3D9.
 EffectD3D9 *EffectD3D9::Create(GAPID3D9 *gapi,
                                const String& effect_code,
                                const String& vertex_program_entry,
                                const String& fragment_program_entry) {
@@ skipping 46 matching lines @@
   D3DXPASS_DESC pass_desc;
   HR(d3d_effect->GetPassDesc(pass, &pass_desc));
   ID3DXConstantTable *table = NULL;
   HR(D3DXGetShaderConstantTable(pass_desc.pPixelShaderFunction,
                                 &table));
   if (!table) {
     LOG(ERROR) << "Could not get the constant table.";
     d3d_effect->Release();
     return NULL;
   }
-  return new EffectD3D9(d3d_effect, table);
+  IDirect3DVertexShader9 *d3d_vertex_shader = NULL;
+  HR(device->CreateVertexShader(pass_desc.pVertexShaderFunction,
+                                &d3d_vertex_shader));
+  if (!d3d_vertex_shader) {
+    d3d_effect->Release();
+    table->Release();
+    DLOG(ERROR) << "Failed to create vertex shader";
+    return NULL;
+  }
+
+  return new EffectD3D9(d3d_effect, table, d3d_vertex_shader);
 }
 
 // Begins rendering with the effect, setting all the appropriate states.
 bool EffectD3D9::Begin(GAPID3D9 *gapi) {
   UINT numpasses;
   HR(d3d_effect_->Begin(&numpasses, 0));
   HR(d3d_effect_->BeginPass(0));
   sync_parameters_ = false;
   return SetSamplers(gapi);
 }
 
 // Terminates rendering with the effect, resetting all the appropriate states.
 void EffectD3D9::End(GAPID3D9 *gapi) {
   HR(d3d_effect_->EndPass());
   HR(d3d_effect_->End());
 }
 
 // Gets the parameter count from the D3D effect description.
 unsigned int EffectD3D9::GetParamCount() {
   D3DXEFFECT_DESC effect_desc;
   HR(d3d_effect_->GetDesc(&effect_desc));
   return effect_desc.Parameters;
 }
 
+// Gets the number of input streams from the shader.
+unsigned int EffectD3D9::GetStreamCount() {
+  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;
         case D3DXPC_VECTOR:
           switch (desc.Columns) {
@@ skipping 85 matching lines @@
     SamplerD3D9 *sampler = gapi->GetSampler(samplers_[i]);
     if (sampler) {
       result &= sampler->ApplyStates(gapi, i);
     } else {
       HR(d3d_device->SetTexture(i, NULL));
     }
   }
   return result;
 }
 
+bool EffectD3D9::SetStreams() {
+  if (!d3d_vertex_shader_) {
+    return false;
+  }
+  UINT size;
+  d3d_vertex_shader_->GetFunction(NULL, &size);
+  scoped_array<DWORD> function(new DWORD[size]);
+  d3d_vertex_shader_->GetFunction(function.get(), &size);
+
+  UINT num_semantics;
+  HR(D3DXGetShaderInputSemantics(function.get(),
+                                 NULL,
+                                 &num_semantics));
+  scoped_array<D3DXSEMANTIC> semantics(new D3DXSEMANTIC[num_semantics]);
+  HR(D3DXGetShaderInputSemantics(function.get(),
+                                 semantics.get(),
+                                 &num_semantics));
+
+  streams_.resize(num_semantics);
+  for (UINT i = 0; i < num_semantics; ++i) {
+    vertex_struct::Semantic semantic;
+    unsigned int semantic_index;
+    if (D3DSemanticToCBSemantic(static_cast<D3DDECLUSAGE>(semantics[i].Usage),
+                                static_cast<int>(semantics[i].UsageIndex),
+                                &semantic, &semantic_index)) {
+      streams_[i].semantic = semantic;
+      streams_[i].semantic_index = semantic_index;
+    }
+  }
+  return true;
+}
+
 void EffectD3D9::LinkParam(EffectParamD3D9 *param) {
   params_.push_back(param);
 }
 
 void EffectD3D9::UnlinkParam(EffectParamD3D9 *param) {
   std::remove(params_.begin(), params_.end(), param);
 }
 
+// Fills the Desc structure, appending name and semantic if any, and if enough
+// room is available in the buffer.
+bool EffectD3D9::GetStreamDesc(unsigned int index,
+                               unsigned int size,
+                               void *data) {
+  using effect_stream::Desc;
+  if (size < sizeof(Desc))  // NOLINT
+    return false;
+
+  Desc stream = streams_[index];
+  Desc *desc = static_cast<Desc *>(data);
+  memset(desc, 0, sizeof(*desc));
+  desc->semantic = stream.semantic;
+  desc->semantic_index = stream.semantic_index;

[Antoine Labour, 2009/07/06 23:48:12]

how about simply *desc = streams_[index]; instead of lines 354, 356-358

+  return true;
+}
+
 EffectParamD3D9::EffectParamD3D9(effect_param::DataType data_type,
                                  EffectD3D9 *effect,
                                  D3DXHANDLE handle)
     : EffectParam(data_type),
       effect_(effect),
       handle_(handle),
       sampler_units_(NULL),
       sampler_unit_count_(0) {
   DCHECK(effect_);
   effect_->LinkParam(this);
@@ skipping 249 matching lines @@
     ResourceID id,
     unsigned int size,
     void *data) {
   EffectParamD3D9 *param = effect_params_.Get(id);
   if (!param) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
   return param->GetDesc(size, data) ?
       BufferSyncInterface::PARSE_NO_ERROR :
       BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
 }
 
+// Gets the stream count from the effect and store it in the memory buffer.
+BufferSyncInterface::ParseError GAPID3D9::GetStreamCount(
+    ResourceID id,
+    unsigned int size,
+    void *data) {
+  EffectD3D9 *effect = effects_.Get(id);
+  if (!effect || size < sizeof(Uint32))  // NOLINT
+    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  *static_cast<Uint32 *>(data) = effect->GetStreamCount();
+  return BufferSyncInterface::PARSE_NO_ERROR;
+}
+
+BufferSyncInterface::ParseError GAPID3D9::GetStreamDesc(
+    ResourceID id,
+    unsigned int index,
+    unsigned int size,
+    void *data) {
+  EffectD3D9 *effect = effects_.Get(id);
+  if (!effect) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  return effect->GetStreamDesc(index, size, data) ?
+      BufferSyncInterface::PARSE_NO_ERROR :
+      BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+}
+
+
 // If the current effect is valid, call End on it, and tag for revalidation.
 void GAPID3D9::DirtyEffect() {
   if (validate_effect_) return;
   DCHECK(current_effect_);
   current_effect_->End(this);
   current_effect_ = NULL;
   validate_effect_ = true;
 }
 
 // Gets the current effect, and calls Begin on it (if successful).
 // Should only be called if the current effect is not valid.
 bool GAPID3D9::ValidateEffect() {
   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