Migrate gles2 from {Surface,Context}3D to Graphics3D.

ppapi/examples/gles2/gles2.cc

 // Copyright (c) 2011 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 <string.h>
 
 #include <iostream>
 #include <sstream>
 #include <list>
 #include <map>
 #include <set>
 #include <vector>
 
 #include "ppapi/c/dev/ppb_console_dev.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/ppb_opengles2.h"
-#include "ppapi/cpp/dev/context_3d_dev.h"
-#include "ppapi/cpp/dev/surface_3d_dev.h"
 #include "ppapi/cpp/dev/video_decoder_client_dev.h"
 #include "ppapi/cpp/dev/video_decoder_dev.h"
 #include "ppapi/cpp/graphics_3d.h"
 #include "ppapi/cpp/graphics_3d_client.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/rect.h"
 #include "ppapi/cpp/var.h"
 #include "ppapi/examples/gles2/testdata.h"
 #include "ppapi/lib/gl/include/GLES2/gl2.h"
@@ skipping 18 matching lines @@
   GLES2DemoInstance(PP_Instance instance, pp::Module* module);
   virtual ~GLES2DemoInstance();
 
   // pp::Instance implementation (see PPP_Instance).
   virtual void DidChangeView(const pp::Rect& position,
                              const pp::Rect& clip_ignored);
 
   // pp::Graphics3DClient implementation.
   virtual void Graphics3DContextLost() {
     // TODO(vrk/fischman): Properly reset after a lost graphics context.  In
-    // particular need to delete context_ & surface_ and re-create textures.
+    // particular need to delete context_ and re-create textures.
     // Probably have to recreate the decoder from scratch, because old textures
     // can still be outstanding in the decoder!
     assert(!"Unexpectedly lost graphics context");
   }
 
   // pp::VideoDecoderClient_Dev implementation.
   virtual void ProvidePictureBuffers(PP_Resource decoder,
                                      uint32_t req_num_of_bufs,
                                      const PP_Size& dimensions);
   virtual void DismissPictureBuffer(PP_Resource decoder,
@@ skipping 87 matching lines @@
   PP_TimeTicks last_swap_request_ticks_;
   PP_TimeTicks swap_ticks_;
   pp::CompletionCallbackFactory<GLES2DemoInstance> callback_factory_;
 
   // Unowned pointers.
   const struct PPB_Console_Dev* console_if_;
   const struct PPB_Core* core_if_;
   const struct PPB_OpenGLES2* gles2_if_;
 
   // Owned data.
-  pp::Context3D_Dev* context_;
-  pp::Surface3D_Dev* surface_;
+  pp::Graphics3D* context_;
   typedef std::map<int, DecoderClient*> Decoders;
   Decoders video_decoders_;
 };
 
 GLES2DemoInstance::DecoderClient::DecoderClient(GLES2DemoInstance* gles2,
                                               pp::VideoDecoder_Dev* decoder)
     : gles2_(gles2), decoder_(decoder), callback_factory_(this),
       next_picture_buffer_id_(0),
       next_bitstream_buffer_id_(0), encoded_data_next_pos_to_decode_(0) {
 };
@@ skipping 15 matching lines @@
   picture_buffers_by_id_.clear();
 }
 
 GLES2DemoInstance::GLES2DemoInstance(PP_Instance instance, pp::Module* module)
     : pp::Instance(instance), pp::Graphics3DClient(this),
       pp::VideoDecoderClient_Dev(this),
       num_frames_rendered_(0),
       first_frame_delivered_ticks_(-1),
       swap_ticks_(0),
       callback_factory_(this),
