Add ClientInfo...

core/cross/buffer.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 16 matching lines @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 
 // This file contains the definitions of Buffer, VertexBuffer and IndexBuffer.
 
 #include "core/cross/precompile.h"
 #include "core/cross/buffer.h"
+#include "core/cross/client_info.h"
 #include "core/cross/renderer.h"
 #include "core/cross/features.h"
 #include "core/cross/error.h"
 #include "import/cross/memory_stream.h"
 #include "import/cross/raw_data.h"
 
 namespace o3d {
 
 O3D_DEFN_CLASS(Buffer, NamedObject);
 O3D_DEFN_CLASS(VertexBufferBase, Buffer);
@@ skipping 54 matching lines @@
       features_(service_locator->GetService<Features>()),
       access_mode_(NONE),
       field_change_count_(0),
       total_components_(0),
       stride_(0),
       num_elements_(0),
       lock_count_(0) {
 }
 
 Buffer::~Buffer() {
+  AdjustBufferMemoryInfo(false);
   for (unsigned ii = 0; ii < fields_.size(); ++ii) {
     if (!fields_[ii].IsNull()) {
       fields_[ii]->ClearBuffer();
     }
   }
 }
 
+void Buffer::AdjustBufferMemoryInfo(bool add) {
+  // Only count VRAM/hardware buffers.
+  if (IsA(VertexBuffer::GetApparentClass()) ||
+      IsA(IndexBuffer::GetApparentClass())) {
+    size_t size_in_bytes = num_elements_ * stride_;
+    ServiceDependency<ClientInfoManager> client_info_manager(service_locator());

[apatrick, 2009/07/09 18:22:00]

You don't need to use a ServiceDependency here. GetService() is simpler. A
ServiceDependency is for when you need to connect with a service that
potentially hasn't been created yet or will change in the future.

+    client_info_manager->AdjustBufferMemoryUsed(
+        static_cast<int>(size_in_bytes) * (add ? 1 : -1));
+  }
+}
+
 bool Buffer::AllocateElements(unsigned num_elements) {
   if (access_mode_ != NONE) {
     O3D_ERROR(service_locator()) << "Attempt to allocate locked Buffer '"
                                  << name() << "'";
     return false;
   }
 
   if (stride_ == 0) {
     O3D_ERROR(service_locator())
         << "No fields have been set on Buffer '" << name() << "'";
@@ skipping 17 matching lines @@
   }
 
   size_t size_in_bytes = num_elements * stride_;
 
   if (size_in_bytes == 0) {
     O3D_ERROR(service_locator())
         << "Attempt to allocate zero bytes for Buffer '" << name() << "'";
     return false;
   }
 
+  bool success = true;
   if (!ConcreteAllocate(size_in_bytes)) {
-    num_elements_ = 0;
-    return false;
+    num_elements = 0;
+    size_in_bytes = 0;
+    success = false;
   }
 
   num_elements_ = num_elements;
-  return true;
+
+  AdjustBufferMemoryInfo(true);
+
+  return success;
 }
 
 void Buffer::Free() {
   if (num_elements_ > 0) {
     ConcreteFree();
+    AdjustBufferMemoryInfo(false);
     num_elements_ = 0;
   }
 }
 
 bool Buffer::ReshuffleBuffer(unsigned int new_stride, Field* field_to_remove) {
   if (new_stride == 0) {
+    AdjustBufferMemoryInfo(false);
     ConcreteFree();
+    stride_ = 0;
     return true;
   }
   if (num_elements_) {
     size_t size_in_bytes = num_elements_ * new_stride;
     std::vector<uint8> temp(size_in_bytes);
 
     // Copy old fields into new buffer.
     {
       BufferLockHelper helper(this);
       void* source = helper.GetData(Buffer::READ_ONLY);
@@ skipping 11 matching lines @@
                     PointerFromVoidPointer<void*>(&temp[0], offset),
                     new_stride);
           field->set_offset(offset);
           offset += field->size();
         }
       }
     }
     // Copy the reorganized data into a new buffer.
     {
       ConcreteFree();
+      AdjustBufferMemoryInfo(false);
       if (!ConcreteAllocate(size_in_bytes)) {
         num_elements_ = 0;
         O3D_ERROR(service_locator())
             << "Couldn't allocate buffer of size: " << size_in_bytes
             << " for Buffer '" << name() << "'";
         return false;
       }
       // stride_ must be set before GetData is called so that the proper size
       // buffer is allocated. We also need to set it after this function is
       // is completed (see CreateField, RemoveField) for when we create a new
       // buffer with no fields yet.
       stride_ = new_stride;
+      AdjustBufferMemoryInfo(true);
       BufferLockHelper helper(this);
       void* destination = helper.GetData(Buffer::WRITE_ONLY);
       if (!destination) {
         return false;
       }
       memcpy(destination, &temp[0], size_in_bytes);
     }
   }
   return true;
 }
@@ skipping 346 matching lines @@
     locked_ = buffer_->Lock(access_mode, &data_);
     if (!locked_) {
       O3D_ERROR(buffer_->service_locator())
           << "Unable to lock buffer '" << buffer_->name() << "'";
     }
   }
   return data_;
 }
 
 }  // namespace o3d