1 //
2 // Copyright 2021 The ANGLE Project Authors. All rights reserved.
3 // Use of this source code is governed by a BSD-style license that can be
4 // found in the LICENSE file.
5 //
6 // Demonstrates GLES usage with two contexts, one uploading texture data.
7
8 #include "SampleApplication.h"
9 #include "util/random_utils.h"
10 #include "util/shader_utils.h"
11 #include "util/test_utils.h"
12
13 #include <array>
14 #include <mutex>
15 #include <queue>
16 #include <thread>
17
18 struct TextureAndFence
19 {
20 GLuint textureID;
21 GLsync fenceSync;
22 };
23
24 constexpr GLuint64 kTimeout = 10000000;
25 static constexpr GLint kTextureSize = 2;
26 constexpr size_t kWindowWidth = 400;
27 constexpr size_t kWindowHeight = 300;
28
UpdateThreadLoop(EGLDisplay display,EGLConfig config,EGLContext shareContext,std::mutex * updateThreadMutex,std::queue<TextureAndFence> * updateThreadQueue,std::mutex * mainThreadMutex,std::queue<TextureAndFence> * mainThreadQueue)29 void UpdateThreadLoop(EGLDisplay display,
30 EGLConfig config,
31 EGLContext shareContext,
32 std::mutex *updateThreadMutex,
33 std::queue<TextureAndFence> *updateThreadQueue,
34 std::mutex *mainThreadMutex,
35 std::queue<TextureAndFence> *mainThreadQueue)
36 {
37 angle::RNG rng;
38
39 EGLint contextAttribs[] = {EGL_CONTEXT_MAJOR_VERSION, 3, EGL_NONE};
40 EGLContext context = eglCreateContext(display, config, shareContext, contextAttribs);
41
42 EGLint surfaceAttribs[] = {EGL_NONE};
43 EGLSurface surface = eglCreatePbufferSurface(display, config, surfaceAttribs);
44
45 eglMakeCurrent(display, surface, surface, context);
46
47 for (;;)
48 {
49 bool hasUpdate = false;
50 TextureAndFence textureAndFence;
51
52 {
53 std::lock_guard<std::mutex> lock(*updateThreadMutex);
54 if (!updateThreadQueue->empty())
55 {
56 textureAndFence = updateThreadQueue->back();
57 hasUpdate = true;
58 updateThreadQueue->pop();
59 }
60 }
61
62 if (hasUpdate)
63 {
64 if (textureAndFence.textureID == 0)
65 {
66 // Signal from the main thread to stop execution.
67 break;
68 }
69
70 glClientWaitSync(textureAndFence.fenceSync, 0, kTimeout);
71 glDeleteSync(textureAndFence.fenceSync);
72 glBindTexture(GL_TEXTURE_2D, textureAndFence.textureID);
73
74 std::vector<uint8_t> bytes(3, 0);
75 FillVectorWithRandomUBytes(&rng, &bytes);
76 bytes.push_back(255);
77
78 std::vector<uint8_t> textureData;
79 for (GLint x = 0; x < kTextureSize; ++x)
80 {
81 for (GLint y = 0; y < kTextureSize; ++y)
82 {
83 textureData.insert(textureData.end(), bytes.begin(), bytes.end());
84 }
85 }
86
87 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, kTextureSize, kTextureSize, GL_RGBA,
88 GL_UNSIGNED_BYTE, textureData.data());
89
90 GLsync mainThreadSync = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
91
92 {
93 std::lock_guard<std::mutex> lock(*mainThreadMutex);
94 mainThreadQueue->push({textureAndFence.textureID, mainThreadSync});
95 }
96 }
97
98 angle::Sleep(200);
99 }
100
101 eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
102 eglDestroySurface(display, surface);
103 eglDestroyContext(display, context);
104 }
105
106 class MultipleContextsSample : public SampleApplication
107 {
108 public:
MultipleContextsSample(int argc,char ** argv)109 MultipleContextsSample(int argc, char **argv)
110 : SampleApplication("MultipleContexts", argc, argv, 3, 0, kWindowWidth, kWindowHeight)
111 {}
112
initialize()113 bool initialize() override
114 {
115 // Initialize some textures and send them to the update thread.
116 glGenTextures(kNumTextures, mTextures.data());
117
118 for (GLuint texture : mTextures)
119 {
120 glBindTexture(GL_TEXTURE_2D, texture);
121 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, kTextureSize, kTextureSize, 0, GL_RGBA,
122 GL_UNSIGNED_BYTE, nullptr);
123 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
124 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
125 glBindTexture(GL_TEXTURE_2D, 0);
126 GLsync fenceSync = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
127
128 mUpdateThreadQueue.push({texture, fenceSync});
129 }
130
131 mUpdateThread.reset(new std::thread(UpdateThreadLoop, getDisplay(), getConfig(),
132 getContext(), &mUpdateThreadMutex, &mUpdateThreadQueue,
133 &mMainThreadMutex, &mMainThreadQueue));
134
135 mProgram = CompileProgram(angle::essl1_shaders::vs::Texture2D(),
136 angle::essl1_shaders::fs::Texture2D());
137 glUseProgram(mProgram);
138 glEnableVertexAttribArray(0);
139
140 glGenBuffers(1, &mVertexBuffer);
141 glBindBuffer(GL_ARRAY_BUFFER, mVertexBuffer);
142 glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 2 * 6, nullptr, GL_DYNAMIC_DRAW);
143
144 glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, nullptr);
145
146 return true;
147 }
148
destroy()149 void destroy() override
150 {
151 {
152 // Signal the worker thread to stop execution.
153 std::lock_guard<std::mutex> lock(mUpdateThreadMutex);
154 mUpdateThreadQueue.push({0, 0});
155 }
156
157 for (;;)
158 {
159 {
160 std::lock_guard<std::mutex> mainLock(mMainThreadMutex);
161 if (mMainThreadQueue.empty())
162 {
163 std::lock_guard<std::mutex> updateLock(mUpdateThreadMutex);
164 if (mUpdateThreadQueue.empty())
165 {
166 break;
167 }
168 }
169 else
170 {
171 TextureAndFence textureAndFence = mMainThreadQueue.back();
172 mMainThreadQueue.pop();
173 glClientWaitSync(textureAndFence.fenceSync, 0, kTimeout);
174 glDeleteSync(textureAndFence.fenceSync);
175 }
176 }
177 }
178
179 glDeleteTextures(kNumTextures, mTextures.data());
180 glDeleteProgram(mProgram);
181 glDeleteBuffers(1, &mVertexBuffer);
182 }
183
draw()184 void draw() override
185 {
186 bool hasUpdate = false;
187 TextureAndFence textureAndFence;
188 while (!hasUpdate)
189 {
190 {
191 std::lock_guard<std::mutex> lock(mMainThreadMutex);
192 if (!mMainThreadQueue.empty())
193 {
194 hasUpdate = true;
195 textureAndFence = mMainThreadQueue.back();
196 mMainThreadQueue.pop();
197 }
198 }
199 }
200
201 glClientWaitSync(textureAndFence.fenceSync, 0, kTimeout);
202 glDeleteSync(textureAndFence.fenceSync);
203 glBindTexture(GL_TEXTURE_2D, textureAndFence.textureID);
204
205 constexpr size_t kNumRows = 3;
206 constexpr size_t kNumCols = 4;
207 constexpr size_t kTileHeight = kWindowHeight / kNumRows;
208 constexpr size_t kTileWidth = kWindowWidth / kNumCols;
209
210 size_t tileX = mDrawCount % kNumCols;
211 size_t tileY = (mDrawCount / kNumCols) % kNumRows;
212
213 mDrawCount++;
214
215 GLfloat tileX0 = static_cast<float>(tileX) / static_cast<float>(kNumCols);
216 GLfloat tileY0 = static_cast<float>(tileY) / static_cast<float>(kNumRows);
217 GLfloat tileX1 = tileX0 + static_cast<float>(kTileWidth) / static_cast<float>(kWindowWidth);
218 GLfloat tileY1 =
219 tileY0 + static_cast<float>(kTileHeight) / static_cast<float>(kWindowHeight);
220
221 tileX0 = tileX0 * 2.0f - 1.0f;
222 tileX1 = tileX1 * 2.0f - 1.0f;
223 tileY0 = tileY0 * 2.0f - 1.0f;
224 tileY1 = tileY1 * 2.0f - 1.0f;
225
226 std::vector<GLfloat> vertices = {tileX0, tileY0, tileX0, tileY1, tileX1, tileY0,
227 tileX1, tileY0, tileX1, tileY1, tileX0, tileY1};
228
229 glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertices[0]) * vertices.size(), vertices.data());
230
231 glClear(GL_COLOR_BUFFER_BIT);
232 glDrawArrays(GL_TRIANGLES, 0, 6);
233
234 GLsync drawSync = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
235 {
236 std::lock_guard<std::mutex> lock(mUpdateThreadMutex);
237 mUpdateThreadQueue.push({textureAndFence.textureID, drawSync});
238 }
239 }
240
241 private:
242 std::unique_ptr<std::thread> mUpdateThread;
243
244 static constexpr GLuint kNumTextures = 4;
245 std::array<GLuint, kNumTextures> mTextures;
246
247 GLuint mProgram = 0;
248 GLuint mVertexBuffer = 0;
249
250 std::mutex mUpdateThreadMutex;
251 std::queue<TextureAndFence> mUpdateThreadQueue;
252 std::mutex mMainThreadMutex;
253 std::queue<TextureAndFence> mMainThreadQueue;
254 size_t mDrawCount = 0;
255 };
256
main(int argc,char ** argv)257 int main(int argc, char **argv)
258 {
259 MultipleContextsSample app(argc, argv);
260 return app.run();
261 }
262