Rendering Daydream controller in a fixed position.

chrome/browser/android/vr_shell/gltf_parser.cc

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/android/vr_shell/gltf_parser.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback_helpers.h"
 #include "base/files/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "net/base/data_url.h"
 #include "net/base/filename_util.h"
 #include "url/gurl.h"
 
 namespace vr_shell {
 
 GltfParser::GltfParser() {}
 
 GltfParser::~GltfParser() = default;
 
 std::unique_ptr<gltf::Asset> GltfParser::Parse(
     const base::DictionaryValue& dict,
+    std::vector<std::unique_ptr<gltf::Buffer>>* buffers,
     const base::FilePath& path) {
   path_ = path;
   asset_ = base::MakeUnique<gltf::Asset>();
 
   base::ScopedClosureRunner runner(
       base::Bind(&GltfParser::Clear, base::Unretained(this)));
 
-  if (!ParseInternal(dict))
+  if (!ParseInternal(dict, buffers))
     return nullptr;
 
   return std::move(asset_);
 }
 
 std::unique_ptr<gltf::Asset> GltfParser::Parse(
-    const base::FilePath& gltf_path) {
+    const base::FilePath& gltf_path,
+    std::vector<std::unique_ptr<gltf::Buffer>>* buffers) {
   JSONFileValueDeserializer json_deserializer(gltf_path);
   int error_code;
   std::string error_msg;
   auto asset_value = json_deserializer.Deserialize(&error_code, &error_msg);
   if (!asset_value)
     return nullptr;
   base::DictionaryValue* asset;
   if (!asset_value->GetAsDictionary(&asset))
     return nullptr;
-  return Parse(*asset, gltf_path);
+  return Parse(*asset, buffers, gltf_path);
 }
 
-bool GltfParser::ParseInternal(const base::DictionaryValue& dict) {
+bool GltfParser::ParseInternal(
+    const base::DictionaryValue& dict,
+    std::vector<std::unique_ptr<gltf::Buffer>>* buffers) {
   std::string gltf_version;
   if (!dict.GetString("asset.version", &gltf_version) || gltf_version != "1.0")
     return false;
 
   const base::DictionaryValue* sub_dict;
-  if (dict.GetDictionary("buffers", &sub_dict) && !SetBuffers(*sub_dict))
+  if (dict.GetDictionary("buffers", &sub_dict) &&
+      !SetBuffers(*sub_dict, buffers))
     return false;
   if (dict.GetDictionary("bufferViews", &sub_dict) &&
       !SetBufferViews(*sub_dict))
     return false;
   if (dict.GetDictionary("accessors", &sub_dict) && !SetAccessors(*sub_dict))
     return false;
   if (dict.GetDictionary("meshes", &sub_dict) && !SetMeshes(*sub_dict))
     return false;
   if (dict.GetDictionary("nodes", &sub_dict) && !SetNodes(*sub_dict))
     return false;
   if (dict.GetDictionary("scenes", &sub_dict) && !SetScenes(*sub_dict))
     return false;
 
   std::string scene_key;
   if (dict.GetString("scene", &scene_key)) {
     auto scene_it = scene_ids_.find(scene_key);
     if (scene_it == scene_ids_.end())
       return false;
     asset_->SetMainScene(asset_->GetScene(scene_it->second));
   }
 
   return true;
 }
 
-bool GltfParser::SetBuffers(const base::DictionaryValue& dict) {
+bool GltfParser::SetBuffers(
+    const base::DictionaryValue& dict,
+    std::vector<std::unique_ptr<gltf::Buffer>>* buffers) {
+  buffers->clear();
   for (base::DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) {
     const base::DictionaryValue* buffer_dict;
     if (!it.value().GetAsDictionary(&buffer_dict))
       return false;
 
     std::string uri_str;
     if (!buffer_dict->GetString("uri", &uri_str))
       return false;
     auto buffer = ProcessUri(uri_str);
     if (!buffer)
       return false;
 
     int byte_length;
     if (buffer_dict->GetInteger("byteLength", &byte_length) &&
         static_cast<int>(buffer->length()) != byte_length)
       return false;
 
-    buffer_ids_[it.key()] = asset_->AddBuffer(std::move(buffer));
+    buffer_ids_[it.key()] = buffers->size();
+    buffers->push_back(std::move(buffer));
   }
   return true;
 }
 
 std::unique_ptr<gltf::Buffer> GltfParser::ProcessUri(
     const std::string& uri_str) {
   auto uri = path_.empty() ? GURL(uri_str)
                            : net::FilePathToFileURL(path_).Resolve(uri_str);
   if (!uri.is_valid())
     return nullptr;
@@ skipping 21 matching lines @@
     if (!it.value().GetAsDictionary(&buffer_view_dict))
       return false;
 
     auto buffer_view = base::MakeUnique<gltf::BufferView>();
     std::string buffer_key;
     if (!buffer_view_dict->GetString("buffer", &buffer_key))
       return false;
     auto buffer_it = buffer_ids_.find(buffer_key);
     if (buffer_it == buffer_ids_.end())
       return false;
-    buffer_view->buffer = asset_->GetBuffer(buffer_it->second);
+    buffer_view->buffer = buffer_it->second;
     if (!buffer_view_dict->GetInteger("byteOffset", &buffer_view->byte_offset))
       return false;
     buffer_view_dict->GetInteger("byteLength", &buffer_view->byte_length);
     buffer_view_dict->GetInteger("target", &buffer_view->target);
 
     buffer_view_ids_[it.key()] = asset_->AddBufferView(std::move(buffer_view));
   }
   return true;
 }
 
@@ skipping 163 matching lines @@
   path_.clear();
   buffer_ids_.clear();
   buffer_view_ids_.clear();
   accessor_ids_.clear();
   node_ids_.clear();
   mesh_ids_.clear();
   scene_ids_.clear();
 }
 
 }  // namespace vr_shell