Add an API to allow JavaScript to determine the framerate of individual dynam...

core/cross/texture_base.h

 /*
  * 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 99 matching lines @@
   // Gets the levels.
   int levels() const {
     return levels_param_->value();
   }
 
   // Gets the format of the texture resource.
   Format format() const {
     return format_;
   }
 
+  int update_count() {
+    return update_count_;
+  }
+
+  int render_count() {
+    CheckLastTextureUpdateRendered();
+    return render_count_;
+  }
+
   bool render_surfaces_enabled() const {
     return render_surfaces_enabled_;
   }
 
   // Generates mips.
   virtual void GenerateMips(int source_level, int num_levels) = 0;
 
   // Gets a RGBASwizzleIndices that contains a mapping from
   // RGBA to the internal format used by the graphics API.
   virtual const RGBASwizzleIndices& GetABGR32FSwizzleIndices() = 0;
 
   // Gets a weak pointer to us.
   WeakPointerType GetWeakPointer() const {
     return weak_pointer_manager_.GetWeakPointer();
   }
 
  protected:
   void set_levels(int levels) {
     levels_param_->set_read_only_value(levels);
   }
 
   void set_format(Format format) {
     format_ = format;
   }
 
+  void TextureUpdated();
+
+  // The global renderer.
+  Renderer* renderer_;
+

[zhurunz, 2010/12/04 01:29:49]

static is better?

[Tristan Schmelcher 2, 2010/12/06 18:44:59]

Static won't work. Technically it's not a global instance--there's just only one
per ServiceLocator. The ServiceLocator is basically a container for singleton
instances, so that you can get all the benefits of singletons but still be able
to have multiple independent copies of the program in the same address space.
Since some browsers have in-proc plugins, there may actually be more than one
Renderer in the process, so we can't use a single static field.

I've removed the comment to avoid confusion.

  private:
+  void CheckLastTextureUpdateRendered();
+
   // The number of mipmap levels contained in this texture.
   ParamInteger::Ref levels_param_;
 
   // true if all the alpha values in this texture are 1.0.
   bool alpha_is_one_;
 
   // The data format of each pixel.
   Format format_;
 
   // Manager for weak pointers to us.
   WeakPointerType::WeakPointerManager weak_pointer_manager_;
 
   bool render_surfaces_enabled_;
 
+  // Counting of frames, to allow the page to determine the framerate of dynamic
+  // textures.
+  bool has_unrendered_update_;
+  int last_render_frame_count_;
+  int update_count_;
+  int render_count_;
+
   O3D_DECL_CLASS(Texture, ParamObject);
   DISALLOW_COPY_AND_ASSIGN(Texture);
 };
 
 class ParamTexture : public TypedRefParam<Texture> {
  public:
   typedef SmartPointer<ParamTexture> Ref;
 
   ParamTexture(ServiceLocator* service_locator, bool dynamic, bool read_only)
       : TypedRefParam<Texture>(service_locator, dynamic, read_only) {}
 
  private:
   friend class IClassManager;
   static ObjectBase::Ref Create(ServiceLocator* service_locator);
 
   O3D_DECL_CLASS(ParamTexture, RefParamBase);
   DISALLOW_COPY_AND_ASSIGN(ParamTexture);
 };
 
 }  // namespace o3d
 
 #endif  // O3D_CORE_CROSS_TEXTURE_BASE_H_