-      context_(NULL),
-      surface_(NULL) {
+      context_(NULL) {
   assert((console_if_ = static_cast<const struct PPB_Console_Dev*>(
       module->GetBrowserInterface(PPB_CONSOLE_DEV_INTERFACE))));
   assert((core_if_ = static_cast<const struct PPB_Core*>(
       module->GetBrowserInterface(PPB_CORE_INTERFACE))));
   assert((gles2_if_ = static_cast<const struct PPB_OpenGLES2*>(
       module->GetBrowserInterface(PPB_OPENGLES2_INTERFACE))));
 }
 
 GLES2DemoInstance::~GLES2DemoInstance() {
   for (Decoders::iterator it = video_decoders_.begin();
        it != video_decoders_.end(); ++it) {
     delete it->second;
   }
   video_decoders_.clear();
-  delete surface_;
   delete context_;
 }
 
 void GLES2DemoInstance::DidChangeView(
     const pp::Rect& position, const pp::Rect& clip_ignored) {
   if (position.width() == 0 || position.height() == 0)
     return;
   if (plugin_size_.width()) {
     assert(position.size() == plugin_size_);
     return;
@@ skipping 151 matching lines @@
   const PP_PictureBuffer_Dev& buffer =
       client->GetPictureBufferById(picture.picture_buffer_id);
   assert(!is_painting_);
   is_painting_ = true;
   int x = 0;
   int y = 0;
   if (client != video_decoders_.begin()->second) {
     x = plugin_size_.width() / kNumDecoders;
     y = plugin_size_.height() / kNumDecoders;
   }
+
   gles2_if_->Viewport(context_->pp_resource(), x, y,
                       plugin_size_.width() / kNumDecoders,
                       plugin_size_.height() / kNumDecoders);
   gles2_if_->ActiveTexture(context_->pp_resource(), GL_TEXTURE0);
   gles2_if_->BindTexture(
       context_->pp_resource(), GL_TEXTURE_2D, buffer.texture_id);
   gles2_if_->DrawArrays(context_->pp_resource(), GL_TRIANGLE_STRIP, 0, 4);
   pp::CompletionCallback cb =
       callback_factory_.NewCallback(
           &GLES2DemoInstance::PaintFinished, decoder, buffer.id);
   last_swap_request_ticks_ = core_if_->GetTimeTicks();
-  assert(surface_->SwapBuffers(cb) == PP_OK_COMPLETIONPENDING);
+  assert(context_->SwapBuffers(cb) == PP_OK_COMPLETIONPENDING);
 }
 
 void GLES2DemoInstance::EndOfStream(PP_Resource decoder) {
 }
 
 void GLES2DemoInstance::NotifyError(PP_Resource decoder,
                                     PP_VideoDecodeError_Dev error) {
   LogError(this).s() << "Received error: " << error;
   assert(!"Unexpected error; see stderr for details");
 }
 
 // This object is the global object representing this plugin library as long
 // as it is loaded.
 class GLES2DemoModule : public pp::Module {
  public:
   GLES2DemoModule() : pp::Module() {}
   virtual ~GLES2DemoModule() {}
 
   virtual pp::Instance* CreateInstance(PP_Instance instance) {
     return new GLES2DemoInstance(instance, this);
   }
 };
 
 void GLES2DemoInstance::InitGL() {
   assert(plugin_size_.width() && plugin_size_.height());
   is_painting_ = false;
 
-  assert(!context_ && !surface_);
-  context_ = new pp::Context3D_Dev(*this, 0, pp::Context3D_Dev(), NULL);
-  assert(!context_->is_null());
-
-  int32_t surface_attributes[] = {
+  assert(!context_);
+  int32_t context_attributes[] = {
+    PP_GRAPHICS3DATTRIB_ALPHA_SIZE, 8,
+    PP_GRAPHICS3DATTRIB_BLUE_SIZE, 8,
+    PP_GRAPHICS3DATTRIB_GREEN_SIZE, 8,
+    PP_GRAPHICS3DATTRIB_RED_SIZE, 8,
+    PP_GRAPHICS3DATTRIB_DEPTH_SIZE, 0,
+    PP_GRAPHICS3DATTRIB_STENCIL_SIZE, 0,
+    PP_GRAPHICS3DATTRIB_SAMPLES, 0,
+    PP_GRAPHICS3DATTRIB_SAMPLE_BUFFERS, 0,
     PP_GRAPHICS3DATTRIB_WIDTH, plugin_size_.width(),
     PP_GRAPHICS3DATTRIB_HEIGHT, plugin_size_.height(),
-    PP_GRAPHICS3DATTRIB_NONE
+    PP_GRAPHICS3DATTRIB_NONE,
   };
-  surface_ = new pp::Surface3D_Dev(*this, 0, surface_attributes);
-  assert(!surface_->is_null());
-
-  assert(!context_->BindSurfaces(*surface_, *surface_));
+  context_ = new pp::Graphics3D(this, context_attributes);
+  assert(!context_->is_null());
+  assert(BindGraphics(*context_));
 
   // Clear color bit.
+  gles2_if_->ClearColor(context_->pp_resource(), 1, 0, 0, 1);
   gles2_if_->Clear(context_->pp_resource(), GL_COLOR_BUFFER_BIT);
 
-  assert(BindGraphics(*surface_));
   assertNoGLError();
 
   CreateGLObjects();
 }
 
 void GLES2DemoInstance::PaintFinished(int32_t result, PP_Resource decoder,
                                       int picture_buffer_id) {
+  assert(result == PP_OK);
   swap_ticks_ += core_if_->GetTimeTicks() - last_swap_request_ticks_;
   is_painting_ = false;
   ++num_frames_rendered_;
   if (num_frames_rendered_ % 50 == 0) {
     double elapsed = core_if_->GetTimeTicks() - first_frame_delivered_ticks_;
     double fps = (elapsed > 0) ? num_frames_rendered_ / elapsed : 1000;
     double ms_per_swap = (swap_ticks_ * 1e3) / num_frames_rendered_;
     LogError(this).s() << "Rendered frames: " << num_frames_rendered_
                        << ", fps: " << fps << ", with average ms/swap of: "
                        << ms_per_swap;
   }
   DecoderClient* client = video_decoders_[decoder];
   if (client && client->decoder())
     client->decoder()->ReusePictureBuffer(picture_buffer_id);
   if (!pictures_pending_paint_.empty()) {
     std::pair<PP_Resource, PP_Picture_Dev> decoder_picture =
         pictures_pending_paint_.front();
     pictures_pending_paint_.pop_front();
     PictureReady(decoder_picture.first, decoder_picture.second);
   }
 }
 
 GLuint GLES2DemoInstance::CreateTexture(int32_t width, int32_t height) {
   GLuint texture_id;
   gles2_if_->GenTextures(context_->pp_resource(), 1, &texture_id);
   assertNoGLError();
   // Assign parameters.
   gles2_if_->ActiveTexture(context_->pp_resource(), GL_TEXTURE0);
-  gles2_if_->BindTexture(
-      context_->pp_resource(), GL_TEXTURE_2D, texture_id);
+  gles2_if_->BindTexture(context_->pp_resource(), GL_TEXTURE_2D, texture_id);
   gles2_if_->TexParameteri(
       context_->pp_resource(), GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
       GL_NEAREST);
   gles2_if_->TexParameteri(
       context_->pp_resource(), GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
       GL_NEAREST);
   gles2_if_->TexParameterf(
       context_->pp_resource(), GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,
       GL_CLAMP_TO_EDGE);
   gles2_if_->TexParameterf(
       context_->pp_resource(), GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
       GL_CLAMP_TO_EDGE);
 
-  // Allocate texture.
   gles2_if_->TexImage2D(
       context_->pp_resource(), GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0,
       GL_RGBA, GL_UNSIGNED_BYTE, NULL);
   assertNoGLError();
   return texture_id;
 }
 
 void GLES2DemoInstance::DeleteTexture(GLuint id) {
   gles2_if_->DeleteTextures(context_->pp_resource(), 1, &id);
 }
@@ skipping 22 matching lines @@
   // Create shader program.
   GLuint program = gles2_if_->CreateProgram(context_->pp_resource());
   CreateShader(program, GL_VERTEX_SHADER, kVertexShader, sizeof(kVertexShader));
   CreateShader(
       program, GL_FRAGMENT_SHADER, kFragmentShader, sizeof(kFragmentShader));
   gles2_if_->LinkProgram(context_->pp_resource(), program);
   gles2_if_->UseProgram(context_->pp_resource(), program);
   gles2_if_->DeleteProgram(context_->pp_resource(), program);
   gles2_if_->Uniform1i(
       context_->pp_resource(),
-      gles2_if_->GetAttribLocation(
+      gles2_if_->GetUniformLocation(
           context_->pp_resource(), program, "s_texture"), 0);
   assertNoGLError();
 
   // Assign vertex positions and texture coordinates to buffers for use in
   // shader program.
   static const float kVertices[] = {
     -1, 1, -1, -1, 1, 1, 1, -1,  // Position coordinates.
     0, 1, 0, 0, 1, 1, 1, 0,  // Texture coordinates.
   };
 
@@ skipping 27 matching lines @@
   gles2_if_->DeleteShader(context_->pp_resource(), shader);
 }
 }  // anonymous namespace
 
 namespace pp {
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new GLES2DemoModule();
 }
 }  // namespace pp