1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
|
// Copyright 2014 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 "ppapi/c/pp_errors.h"
#include "ppapi/cpp/core.h"
#include "ppapi/cpp/graphics_3d.h"
#include "ppapi/cpp/graphics_3d_client.h"
#include "ppapi/cpp/input_event.h"
#include "ppapi/cpp/instance.h"
#include "ppapi/cpp/module.h"
#include "ppapi/cpp/rect.h"
#include "spinning_cube.hpp"
#include "ppapi/lib/gl/gles2/gl2ext_ppapi.h"
#include "ppapi/utility/completion_callback_factory.h"
// Use assert as a makeshift CHECK, even in non-debug mode.
// Since <assert.h> redefines assert on every inclusion (it doesn't use
// include-guards), make sure this is the last file #include'd in this file.
#undef NDEBUG
#include <assert.h>
#include <stdint.h>
#include <stdio.h>
namespace {
class DemoInstance : public pp::Instance, public pp::Graphics3DClient {
public:
DemoInstance(PP_Instance instance);
virtual ~DemoInstance();
// pp::Instance implementation (see PPP_Instance).
virtual bool Init(uint32_t argc, const char* argn[], const char* argv[]);
virtual void DidChangeView(const pp::Rect& position,
const pp::Rect& clip);
virtual bool HandleInputEvent(const pp::InputEvent& event) {
// TODO(yzshen): Handle input events.
return true;
}
// pp::Graphics3DClient implementation.
virtual void Graphics3DContextLost();
private:
// GL-related functions.
void InitGL(int32_t result);
void Paint(int32_t result);
pp::Size plugin_size_;
pp::CompletionCallbackFactory<DemoInstance> callback_factory_;
// Owned data.
pp::Graphics3D* context_;
SpinningCube cube_;
};
DemoInstance::DemoInstance(PP_Instance instance)
: pp::Instance(instance),
pp::Graphics3DClient(this),
callback_factory_(this),
context_(NULL) {
printf("DemoInstance created\n");
}
DemoInstance::~DemoInstance() {
assert(glTerminatePPAPI());
delete context_;
printf("DemoInstance destroyed\n");
}
bool DemoInstance::Init(uint32_t /*argc*/,
const char* /*argn*/[],
const char* /*argv*/[]) {
printf("Init\n");
RequestInputEvents(PP_INPUTEVENT_CLASS_MOUSE);
return !!glInitializePPAPI(pp::Module::Get()->get_browser_interface());
}
void DemoInstance::DidChangeView(
const pp::Rect& position, const pp::Rect& /*clip*/) {
printf("didchangeview\n");
if (position.width() == 0 || position.height() == 0)
return;
plugin_size_ = position.size();
// Initialize graphics.
InitGL(0);
}
void DemoInstance::Graphics3DContextLost() {
printf("Graphics3dcontextlost\n");
delete context_;
context_ = NULL;
pp::CompletionCallback cb = callback_factory_.NewCallback(
&DemoInstance::InitGL);
pp::Module::Get()->core()->CallOnMainThread(0, cb, 0);
}
void DemoInstance::InitGL(int32_t /*result*/) {
printf("InitGL\n");
assert(plugin_size_.width() && plugin_size_.height());
if (context_) {
context_->ResizeBuffers(plugin_size_.width(), plugin_size_.height());
return;
}
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,
};
context_ = new pp::Graphics3D(this, context_attributes);
assert(!context_->is_null());
assert(BindGraphics(*context_));
glSetCurrentContextPPAPI(context_->pp_resource());
cube_.Init(plugin_size_.width(), plugin_size_.height());
Paint(PP_OK);
}
void DemoInstance::Paint(int32_t result) {
printf("Paint\n");
if (result != PP_OK || !context_)
return;
cube_.UpdateForTimeDelta(0.02f);
cube_.Draw();
context_->SwapBuffers(callback_factory_.NewCallback(&DemoInstance::Paint));
}
// This object is the global object representing this plugin library as long
// as it is loaded.
class DemoModule : public pp::Module {
public:
DemoModule() : Module() {}
virtual ~DemoModule() {}
virtual pp::Instance* CreateInstance(PP_Instance instance) {
printf("DemoModule\n");
return new DemoInstance(instance);
}
};
}
// anonymous namespace
namespace pp {
// Factory function for your specialization of the Module object.
Module* CreateModule() {
printf("CreateModule\n");
return new DemoModule();
}
} // namespace pp
|
