Merge lp:~jaytaoko/nux/nux-linaro-rev518-merge into lp:nux/2.0
- nux-linaro-rev518-merge
- Merge into 2.0
Status: | Merged |
---|---|
Approved by: | Jay Taoko |
Approved revision: | 535 |
Merged at revision: | 535 |
Proposed branch: | lp:~jaytaoko/nux/nux-linaro-rev518-merge |
Merge into: | lp:nux/2.0 |
Diff against target: |
302 lines (+157/-35) 7 files modified
Nux/WindowCompositor.cpp (+102/-26) Nux/WindowCompositor.h (+21/-0) Nux/WindowThread.cpp (+9/-0) NuxGraphics/GraphicsDisplayX11.cpp (+2/-0) configure.ac (+1/-1) tests/manual-tests/linaro-reference-fbo.txt (+8/-0) tools/unity_support_test.c (+14/-8) |
To merge this branch: | bzr merge lp:~jaytaoko/nux/nux-linaro-rev518-merge |
Related bugs: |
Reviewer | Review Type | Date Requested | Status |
---|---|---|---|
Mirco Müller (community) | Approve | ||
Review via email: mp+87566@code.launchpad.net |
Commit message
Description of the change
* Merge linaro branch (lp:~linaro-graphics-wg/nux/nux-gles2-11.12 rev 518) with Nux trunk.
* This branch is adding support for a reference frame buffer in Nux. A Reference frame buffer allows Nux to restore a previously set FBO once it is done with its own rendering.
David Barth (dbarth) wrote : | # |
Alexandros Frantzis (afrantzis) wrote : | # |
The branch fails to build for gles2. Here is a fix:
=== modified file 'NuxGraphics/
--- NuxGraphics/
+++ NuxGraphics/
@@ -64,7 +64,9 @@
, m_X11Screen(0)
, m_ParentWindow(0)
, m_GLCtx(0)
+#ifndef NUX_OPENGLES_20
, glx_window_(0)
+#endif
, m_NumVideoModes(0)
, m_BorderPixel(0)
, _x11_major(0)
=== modified file 'tools/
--- tools/unity_
+++ tools/unity_
@@ -721,21 +721,26 @@
// Open a X11 connection and get the root window.
display = XOpenDisplay (display_name);
+#ifndef NUX_OPENGLES_20
// Before doing anything with GLX, check that it is supported on the system.
Bool glx_supported = False;
int dummy0, dummy1;
if (display)
glx_supported = glXQueryExtensi
-
- if (!display || !glx_supported) {
- if (!display)
- results.error = strdup ("unable to open display");
- else
- results.error = strdup ("GLX is not available on the system");
-
- // exit with 5, to tell "it's not an error we should cache"
- results.result = 5;
- }
+#endif
+
+ if (!display) {
+ results.error = strdup ("unable to open display");
+ // exit with 5, to tell "it's not an error we should cache"
+ results.result = 5;
+ }
+#ifndef NUX_OPENGLES_20
+ else if (!glx_supported) {
+ results.error = strdup ("GLX is not available on the system");
+ // exit with 5, to tell "it's not an error we should cache"
+ results.result = 5;
+ }
+#endif
else
{
screen = DefaultScreen (display);
Jay Taoko (jaytaoko) wrote : | # |
The logic behind the reference framebuffer:
- by default there is no reference frame buffer set and Nux render to the opengl back buffer.
- When a reference frame buffer is set Nux does its rendering into the reference frame buffer texture.
- it is up to the caller to display the texture from the reference frame buffer into the back buffer.
To test this, a sample program would set a reference frame buffer and have Nux render a single color quad all over the window. Then the program would dump the texture in the reference frame buffer to memory and compare a few texels with the color that was used.
Unity Merger (unity-merger) wrote : | # |
Attempt to merge into lp:nux failed due to conflicts:
text conflict in configure.ac
Preview Diff
1 | === modified file 'Nux/WindowCompositor.cpp' | |||
2 | --- Nux/WindowCompositor.cpp 2012-01-04 00:47:59 +0000 | |||
3 | +++ Nux/WindowCompositor.cpp 2012-01-06 18:46:23 +0000 | |||
4 | @@ -41,6 +41,7 @@ | |||
5 | 41 | 41 | ||
6 | 42 | WindowCompositor::WindowCompositor(WindowThread *window_thread) | 42 | WindowCompositor::WindowCompositor(WindowThread *window_thread) |
7 | 43 | : window_thread_(window_thread) | 43 | : window_thread_(window_thread) |
8 | 44 | , reference_fbo_(0) | ||
9 | 44 | { | 45 | { |
10 | 45 | m_FocusAreaWindow = NULL; | 46 | m_FocusAreaWindow = NULL; |
11 | 46 | m_MenuWindow = NULL; | 47 | m_MenuWindow = NULL; |
12 | @@ -1465,35 +1466,15 @@ | |||
13 | 1465 | { | 1466 | { |
14 | 1466 | m_FrameBufferObject->Deactivate(); | 1467 | m_FrameBufferObject->Deactivate(); |
15 | 1467 | 1468 | ||
40 | 1468 | // Enable this to render the drop shadow under windows: not perfect yet... | 1469 | // Nux is done rendering a BaseWindow into a texture. The previous call to Deactivate |
41 | 1469 | if (0) | 1470 | // has cancelled any opengl framebuffer object that was set. |
42 | 1470 | { | 1471 | |
43 | 1471 | graphics_engine.EmptyClippingRegion(); | 1472 | CHECKGL(glDepthMask(GL_FALSE)); |
20 | 1472 | graphics_engine.SetOpenGLClippingRectangle(0, 0, window_width, window_height); | ||
21 | 1473 | graphics_engine.SetViewport(0, 0, window_width, window_height); | ||
22 | 1474 | graphics_engine.SetOrthographicProjectionMatrix(window_width, window_height); | ||
23 | 1475 | |||
24 | 1476 | Geometry shadow(window->GetBaseX(), window->GetBaseY(), | ||
25 | 1477 | window->GetBaseWidth(), window->GetBaseHeight()); | ||
26 | 1478 | //if(window->IsVisibleSizeGrip()) | ||
27 | 1479 | { | ||
28 | 1480 | shadow.OffsetPosition(4, 4); | ||
29 | 1481 | GetPainter().PaintShape(graphics_engine, shadow, color::Black, | ||
30 | 1482 | eSHAPE_CORNER_SHADOW); | ||
31 | 1483 | } | ||
32 | 1484 | // else | ||
33 | 1485 | // { | ||
34 | 1486 | // shadow.OffsetPosition(4, 4); | ||
35 | 1487 | // GetPainter().PaintShape(window_thread_->GetGraphicsEngine(), shadow, Color(0xFF000000), eSHAPE_CORNER_ROUND10_SHADOW); | ||
36 | 1488 | // } | ||
37 | 1489 | } | ||
38 | 1490 | |||
39 | 1491 | CHECKGL( glDepthMask(GL_FALSE)); | ||
44 | 1492 | { | 1473 | { |
45 | 1493 | graphics_engine.ApplyClippingRectangle(); | 1474 | graphics_engine.ApplyClippingRectangle(); |
46 | 1494 | PresentBufferToScreen(rt.color_rt, window->GetBaseX(), window->GetBaseY(), false, false, window->GetOpacity(), window->premultiply()); | 1475 | PresentBufferToScreen(rt.color_rt, window->GetBaseX(), window->GetBaseY(), false, false, window->GetOpacity(), window->premultiply()); |
47 | 1495 | } | 1476 | } |
49 | 1496 | CHECKGL( glDepthMask(GL_TRUE)); | 1477 | CHECKGL(glDepthMask(GL_TRUE)); |
50 | 1497 | graphics_engine.GetRenderStates().SetBlend(false); | 1478 | graphics_engine.GetRenderStates().SetBlend(false); |
51 | 1498 | } | 1479 | } |
52 | 1499 | 1480 | ||
53 | @@ -1607,7 +1588,20 @@ | |||
54 | 1607 | } | 1588 | } |
55 | 1608 | else | 1589 | else |
56 | 1609 | { | 1590 | { |
58 | 1610 | GetGraphicsDisplay()->GetGpuDevice()->DeactivateFrameBuffer(); | 1591 | if (GetWindowThread()->IsEmbeddedWindow() && reference_fbo_) |
59 | 1592 | { | ||
60 | 1593 | // In the context of Unity, we may want Nux to restore a specific fbo and render the | ||
61 | 1594 | // BaseWindow texture into it. That fbo is called a reference framebuffer object. if a | ||
62 | 1595 | // Reference framebuffer object is present, Nux sets it. | ||
63 | 1596 | if (!RestoreReferenceFramebuffer()) | ||
64 | 1597 | { | ||
65 | 1598 | nuxDebugMsg("[WindowCompositor::RenderTopViews] Setting the Reference fbo has failed."); | ||
66 | 1599 | } | ||
67 | 1600 | } | ||
68 | 1601 | else | ||
69 | 1602 | { | ||
70 | 1603 | GetGraphicsDisplay()->GetGpuDevice()->DeactivateFrameBuffer(); | ||
71 | 1604 | } | ||
72 | 1611 | } | 1605 | } |
73 | 1612 | 1606 | ||
74 | 1613 | window_thread_->GetGraphicsEngine().EmptyClippingRegion(); | 1607 | window_thread_->GetGraphicsEngine().EmptyClippingRegion(); |
75 | @@ -2272,5 +2266,87 @@ | |||
76 | 2272 | 2266 | ||
77 | 2273 | return (*keyboard_grab_stack_.begin()); | 2267 | return (*keyboard_grab_stack_.begin()); |
78 | 2274 | } | 2268 | } |
79 | 2269 | |||
80 | 2270 | void WindowCompositor::SetReferenceFramebuffer(unsigned int fbo_object, Geometry fbo_geometry) | ||
81 | 2271 | { | ||
82 | 2272 | reference_fbo_ = fbo_object; | ||
83 | 2273 | reference_fbo_geometry_ = fbo_geometry; | ||
84 | 2274 | } | ||
85 | 2275 | |||
86 | 2276 | bool WindowCompositor::RestoreReferenceFramebuffer() | ||
87 | 2277 | { | ||
88 | 2278 | // It is assumed that the reference fbo contains valid textures. | ||
89 | 2279 | // Nux does the following: | ||
90 | 2280 | // - Bind the reference fbo (reference_fbo_) | ||
91 | 2281 | // - Call glDrawBuffer with GL_COLOR_ATTACHMENT0 | ||
92 | 2282 | // - Set the opengl viewport size (reference_fbo_geometry_) | ||
93 | 2283 | |||
94 | 2284 | bool ok = false; | ||
95 | 2285 | |||
96 | 2286 | CHECKGL(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, reference_fbo_)); | ||
97 | 2287 | #ifndef NUX_OPENGLES_20 | ||
98 | 2288 | CHECKGL(glDrawBuffer(GL_COLOR_ATTACHMENT0)); | ||
99 | 2289 | #endif | ||
100 | 2290 | CHECKGL(glViewport(reference_fbo_geometry_.x, | ||
101 | 2291 | reference_fbo_geometry_.y, | ||
102 | 2292 | reference_fbo_geometry_.width, | ||
103 | 2293 | reference_fbo_geometry_.height)); | ||
104 | 2294 | |||
105 | 2295 | // Nux does some sanity checks to make sure that the FBO is in good condition. | ||
106 | 2296 | GLenum status; | ||
107 | 2297 | status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); | ||
108 | 2298 | CHECKGL_MSG(glCheckFramebufferStatusEXT); | ||
109 | 2299 | |||
110 | 2300 | switch(status) | ||
111 | 2301 | { | ||
112 | 2302 | case GL_FRAMEBUFFER_COMPLETE_EXT: // Everything's OK | ||
113 | 2303 | ok = true; | ||
114 | 2304 | break; | ||
115 | 2305 | case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT: | ||
116 | 2306 | nuxError("[GLFramebufferObject::IsValid] GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT"); | ||
117 | 2307 | ok = false; | ||
118 | 2308 | break; | ||
119 | 2309 | case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT: | ||
120 | 2310 | nuxError("[GLFramebufferObject::IsValid] GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT"); | ||
121 | 2311 | ok = false; | ||
122 | 2312 | break; | ||
123 | 2313 | // See issue(87) of http://www.opengl.org/registry/specs/EXT/framebuffer_object.txt | ||
124 | 2314 | // case GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT: | ||
125 | 2315 | // nuxError("[GLFramebufferObject::IsValid] GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT"); | ||
126 | 2316 | // ok = false; | ||
127 | 2317 | // break; | ||
128 | 2318 | case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT: | ||
129 | 2319 | nuxError("[GLFramebufferObject::IsValid] GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT"); | ||
130 | 2320 | ok = false; | ||
131 | 2321 | break; | ||
132 | 2322 | #ifndef NUX_OPENGLES_20 | ||
133 | 2323 | case GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT: | ||
134 | 2324 | nuxError("[GLFramebufferObject::IsValid] GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT"); | ||
135 | 2325 | ok = false; | ||
136 | 2326 | break; | ||
137 | 2327 | case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT: | ||
138 | 2328 | nuxError("[GLFramebufferObject::IsValid] GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT"); | ||
139 | 2329 | ok = false; | ||
140 | 2330 | break; | ||
141 | 2331 | case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT: | ||
142 | 2332 | nuxError("[GLFramebufferObject::IsValid] GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT"); | ||
143 | 2333 | ok = false; | ||
144 | 2334 | break; | ||
145 | 2335 | #endif | ||
146 | 2336 | // case GL_FRAMEBUFFER_STATUS_ERROR_EXT: | ||
147 | 2337 | // nuxError("[GLFramebufferObject::IsValid] GL_FRAMEBUFFER_STATUS_ERROR_EXT"); | ||
148 | 2338 | // ok = false; | ||
149 | 2339 | // break; | ||
150 | 2340 | case GL_FRAMEBUFFER_UNSUPPORTED_EXT: | ||
151 | 2341 | nuxError("[GLFramebufferObject::IsValid] GL_FRAMEBUFFER_UNSUPPORTED_EXT"); | ||
152 | 2342 | ok = false; | ||
153 | 2343 | break; | ||
154 | 2344 | default: | ||
155 | 2345 | nuxError("[GLFramebufferObject::IsValid] Unknown ERROR"); | ||
156 | 2346 | ok = false; | ||
157 | 2347 | } | ||
158 | 2348 | |||
159 | 2349 | return ok; | ||
160 | 2350 | } | ||
161 | 2275 | } | 2351 | } |
162 | 2276 | 2352 | ||
163 | 2277 | 2353 | ||
164 | === modified file 'Nux/WindowCompositor.h' | |||
165 | --- Nux/WindowCompositor.h 2011-12-29 18:06:53 +0000 | |||
166 | +++ Nux/WindowCompositor.h 2012-01-06 18:46:23 +0000 | |||
167 | @@ -175,6 +175,23 @@ | |||
168 | 175 | //==================================== | 175 | //==================================== |
169 | 176 | 176 | ||
170 | 177 | public: | 177 | public: |
171 | 178 | /*! | ||
172 | 179 | Set and external fbo to draw Nux BaseWindow into. This external fbo will be | ||
173 | 180 | restored after Nux completes it rendering. The external fbo is used only in embedded mode. \n | ||
174 | 181 | If the fbo_object parameter 0, then the reference fbo is invalid and will not be used. | ||
175 | 182 | |||
176 | 183 | @param fbo_object The opengl index of the fbo. | ||
177 | 184 | @param fbo_geometry The geometry of the fbo. | ||
178 | 185 | */ | ||
179 | 186 | void SetReferenceFramebuffer(unsigned int fbo_object, Geometry fbo_geometry); | ||
180 | 187 | |||
181 | 188 | /*! | ||
182 | 189 | Bind the reference opengl framebuffer object. | ||
183 | 190 | |||
184 | 191 | @return True if no error was detected. | ||
185 | 192 | */ | ||
186 | 193 | bool RestoreReferenceFramebuffer(); | ||
187 | 194 | |||
188 | 178 | ObjectPtr<IOpenGLFrameBufferObject>& GetWindowFrameBufferObject() | 195 | ObjectPtr<IOpenGLFrameBufferObject>& GetWindowFrameBufferObject() |
189 | 179 | { | 196 | { |
190 | 180 | return m_FrameBufferObject; | 197 | return m_FrameBufferObject; |
191 | @@ -561,6 +578,10 @@ | |||
192 | 561 | int m_TooltipX; | 578 | int m_TooltipX; |
193 | 562 | int m_TooltipY; | 579 | int m_TooltipY; |
194 | 563 | 580 | ||
195 | 581 | //! The fbo to restore after Nux rendering in embedded mode. | ||
196 | 582 | unsigned int reference_fbo_; | ||
197 | 583 | Geometry reference_fbo_geometry_; | ||
198 | 584 | |||
199 | 564 | //! Pointer grab stack. | 585 | //! Pointer grab stack. |
200 | 565 | /*! | 586 | /*! |
201 | 566 | The head of the list is the top of the stack. | 587 | The head of the list is the top of the stack. |
202 | 567 | 588 | ||
203 | === modified file 'Nux/WindowThread.cpp' | |||
204 | --- Nux/WindowThread.cpp 2012-01-04 00:10:39 +0000 | |||
205 | +++ Nux/WindowThread.cpp 2012-01-06 18:46:23 +0000 | |||
206 | @@ -1425,6 +1425,15 @@ | |||
207 | 1425 | 1425 | ||
208 | 1426 | graphics_display_->GetGpuDevice()->DeactivateFrameBuffer(); | 1426 | graphics_display_->GetGpuDevice()->DeactivateFrameBuffer(); |
209 | 1427 | IOpenGLShaderProgram::SetShaderTracking(false); | 1427 | IOpenGLShaderProgram::SetShaderTracking(false); |
210 | 1428 | |||
211 | 1429 | if (IsEmbeddedWindow() && window_compositor_->reference_fbo_) | ||
212 | 1430 | { | ||
213 | 1431 | // Restore the reference framebuffer | ||
214 | 1432 | if (!window_compositor_->RestoreReferenceFramebuffer()) | ||
215 | 1433 | { | ||
216 | 1434 | nuxDebugMsg("[WindowCompositor::RenderTopViews] Setting the Reference fbo has failed."); | ||
217 | 1435 | } | ||
218 | 1436 | } | ||
219 | 1428 | } | 1437 | } |
220 | 1429 | 1438 | ||
221 | 1430 | int WindowThread::InstallEventInspector(EventInspector function, void* data) | 1439 | int WindowThread::InstallEventInspector(EventInspector function, void* data) |
222 | 1431 | 1440 | ||
223 | === modified file 'NuxGraphics/GraphicsDisplayX11.cpp' | |||
224 | --- NuxGraphics/GraphicsDisplayX11.cpp 2012-01-04 00:10:39 +0000 | |||
225 | +++ NuxGraphics/GraphicsDisplayX11.cpp 2012-01-06 18:46:23 +0000 | |||
226 | @@ -44,7 +44,9 @@ | |||
227 | 44 | , m_X11Screen(0) | 44 | , m_X11Screen(0) |
228 | 45 | , m_ParentWindow(0) | 45 | , m_ParentWindow(0) |
229 | 46 | , m_GLCtx(0) | 46 | , m_GLCtx(0) |
230 | 47 | #ifndef NUX_OPENGLES_20 | ||
231 | 47 | , glx_window_(0) | 48 | , glx_window_(0) |
232 | 49 | #endif | ||
233 | 48 | , m_NumVideoModes(0) | 50 | , m_NumVideoModes(0) |
234 | 49 | , m_BorderPixel(0) | 51 | , m_BorderPixel(0) |
235 | 50 | , _x11_major(0) | 52 | , _x11_major(0) |
236 | 51 | 53 | ||
237 | === modified file 'configure.ac' | |||
238 | --- configure.ac 2012-01-06 16:55:41 +0000 | |||
239 | +++ configure.ac 2012-01-06 18:46:23 +0000 | |||
240 | @@ -22,7 +22,7 @@ | |||
241 | 22 | # The number format is : year/month/day | 22 | # The number format is : year/month/day |
242 | 23 | # e.g.: december 5th, 2011 is: 20111205 | 23 | # e.g.: december 5th, 2011 is: 20111205 |
243 | 24 | # So far there is no provision for more than one break in a day. | 24 | # So far there is no provision for more than one break in a day. |
245 | 25 | m4_define([nux_abi_version], [20111213]) | 25 | m4_define([nux_abi_version], [20111214]) |
246 | 26 | 26 | ||
247 | 27 | m4_define([nux_version], | 27 | m4_define([nux_version], |
248 | 28 | [nux_major_version.nux_minor_version.nux_micro_version]) | 28 | [nux_major_version.nux_minor_version.nux_micro_version]) |
249 | 29 | 29 | ||
250 | === added directory 'tests/manual-tests' | |||
251 | === added file 'tests/manual-tests/linaro-reference-fbo.txt' | |||
252 | --- tests/manual-tests/linaro-reference-fbo.txt 1970-01-01 00:00:00 +0000 | |||
253 | +++ tests/manual-tests/linaro-reference-fbo.txt 2012-01-06 18:46:23 +0000 | |||
254 | @@ -0,0 +1,8 @@ | |||
255 | 1 | |||
256 | 2 | The logic behind the reference framebuffer: | ||
257 | 3 | - by default there is no reference frame buffer set and Nux render to the opengl back buffer. | ||
258 | 4 | - When a reference frame buffer is set Nux does its rendering into the reference frame buffer texture. | ||
259 | 5 | - it is up to the caller to display the texture from the reference frame buffer into the back buffer. | ||
260 | 6 | |||
261 | 7 | To test this, a sample program would set a reference frame buffer and have Nux render a single color quad all over the window. Then the program would dump the texture in the reference frame buffer to memory and compare a few texels with the color that was used. | ||
262 | 8 | |||
263 | 0 | 9 | ||
264 | === modified file 'tools/unity_support_test.c' | |||
265 | --- tools/unity_support_test.c 2011-11-24 16:45:23 +0000 | |||
266 | +++ tools/unity_support_test.c 2012-01-06 18:46:23 +0000 | |||
267 | @@ -721,21 +721,27 @@ | |||
268 | 721 | // Open a X11 connection and get the root window. | 721 | // Open a X11 connection and get the root window. |
269 | 722 | display = XOpenDisplay (display_name); | 722 | display = XOpenDisplay (display_name); |
270 | 723 | 723 | ||
271 | 724 | #ifndef NUX_OPENGLES_20 | ||
272 | 724 | // Before doing anything with GLX, check that it is supported on the system. | 725 | // Before doing anything with GLX, check that it is supported on the system. |
273 | 725 | Bool glx_supported = False; | 726 | Bool glx_supported = False; |
274 | 726 | int dummy0, dummy1; | 727 | int dummy0, dummy1; |
275 | 727 | if (display) | 728 | if (display) |
276 | 728 | glx_supported = glXQueryExtension(display, &dummy0, &dummy1); | 729 | glx_supported = glXQueryExtension(display, &dummy0, &dummy1); |
277 | 729 | 730 | ||
283 | 730 | if (!display || !glx_supported) { | 731 | #endif |
279 | 731 | if (!display) | ||
280 | 732 | results.error = strdup ("unable to open display"); | ||
281 | 733 | else | ||
282 | 734 | results.error = strdup ("GLX is not available on the system"); | ||
284 | 735 | 732 | ||
288 | 736 | // exit with 5, to tell "it's not an error we should cache" | 733 | if (!display) { |
289 | 737 | results.result = 5; | 734 | results.error = strdup ("unable to open display"); |
290 | 738 | } | 735 | // exit with 5, to tell "it's not an error we should cache" |
291 | 736 | results.result = 5; | ||
292 | 737 | } | ||
293 | 738 | #ifndef NUX_OPENGLES_20 | ||
294 | 739 | else if (!glx_supported) { | ||
295 | 740 | results.error = strdup ("GLX is not available on the system"); | ||
296 | 741 | // exit with 5, to tell "it's not an error we should cache" | ||
297 | 742 | results.result = 5; | ||
298 | 743 | } | ||
299 | 744 | #endif | ||
300 | 739 | else | 745 | else |
301 | 740 | { | 746 | { |
302 | 741 | screen = DefaultScreen (display); | 747 | screen = DefaultScreen (display); |
Jay, can you document the test requirements for this change, and how much the code is already covered by existing tests?