mozart: Port the spinning cube example.

examples/ui/spinning_cube/spinning_cube_view.cc

+// Copyright 2013 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 <GLES2/gl2.h>
+#include <GLES2/gl2extmojo.h>
+#include <MGL/mgl.h>
+
+#include "base/message_loop/message_loop.h"
+#include "examples/ui/spinning_cube/spinning_cube_view.h"
+
+namespace examples {
+
+SpinningCubeView::SpinningCubeView(
+    mojo::ApplicationImpl* app,
+    const mojo::ui::ViewProvider::CreateViewCallback& callback)
+    : callback_(callback),
+      binding_(this),
+      context_owner_(app->shell()),
+      texture_cache_(context_owner_.context(), &resource_returner_),
+      surface_id_namespace_(0),
+      draw_scheduled_(false),
+      weak_ptr_factory_(this) {
+  app->ConnectToService("mojo:surfaces_service", &surfaces_);
+  app->ConnectToService("mojo:view_manager_service", &view_manager_);
+
+  surfaces_->SetResourceReturner(resource_returner_.Pass());
+  surfaces_->GetIdNamespace(
+      base::Bind(&SpinningCubeView::OnSurfaceIdNamespaceAvailable,
+                 base::Unretained(this)));
+
+  InitCube();
+}
+
+SpinningCubeView::~SpinningCubeView() {}
+
+void SpinningCubeView::OnSurfaceIdNamespaceAvailable(uint32_t id_namespace) {
+  surface_id_namespace_ = id_namespace;
+  InitView();
+}
+
+void SpinningCubeView::InitView() {
+  mojo::ui::ViewPtr view;
+  binding_.Bind(mojo::GetProxy(&view));
+  view_manager_->RegisterView(view.Pass(), mojo::GetProxy(&view_host_),
+                              callback_);
+
+  view_host_->GetServiceProvider(mojo::GetProxy(&view_service_provider_));
+}
+
+void SpinningCubeView::OnLayout(mojo::ui::ViewLayoutParamsPtr layout_params,
+                                mojo::Array<uint32_t> children_needing_layout,

[abarth, 2015/10/24 06:17:36]

Should we DCHECK something about |children_needing_layout| ?

[jeffbrown, 2015/10/27 01:58:32]

Not much to DCHECK here.  I think the validator will ensure it's non-null and
it's ok for it to be empty.  We're already assuming the view manager provided a
valid list of children (wouldn't make sense for each client to have to check).

+                                const OnLayoutCallback& callback) {
+  // Create a new surface the first time or if the size has changed.
+  mojo::Size new_size;
+  new_size.width = layout_params->constraints->max_width;
+  new_size.height = layout_params->constraints->max_height;
+  if (!surface_id_ || !size_.Equals(new_size)) {
+    if (!surface_id_) {
+      surface_id_ = mojo::SurfaceId::New();
+      surface_id_->id_namespace = surface_id_namespace_;
+    } else {
+      surfaces_->DestroySurface(surface_id_->local);
+    }
+    surface_id_->local++;
+    size_ = new_size;
+    surfaces_->CreateSurface(surface_id_->local);
+  }
+
+  // Submit the new layout information.
+  mojo::ui::ViewLayoutInfoPtr info = mojo::ui::ViewLayoutInfo::New();
+  info->size = size_.Clone();
+  info->surface_id = surface_id_->Clone();
+  callback.Run(info.Pass());
+
+  // Draw!
+  ScheduleDraw();
+}
+
+void SpinningCubeView::OnChildUnavailable(
+    uint32_t child_key,
+    const OnChildUnavailableCallback& callback) {
+  callback.Run();
+}
+
+void SpinningCubeView::InitCube() {
+  context_owner_.context()->MakeCurrent();
+  cube_.Init();
+  last_draw_ = mojo::GetTimeTicksNow();
+}
+
+void SpinningCubeView::DrawCube() {
+  draw_scheduled_ = false;
+
+  context_owner_.context()->MakeCurrent();
+
+  scoped_ptr<mojo::TextureCache::TextureInfo> texture_info =
+      texture_cache_.GetTexture(size_);
+  if (!texture_info.get()) {
+    LOG(ERROR) << "Could not allocate texture of size " << size_.width << "x"
+               << size_.height;
+    return;
+  }
+
+  scoped_ptr<mojo::GLTexture> texture = texture_info->TakeTexture();
+
+  GLuint fbo = 0u;
+  glGenFramebuffers(1, &fbo);
+  glBindFramebuffer(GL_FRAMEBUFFER, fbo);
+  GLuint depth_buffer = 0u;
+  glGenRenderbuffers(1, &depth_buffer);
+  glBindRenderbuffer(GL_RENDERBUFFER, depth_buffer);
+  glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, size_.width,
+                        size_.height);
+  glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
+                         texture->texture_id(), 0);
+  glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
+                            GL_RENDERBUFFER, depth_buffer);
+  DCHECK_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE),
+            glCheckFramebufferStatus(GL_FRAMEBUFFER));
+  glClearColor(1, 0, 0, 0.5);

[abarth, 2015/10/24 06:17:36]

Should this GL boilerplate go somewhere common (e.g., in |SpinningCube|)?  I
suspect it's duplicated in several places by now.

[jeffbrown, 2015/10/27 01:58:32]

Perhaps.  But I'm hoping this will be replaced by some kind of swap chain /
buffer queue abstraction that does away with it entirely.

+
+  cube_.set_size(size_.width, size_.height);
+
+  MojoTimeTicks now = mojo::GetTimeTicksNow();
+  MojoTimeTicks offset = now - last_draw_;
+  cube_.UpdateForTimeDelta(offset * 0.000001f);
+  last_draw_ = now;
+
+  cube_.Draw();
+
+  glDeleteFramebuffers(1, &fbo);
+  glDeleteRenderbuffers(1, &depth_buffer);
+
+  mojo::FramePtr frame = mojo::TextureUploader::GetUploadFrame(
+      context_owner_.context(), texture_info->resource_id(), texture);
+  surfaces_->SubmitFrame(surface_id_->local, frame.Pass(),
+                         base::Bind(&SpinningCubeView::OnSurfaceSubmitted,
+                                    base::Unretained(this)));
+
+  texture_cache_.NotifyPendingResourceReturn(texture_info->resource_id(),
+                                             texture.Pass());
+}
+
+void SpinningCubeView::OnSurfaceSubmitted() {
+  ScheduleDraw();
+}
+
+void SpinningCubeView::ScheduleDraw() {
+  if (!draw_scheduled_) {
+    draw_scheduled_ = true;
+    base::MessageLoop::current()->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&SpinningCubeView::DrawCube, weak_ptr_factory_.GetWeakPtr()),
+        base::TimeDelta::FromMilliseconds(30));

[abarth, 2015/10/24 06:17:36]

Here you're using a delay but in |launcher| you go right away when
OnSurfaceSubmitted is called.  Does that mean the |launcher| will submit frames
faster than vsync?

[jeffbrown, 2015/10/27 01:58:32]

Ahh, I should add a comment on this.  This is to keep spinning cube from
completely overwhelming X11 today.

+  }
+}
+
+}  // namespace examples