1
=== modified file 'include/core/window.h'
2
--- include/core/window.h	2013-01-03 16:06:41 +0000
3
+++ include/core/window.h	2013-02-13 11:45:25 +0000
4
@@ -43,12 +43,12 @@
5
43
#include <core/region.h>
43
#include <core/region.h>
6
44
#include <core/windowgeometry.h>
44
#include <core/windowgeometry.h>
7
45
#include <core/windowextents.h>
45
#include <core/windowextents.h>
8
46
#include <core/servergrab.h>
9
47
46
10
48
#include <core/wrapsystem.h>
47
#include <core/wrapsystem.h>
11
49
48
12
50
#include <map>
49
#include <map>
13
51
50
14
51
class ServerLock;
15
52
class CompWindow;
52
class CompWindow;
16
53
class CompIcon;
53
class CompIcon;
17
54
class PrivateWindow;
54
class PrivateWindow;
18
@@ -434,7 +434,7 @@
19
434
	void moveInputFocusToOtherWindow ();
434
	void moveInputFocusToOtherWindow ();
20
435
435
21
436
	/* wraps XConfigureWindow and updates serverGeometry */
436
	/* wraps XConfigureWindow and updates serverGeometry */
23
437
	void configureXWindow (unsigned int   valueMask,
437
	void configureXWindow (unsigned int valueMask,
24
438
			       XWindowChanges *xwc);
438
			       XWindowChanges *xwc);
25
439
439
26
440
	void restackAndConfigureXWindow (unsigned int     valueMask,
440
	void restackAndConfigureXWindow (unsigned int     valueMask,
27
441
441
28
=== modified file 'plugins/opengl/CMakeLists.txt'
29
--- plugins/opengl/CMakeLists.txt	2012-12-12 07:33:12 +0000
30
+++ plugins/opengl/CMakeLists.txt	2013-02-13 11:45:25 +0000
31
@@ -5,15 +5,21 @@
32
5
set (INTERNAL_LIBRARIES
5
set (INTERNAL_LIBRARIES
33
6
    compiz_opengl_double_buffer
6
    compiz_opengl_double_buffer
34
7
    compiz_opengl_fsregion
7
    compiz_opengl_fsregion
35
8
    compiz_opengl_framebuffer_direct_draw
36
8
    compiz_opengl_blacklist
9
    compiz_opengl_blacklist
37
9
    compiz_opengl_glx_tfp_bind
10
    compiz_opengl_glx_tfp_bind
38
10
)
11
)
39
11
12
40
13
set (COMPIZ_OPENGL_PLUGIN_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include)
41
14
set (COMPIZ_OPENGL_PLUGIN_SOURCE_DIR  ${CMAKE_CURRENT_SOURCE_DIR}/src)
42
15
43
12
add_subdirectory (src/doublebuffer)
16
add_subdirectory (src/doublebuffer)
44
13
add_subdirectory (src/fsregion)
17
add_subdirectory (src/fsregion)
45
18
add_subdirectory (src/fbdirectdraw)
46
14
add_subdirectory (src/blacklist)
19
add_subdirectory (src/blacklist)
47
15
add_subdirectory (src/glxtfpbind)
20
add_subdirectory (src/glxtfpbind)
48
16
21
49
22
include_directories (src/fbdirectdraw/include)
50
17
include_directories (src/glxtfpbind/include)
23
include_directories (src/glxtfpbind/include)
51
18
24
52
19
if (USE_GLES)
25
if (USE_GLES)
53
20
26
54
=== modified file 'plugins/opengl/include/opengl/framebufferobject.h'
55
--- plugins/opengl/include/opengl/framebufferobject.h	2012-08-09 02:19:26 +0000
56
+++ plugins/opengl/include/opengl/framebufferobject.h	2013-02-13 11:45:25 +0000
57
@@ -26,29 +26,175 @@
58
26
#ifndef _COMPIZ_GLFRAMEBUFFEROBJECT_H
26
#ifndef _COMPIZ_GLFRAMEBUFFEROBJECT_H
59
27
#define _COMPIZ_GLFRAMEBUFFEROBJECT_H
27
#define _COMPIZ_GLFRAMEBUFFEROBJECT_H
60
28
28
62
29
#include <opengl/opengl.h>
29
#include <list>
63
30
#include <boost/function.hpp>
64
31
#include <opengl/opengl-api.h>
65
32
#include <core/size.h>
66
33
#include <core/rect.h>
67
34
68
35
class GLVertexBuffer;
69
36
class GLTexture;
70
37
71
38
namespace compiz
72
39
{
73
40
namespace opengl
74
41
{
75
42
typedef enum _BlitMask
76
43
{
77
44
    ColorData = (1 << 0),
78
45
    StencilData = (1 << 1)
79
46
} BlitMask;
80
47
81
48
typedef enum _Filter
82
49
{
83
50
    Fast = 0,
84
51
    Good = 1,
85
52
} Filter;
86
53
87
54
typedef enum _BindPoint
88
55
{
89
56
    Read = 0,
90
57
    Draw = 1
91
58
} BindPoint;
92
59
93
60
class BindableFramebuffer
94
61
{
95
62
    public:
96
63
97
64
	virtual ~BindableFramebuffer () {}
98
65
99
66
	virtual GLuint getResourceId () const = 0;
100
67
	virtual bool   setBindStatus (GLenum) = 0;
101
68
	virtual void   updateAllocation (GLenum) = 0;
102
69
};
103
70
104
71
class BindLocation
105
72
{
106
73
    public:
107
74
108
75
	virtual ~BindLocation () {}
109
76
110
77
	/**
111
78
	 * Bind the specified BindableFramebuffer to this bind location
112
79
	 * usually either as the read target or the draw target
113
80
	 *
114
81
	 * The previous FBO is no longer bound. If it was bound to the
115
82
	 * draw target, it will be safe to use its texture.
116
83
	 *
117
84
	 * This returns the last-bound BindableFramebuffer object on
118
85
	 * success and NULL on failure (no change). Call this again
119
86
	 * in order to restore that framebuffer
120
87
	 */
121
88
	virtual BindableFramebuffer * bind (BindableFramebuffer *) = 0;
122
89
};
123
90
124
91
typedef boost::function <bool (const CompRect &src,
125
92
			       const CompRect &dst,
126
93
			       GLbitfield     mask,
127
94
			       GLenum         filter)> RectangularDraw;
128
95
typedef std::list <RectangularDraw> RectangularDrawList;
129
96
130
97
class DirectDrawStrategies
131
98
{
132
99
    public:
133
100
134
101
	typedef boost::shared_ptr <DirectDrawStrategies> Ptr;
135
102
136
103
	virtual ~DirectDrawStrategies () {}
137
104
	virtual void draw (const CompRect &src,
138
105
			   const CompRect &dst,
139
106
			   BlitMask       mask,
140
107
			   Filter         filter) = 0;
141
108
};
142
109
143
110
class FramebufferObject
144
111
{
145
112
    public:
146
113
147
114
	virtual ~FramebufferObject () {}
148
115
149
116
	/**
150
117
	 * Ensure the texture is of the given size, recreating it if needed,
151
118
	 * and replace the FBO color attachment with it. The texture contents
152
119
	 * become undefined, unless specified in the 'image' argument.
153
120
	 * When specifying 'image', it's also possible to pass-in the
154
121
	 * desired image's 'format' and 'type'.
155
122
	 *
156
123
	 * Returns true on success, and false on texture allocation failure.
157
124
	 */
158
125
	virtual bool allocate (const CompSize &size,
159
126
			       const char *image = NULL,
160
127
			       GLenum format = GL_RGBA,
161
128
			       GLenum type = GL_UNSIGNED_BYTE) = 0;
162
129
163
130
	/**
164
131
	 * Check the FBO completeness. Returns true on complete.
165
132
	 * Otherwise returns false and reports the error to log.
166
133
	 */
167
134
	virtual bool checkStatus () = 0;
168
135
169
136
	/**
170
137
	 * Return a pointer to the texture that is the color attachment.
171
138
	 * This will return NULL, if allocate () has not been called, or
172
139
	 * the last allocate () call failed.
173
140
	 */
174
141
	virtual GLTexture * tex () = 0;
175
142
};
176
143
177
144
class DirectDrawObject :
178
145
    virtual public compiz::opengl::FramebufferObject,
179
146
    virtual public compiz::opengl::BindableFramebuffer
180
147
{
181
148
    public:
182
149
183
150
	virtual ~DirectDrawObject () {};
184
151
185
152
	/**
186
153
	 * Draws a region of the framebuffer object as specified in
187
154
	 * framebuffer-specified co-ordinates as @src co-ordinates in
188
155
	 * the buffer currently bound co-ordinates @dst . @mask indicates
189
156
	 * what kind of data should be propogated downwards. @filter indicates
190
157
	 * what kind of filter should be used when drawing this buffer
191
158
	 *
192
159
	 * This since this code only draws a rectangular region from one
193
160
	 * framebuffer to another, it will try and use the fastest codepath
194
161
	 * possible, falling back to a simple textured draw if
195
162
	 * glBlitFramebuffer is not available
196
163
	 *
197
164
	 */
198
165
	virtual void directDraw (const CompRect           &src,
199
166
				 const CompRect           &dst,
200
167
				 compiz::opengl::BlitMask mask,
201
168
				 compiz::opengl::Filter  filter) = 0;
202
169
};
203
170
204
171
namespace impl
205
172
{
206
173
namespace cgl = compiz::opengl;
207
30
174
208
31
struct PrivateGLFramebufferObject;
175
struct PrivateGLFramebufferObject;
209
32
176
229
33
/**
177
class FBOBindLocation :
230
34
 * Class representing a framebuffer object in GL, supporting only one
178
    public cgl::BindLocation
231
35
 * color attachment as per GLES 2 spec. The color attachment is referred
179
{
232
36
 * to as the texture (of the FBO).
180
    public:
233
37
 *
181
234
38
 * Usage:
182
	FBOBindLocation (GLenum binding, BindableFramebuffer *back);
235
39
 * 1. create a GLFramebufferObject (requires a GL context)
183
	BindableFramebuffer * bind (BindableFramebuffer *);
236
40
 * 2. call allocate (size), and check status ()
184
237
41
 * 3. old = bind ()
185
    private:
238
42
 * 4. do your rendering
186
239
43
 * 5. rebind (old)
187
	class Private;
240
44
 * 6. use the rendered texture via tex ()
188
	std::auto_ptr <Private> priv;
241
45
 * 7. go to 2 or 3, or delete to quit (requires a GL context)
189
};
242
46
 */
190
243
47
class GLFramebufferObject
191
class FramebufferObject :
244
48
{
192
    public cgl::FramebufferObject,
245
49
    public:
193
    public cgl::BindableFramebuffer
246
50
	GLFramebufferObject ();
194
{
247
51
	~GLFramebufferObject ();
195
    public:
248
196
	FramebufferObject ();
249
197
	~FramebufferObject ();
250
52
198
251
53
	/**
199
	/**
252
54
	 * Ensure the texture is of the given size, recreating it if needed,
200
	 * Ensure the texture is of the given size, recreating it if needed,
253
@@ -65,26 +211,6 @@
254
65
		       GLenum type = GL_UNSIGNED_BYTE);
211
		       GLenum type = GL_UNSIGNED_BYTE);
255
66
212
256
67
	/**
213
	/**
257
68
	 * Bind this as the current FBO, previous binding in GL context is
258
69
	 * undone. GL rendering is now targeted to this FBO.
259
70
	 * Returns a pointer to the previously bound FBO, or NULL if
260
71
	 * the previous binding was zero (the window system provided
261
72
	 * framebuffer).
262
73
	 *
263
74
	 * The previous FBO is no longer bound, so you can use its
264
75
	 * texture. To restore the previous FBO, call rebind (FBO) with
265
76
	 * the returned pointer as the argument.
266
77
	 */
267
78
	GLFramebufferObject *bind ();
268
79
269
80
	/**
270
81
	 * Bind the given FBO as the current FBO, without looking up the
271
82
	 * previous binding. The argument can be NULL, in which case the
272
83
	 * window system provided framebuffer gets bound (FBO is unbound).
273
84
	 */
274
85
	static void rebind (GLFramebufferObject *fbo);
275
86
276
87
	/**
277
88
	 * Check the FBO completeness. Returns true on complete.
214
	 * Check the FBO completeness. Returns true on complete.
278
89
	 * Otherwise returns false and reports the error to log.
215
	 * Otherwise returns false and reports the error to log.
279
90
	 */
216
	 */
280
@@ -95,10 +221,23 @@
281
95
	 * This will return NULL, if allocate () has not been called, or
221
	 * This will return NULL, if allocate () has not been called, or
282
96
	 * the last allocate () call failed.
222
	 * the last allocate () call failed.
283
97
	 */
223
	 */
285
98
	GLTexture *tex ();
224
	GLTexture * tex ();
286
99
225
287
100
    private:
226
    private:
288
227
289
228
	/**
290
229
	 * Returns the framebuffer identifier
291
230
	 */
292
231
	GLuint getResourceId () const;
293
232
	bool   setBindStatus (GLenum);
294
233
	void   updateAllocation (GLenum bindingLocation);
295
234
296
101
	PrivateGLFramebufferObject *priv;
235
	PrivateGLFramebufferObject *priv;
297
102
};
236
};
298
237
}
299
238
}
300
239
}
301
240
302
241
typedef compiz::opengl::impl::FramebufferObject GLFramebufferObject;
303
103
242
304
104
#endif // _COMPIZ_GLFRAMEBUFFEROBJECT_H
243
#endif // _COMPIZ_GLFRAMEBUFFEROBJECT_H
305
105
244
306
=== added file 'plugins/opengl/include/opengl/opengl-api.h'
307
--- plugins/opengl/include/opengl/opengl-api.h	1970-01-01 00:00:00 +0000
308
+++ plugins/opengl/include/opengl/opengl-api.h	2013-02-13 11:45:25 +0000
309
@@ -0,0 +1,42 @@
310
1
/*
311
2
 * Copyright © 2008 Dennis Kasprzyk
312
3
 * Copyright © 2007 Novell, Inc.
313
4
 *
314
5
 * Permission to use, copy, modify, distribute, and sell this software
315
6
 * and its documentation for any purpose is hereby granted without
316
7
 * fee, provided that the above copyright notice appear in all copies
317
8
 * and that both that copyright notice and this permission notice
318
9
 * appear in supporting documentation, and that the name of
319
10
 * Dennis Kasprzyk not be used in advertising or publicity pertaining to
320
11
 * distribution of the software without specific, written prior permission.
321
12
 * Dennis Kasprzyk makes no representations about the suitability of this
322
13
 * software for any purpose. It is provided "as is" without express or
323
14
 * implied warranty.
324
15
 *
325
16
 * DENNIS KASPRZYK DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
326
17
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
327
18
 * NO EVENT SHALL DENNIS KASPRZYK BE LIABLE FOR ANY SPECIAL, INDIRECT OR
328
19
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
329
20
 * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
330
21
 * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
331
22
 * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
332
23
 *
333
24
 * Authors: Dennis Kasprzyk <onestone@compiz-fusion.org>
334
25
 *          David Reveman <davidr@novell.com>
335
26
 */
336
27
337
28
#ifndef _COMPIZ_OPENGL_API_H
338
29
#define _COMPIZ_OPENGL_API_H
339
30
340
31
#ifdef USE_GLES
341
32
#define SUPPORT_X11
342
33
#include <GLES2/gl2.h>
343
34
#include <GLES2/gl2ext.h>
344
35
#include <EGL/egl.h>
345
36
#include <EGL/eglext.h>
346
37
#else
347
38
#include <GL/gl.h>
348
39
#include <GL/glx.h>
349
40
#endif
350
41
351
42
#endif
352
0
43
353
=== modified file 'plugins/opengl/include/opengl/opengl.h'
354
--- plugins/opengl/include/opengl/opengl.h	2013-01-10 09:23:24 +0000
355
+++ plugins/opengl/include/opengl/opengl.h	2013-02-13 11:45:25 +0000
356
@@ -28,29 +28,19 @@
357
28
#ifndef _COMPIZ_OPENGL_H
28
#ifndef _COMPIZ_OPENGL_H
358
29
#define _COMPIZ_OPENGL_H
29
#define _COMPIZ_OPENGL_H
359
30
30
370
31
#ifdef USE_GLES
31
#include <opengl/opengl-api.h>
361
32
#define SUPPORT_X11
362
33
#include <GLES2/gl2.h>
363
34
#include <GLES2/gl2ext.h>
364
35
#include <EGL/egl.h>
365
36
#include <EGL/eglext.h>
366
37
#else
367
38
#include <GL/gl.h>
368
39
#include <GL/glx.h>
369
40
#endif
371
41
32
372
42
#include <core/size.h>
33
#include <core/size.h>
373
43
#include <core/pluginclasshandler.h>
34
#include <core/pluginclasshandler.h>
374
44
35
375
45
#include <opengl/matrix.h>
36
#include <opengl/matrix.h>
376
46
#include <opengl/texture.h>
37
#include <opengl/texture.h>
377
47
#include <opengl/framebufferobject.h>
378
48
#include <opengl/vertexbuffer.h>
38
#include <opengl/vertexbuffer.h>
379
49
#include <opengl/program.h>
39
#include <opengl/program.h>
380
50
#include <opengl/programcache.h>
40
#include <opengl/programcache.h>
381
51
#include <opengl/shadercache.h>
41
#include <opengl/shadercache.h>
382
52
42
384
53
#define COMPIZ_OPENGL_ABI 6
43
#define COMPIZ_OPENGL_ABI 7
385
54
44
386
55
/*
45
/*
387
56
 * Some plugins check for #ifdef USE_MODERN_COMPIZ_GL. Support it for now, but
46
 * Some plugins check for #ifdef USE_MODERN_COMPIZ_GL. Support it for now, but
388
@@ -84,9 +74,38 @@
389
84
extern const float GREEN_SATURATION_WEIGHT;
74
extern const float GREEN_SATURATION_WEIGHT;
390
85
extern const float BLUE_SATURATION_WEIGHT;
75
extern const float BLUE_SATURATION_WEIGHT;
391
86
76
392
77
class GLScreen;
393
87
class PrivateGLScreen;
78
class PrivateGLScreen;
394
88
class PrivateGLWindow;
79
class PrivateGLWindow;
395
89
80
396
81
namespace compiz
397
82
{
398
83
namespace opengl
399
84
{
400
85
typedef boost::function <bool (const CompRect &src,
401
86
			       const CompRect &dst,
402
87
			       GLbitfield     mask,
403
88
			       GLenum         filter)> BlitFramebufferFunc;
404
89
405
90
class DirectDrawObject;
406
91
class FramebufferObject;
407
92
class BindableFramebuffer;
408
93
409
94
/**
410
95
 * Convenience method to construct a framebuffer object that
411
96
 * supports GLX_EXT_blit_framebuffer and a fallback path
412
97
 */
413
98
DirectDrawObject *createBlittableFramebufferObjectWithFallback(const CompSize &sz, GLScreen *gScreen);
414
99
415
100
namespace impl
416
101
{
417
102
class FramebufferObject;
418
103
}
419
104
}
420
105
}
421
106
422
107
typedef compiz::opengl::impl::FramebufferObject GLFramebufferObject;
423
108
424
90
extern GLushort   defaultColor[4];
109
extern GLushort   defaultColor[4];
425
91
110
426
92
#ifndef GLX_EXT_texture_from_pixmap
111
#ifndef GLX_EXT_texture_from_pixmap
427
@@ -313,6 +332,18 @@
428
313
					   GLsizei width,
332
					   GLsizei width,
429
314
					   GLsizei height);
333
					   GLsizei height);
430
315
334
431
335
    /* GLX_EXT_blit_framebuffer */
432
336
    typedef void (*GLBlitFramebufferProc) (GLint      srcX0,
433
337
					   GLint      srcY0,
434
338
					   GLint      srcX1,
435
339
					   GLint      srcY1,
436
340
					   GLint      dstX0,
437
341
					   GLint      dstY0,
438
342
					   GLint      dstX1,
439
343
					   GLint      dstY1,
440
344
					   GLbitfield mask,
441
345
					   GLenum     filter);
442
346
443
316
347
444
317
    /* GL_ARB_shader_objects */
348
    /* GL_ARB_shader_objects */
445
318
    #ifndef USE_GLES
349
    #ifndef USE_GLES
446
@@ -413,11 +444,12 @@
447
413
    extern GLDisableVertexAttribArrayProc disableVertexAttribArray;
444
    extern GLDisableVertexAttribArrayProc disableVertexAttribArray;
448
414
    extern GLVertexAttribPointerProc      vertexAttribPointer;
445
    extern GLVertexAttribPointerProc      vertexAttribPointer;
449
415
446
453
416
    extern GLGenRenderbuffersProc genRenderbuffers;
447
    extern GLGenRenderbuffersProc        genRenderbuffers;
454
417
    extern GLDeleteRenderbuffersProc deleteRenderbuffers;
448
    extern GLDeleteRenderbuffersProc     deleteRenderbuffers;
455
418
    extern GLBindRenderbufferProc    bindRenderbuffer;
449
    extern GLBindRenderbufferProc        bindRenderbuffer;
456
419
    extern GLFramebufferRenderbufferProc framebufferRenderbuffer;
450
    extern GLFramebufferRenderbufferProc framebufferRenderbuffer;
458
420
    extern GLRenderbufferStorageProc renderbufferStorage;
451
    extern GLRenderbufferStorageProc     renderbufferStorage;
459
452
    extern GLBlitFramebufferProc         blitFramebuffer;
460
421
453
461
422
    #ifndef USE_GLES
454
    #ifndef USE_GLES
462
423
    extern GLCreateShaderObjectARBProc createShaderObjectARB;
455
    extern GLCreateShaderObjectARBProc createShaderObjectARB;
463
@@ -579,7 +611,6 @@
464
579
extern GLScreenPaintAttrib defaultScreenPaintAttrib;
611
extern GLScreenPaintAttrib defaultScreenPaintAttrib;
465
580
612
466
581
class GLScreen;
613
class GLScreen;
467
582
class GLFramebufferObject;
468
583
class GLScreenInterface;
614
class GLScreenInterface;
469
584
extern template class WrapableInterface<GLScreen, GLScreenInterface>;
615
extern template class WrapableInterface<GLScreen, GLScreenInterface>;
470
585
616
471
@@ -658,9 +689,9 @@
472
658
	 * @param scratchFbo Describes the final composited FBO that is
689
	 * @param scratchFbo Describes the final composited FBO that is
473
659
	 * to be rendered.
690
	 * to be rendered.
474
660
	 */
691
	 */
478
661
	virtual void glPaintCompositedOutput (const CompRegion    &region,
692
	virtual void glPaintCompositedOutput (const CompRegion				  &region,
479
662
					      GLFramebufferObject *fbo,
693
					      compiz::opengl::DirectDrawObject *fbo,
480
663
					      unsigned int         mask);
694
					      unsigned int				  mask);
481
664
695
482
665
	/**
696
	/**
483
666
	 * Hookable function used by plugins to determine stenciling mask
697
	 * Hookable function used by plugins to determine stenciling mask
484
@@ -759,13 +790,36 @@
485
759
	/**
790
	/**
486
760
	 * Returns the FBO compiz is using for the screen
791
	 * Returns the FBO compiz is using for the screen
487
761
	 */
792
	 */
489
762
	GLFramebufferObject *fbo ();
793
	compiz::opengl::FramebufferObject * fbo ();
490
794
491
795
	/**
492
796
	 * Binds a framebuffer for drawing, returns the old bindable
493
797
	 */
494
798
	compiz::opengl::BindableFramebuffer *
495
799
	bindFramebufferForDrawing (compiz::opengl::BindableFramebuffer *);
496
800
497
801
	/**
498
802
	 * Binds a framebuffer for reading, returns the old reading
499
803
	 */
500
804
	compiz::opengl::BindableFramebuffer *
501
805
	bindFramebufferForReading (compiz::opengl::BindableFramebuffer *);
502
806
503
807
	/**
504
808
	 * Gets the backbuffer as a BindableFramebuffer
505
809
	 */
506
810
	compiz::opengl::BindableFramebuffer *
507
811
	backbuffer ();
508
763
812
509
764
	/**
813
	/**
510
765
	 * Returns a default icon texture
814
	 * Returns a default icon texture
511
766
	 */
815
	 */
512
767
	GLTexture *defaultIcon ();
816
	GLTexture *defaultIcon ();
513
768
817
514
818
	/**
515
819
	 * Returns the current framebuffer function for blitting the framebuffer
516
820
	 */
517
821
	const compiz::opengl::BlitFramebufferFunc & blitFramebufferFunc ();
518
822
519
769
	void resetRasterPos ();
823
	void resetRasterPos ();
520
770
824
521
771
	bool glInitContext (XVisualInfo *);
825
	bool glInitContext (XVisualInfo *);
522
@@ -786,7 +840,7 @@
523
786
840
524
787
	WRAPABLE_HND (5, GLScreenInterface, GLMatrix *, projectionMatrix);
841
	WRAPABLE_HND (5, GLScreenInterface, GLMatrix *, projectionMatrix);
525
788
	WRAPABLE_HND (6, GLScreenInterface, void, glPaintCompositedOutput,
842
	WRAPABLE_HND (6, GLScreenInterface, void, glPaintCompositedOutput,
527
789
		      const CompRegion &, GLFramebufferObject *, unsigned int);
843
		      const CompRegion &, compiz::opengl::DirectDrawObject *, unsigned int);
528
790
844
529
791
	WRAPABLE_HND (7, GLScreenInterface, void, glBufferStencil, const GLMatrix &,
845
	WRAPABLE_HND (7, GLScreenInterface, void, glBufferStencil, const GLMatrix &,
530
792
		      GLVertexBuffer &,
846
		      GLVertexBuffer &,
531
793
847
532
=== added directory 'plugins/opengl/src/fbdirectdraw'
533
=== added file 'plugins/opengl/src/fbdirectdraw/CMakeLists.txt'
534
--- plugins/opengl/src/fbdirectdraw/CMakeLists.txt	1970-01-01 00:00:00 +0000
535
+++ plugins/opengl/src/fbdirectdraw/CMakeLists.txt	2013-02-13 11:45:25 +0000
536
@@ -0,0 +1,32 @@
537
1
INCLUDE_DIRECTORIES (  
538
2
  ${COMPIZ_OPENGL_PLUGIN_SOURCE_DIR}
539
3
  ${COMPIZ_OPENGL_PLUGIN_INCLUDE_DIR}
540
4
  ${CMAKE_CURRENT_SOURCE_DIR}/include
541
5
  ${CMAKE_CURRENT_SOURCE_DIR}/src
542
6
    
543
7
  ${Boost_INCLUDE_DIRS}
544
8
)
545
9
546
10
LINK_DIRECTORIES (${COMPIZ_LIBRARY_DIRS}) 
547
11
548
12
SET( 
549
13
  SRCS 
550
14
  ${CMAKE_CURRENT_SOURCE_DIR}/src/framebuffer-direct-draw.cpp
551
15
)
552
16
553
17
ADD_LIBRARY( 
554
18
  compiz_opengl_framebuffer_direct_draw STATIC
555
19
  
556
20
  ${SRCS}
557
21
)
558
22
559
23
if (COMPIZ_BUILD_TESTING)
560
24
ADD_SUBDIRECTORY( ${CMAKE_CURRENT_SOURCE_DIR}/tests )
561
25
endif (COMPIZ_BUILD_TESTING)
562
26
563
27
TARGET_LINK_LIBRARIES(
564
28
  compiz_opengl_framebuffer_direct_draw
565
29
566
30
  compiz_region
567
31
  compiz_logmessage
568
32
)
569
0
33
570
=== added directory 'plugins/opengl/src/fbdirectdraw/include'
571
=== added file 'plugins/opengl/src/fbdirectdraw/include/framebuffer-direct-draw.h'
572
--- plugins/opengl/src/fbdirectdraw/include/framebuffer-direct-draw.h	1970-01-01 00:00:00 +0000
573
+++ plugins/opengl/src/fbdirectdraw/include/framebuffer-direct-draw.h	2013-02-13 11:45:25 +0000
574
@@ -0,0 +1,111 @@
575
1
/*
576
2
 * Compiz, opengl plugin, FramebufferDirectDraw class
577
3
 *
578
4
 * Copyright (c) 2012 Canonical Ltd.
579
5
 * Authors: Sam Spilsbury <sam.spilsbury@canonical.com>
580
6
 * 
581
7
 * Permission is hereby granted, free of charge, to any person obtaining a
582
8
 * copy of this software and associated documentation files (the "Software"),
583
9
 * to deal in the Software without restriction, including without limitation
584
10
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
585
11
 * and/or sell copies of the Software, and to permit persons to whom the
586
12
 * Software is furnished to do so, subject to the following conditions:
587
13
 * 
588
14
 * The above copyright notice and this permission notice shall be included in
589
15
 * all copies or substantial portions of the Software.
590
16
 * 
591
17
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
592
18
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
593
19
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
594
20
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
595
21
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
596
22
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
597
23
 * DEALINGS IN THE SOFTWARE.
598
24
 */
599
25
#ifndef _COMPIZ_OPENGL_FRAMEBUFFER_DIRECT_DRAW_H
600
26
#define _COMPIZ_OPENGL_FRAMEBUFFER_DIRECT_DRAW_H
601
27
602
28
#include <memory>
603
29
#include <boost/shared_ptr.hpp>
604
30
#include <core/rect.h>
605
31
#include <opengl/framebufferobject.h>
606
32
607
33
class GLVertexBuffer;
608
34
609
35
namespace compiz
610
36
{
611
37
namespace opengl
612
38
{
613
39
namespace impl
614
40
{
615
41
namespace cglfb = compiz::opengl;
616
42
617
43
class PrivateDirectDrawStrategies;
618
44
619
45
class DirectDrawStrategies :
620
46
    public cglfb::DirectDrawStrategies
621
47
{
622
48
    public:
623
49
624
50
	typedef boost::shared_ptr <DirectDrawStrategies> Ptr;
625
51
626
52
	DirectDrawStrategies (const RectangularDrawList &strategies);
627
53
628
54
	void draw (const CompRect   &src,
629
55
		   const CompRect   &dst,
630
56
		   BlitMask  mask,
631
57
		   Filter           filter);
632
58
633
59
    private:
634
60
635
61
	std::auto_ptr <PrivateDirectDrawStrategies> priv;
636
62
};
637
63
638
64
class PrivateDirectDrawObject;
639
65
640
66
class DirectDrawObject :
641
67
    virtual public cglfb::FramebufferObject,
642
68
    public cglfb::DirectDrawObject
643
69
{
644
70
    public:
645
71
646
72
	DirectDrawObject (const boost::shared_ptr <cglfb::DirectDrawStrategies> &,
647
73
			  const boost::shared_ptr <cglfb::FramebufferObject>    &,
648
74
			  const boost::shared_ptr <cglfb::BindableFramebuffer>  &);
649
75
650
76
	bool allocate (const CompSize &size,
651
77
		       const char *image = NULL,
652
78
		       GLenum format = GL_RGBA,
653
79
		       GLenum type = GL_UNSIGNED_BYTE);
654
80
	bool checkStatus ();
655
81
	GLTexture * tex ();
656
82
657
83
	void directDraw (const CompRect         &src,
658
84
			 const CompRect         &dst,
659
85
			 cglfb::BlitMask mask,
660
86
			 cglfb::Filter          filter);
661
87
662
88
    private:
663
89
664
90
	GLuint getResourceId () const;
665
91
	bool   setBindStatus (GLenum);
666
92
	void   updateAllocation (GLenum);
667
93
668
94
	PrivateDirectDrawObject *priv;
669
95
};
670
96
671
97
typedef boost::function <cglfb::BindableFramebuffer * (cglfb::BindableFramebuffer *)>
672
98
    BindReadBufferFunc;
673
99
674
100
bool rectangleDrawFromReadBuffer (const CompRect             &src,
675
101
				  const CompRect             &dst,
676
102
				  GLbitfield                 mask,
677
103
				  GLenum                     filter,
678
104
				  cglfb::BindableFramebuffer *bindable,
679
105
				  const BindReadBufferFunc   &func,
680
106
				  cglfb::RectangularDraw     strategy);
681
107
}
682
108
}
683
109
}
684
110
685
111
#endif
686
0
112
687
=== added directory 'plugins/opengl/src/fbdirectdraw/src'
688
=== added file 'plugins/opengl/src/fbdirectdraw/src/framebuffer-direct-draw.cpp'
689
--- plugins/opengl/src/fbdirectdraw/src/framebuffer-direct-draw.cpp	1970-01-01 00:00:00 +0000
690
+++ plugins/opengl/src/fbdirectdraw/src/framebuffer-direct-draw.cpp	2013-02-13 11:45:25 +0000
691
@@ -0,0 +1,177 @@
692
1
/*
693
2
 * Compiz, opengl plugin, DirectDrawFramebufferStrategies class
694
3
 *
695
4
 * Copyright (c) 2012 Canonical Ltd.
696
5
 * Authors: Sam Spilsbury <sam.spilsbury@canonical.com>
697
6
 * 
698
7
 * Permission is hereby granted, free of charge, to any person obtaining a
699
8
 * copy of this software and associated documentation files (the "Software"),
700
9
 * to deal in the Software without restriction, including without limitation
701
10
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
702
11
 * and/or sell copies of the Software, and to permit persons to whom the
703
12
 * Software is furnished to do so, subject to the following conditions:
704
13
 * 
705
14
 * The above copyright notice and this permission notice shall be included in
706
15
 * all copies or substantial portions of the Software.
707
16
 * 
708
17
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
709
18
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
710
19
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
711
20
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
712
21
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
713
22
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
714
23
 * DEALINGS IN THE SOFTWARE.
715
24
 */
716
25
#include "framebuffer-direct-draw.h"
717
26
718
27
namespace cglfb = compiz::opengl;
719
28
namespace cglfbi = compiz::opengl::impl;
720
29
721
30
class GLTexture;
722
31
class GLVertexBuffer;
723
32
724
33
namespace compiz
725
34
{
726
35
namespace opengl
727
36
{
728
37
namespace impl
729
38
{
730
39
class PrivateDirectDrawStrategies
731
40
{
732
41
    public:
733
42
734
43
	PrivateDirectDrawStrategies (const cglfb::RectangularDrawList &strategies) :
735
44
	    rectDrawList (strategies)
736
45
	{
737
46
	}
738
47
739
48
	cglfb::RectangularDrawList rectDrawList;
740
49
};
741
50
742
51
class PrivateDirectDrawObject
743
52
{
744
53
    public:
745
54
746
55
	PrivateDirectDrawObject (const boost::shared_ptr <cglfb::DirectDrawStrategies> &strategies,
747
56
				 const boost::shared_ptr <cglfb::FramebufferObject>    &object,
748
57
				 const boost::shared_ptr <cglfb::BindableFramebuffer>  &bindable) :
749
58
	    directDrawStrategies (strategies),
750
59
	    framebufferObject (object),
751
60
	    bindableFramebuffer (bindable)
752
61
	{
753
62
	};
754
63
755
64
	boost::shared_ptr <cglfb::DirectDrawStrategies> directDrawStrategies;
756
65
	boost::shared_ptr <cglfb::FramebufferObject>    framebufferObject;
757
66
	boost::shared_ptr <cglfb::BindableFramebuffer>  bindableFramebuffer;
758
67
};
759
68
}
760
69
}
761
70
}
762
71
763
72
cglfbi::DirectDrawObject::DirectDrawObject (const boost::shared_ptr <cglfb::DirectDrawStrategies> &strategies,
764
73
					    const boost::shared_ptr <cglfb::FramebufferObject>    &object,
765
74
					    const boost::shared_ptr <cglfb::BindableFramebuffer>  &bindable) :
766
75
    priv (new cglfbi::PrivateDirectDrawObject (strategies, object, bindable))
767
76
{
768
77
}
769
78
770
79
bool
771
80
cglfbi::DirectDrawObject::allocate (const CompSize &size, const char *image,
772
81
					       GLenum format, GLenum type)
773
82
{
774
83
    return priv->framebufferObject->allocate (size, image, format, type);
775
84
}
776
85
777
86
bool
778
87
cglfbi::DirectDrawObject::checkStatus ()
779
88
{
780
89
    return priv->framebufferObject->checkStatus ();
781
90
}
782
91
783
92
GLTexture *
784
93
cglfbi::DirectDrawObject::tex ()
785
94
{
786
95
    return priv->framebufferObject->tex ();
787
96
}
788
97
789
98
GLuint
790
99
cglfbi::DirectDrawObject::getResourceId () const
791
100
{
792
101
    return priv->bindableFramebuffer->getResourceId ();
793
102
}
794
103
795
104
bool
796
105
cglfbi::DirectDrawObject::setBindStatus (GLenum status)
797
106
{
798
107
    return priv->bindableFramebuffer->setBindStatus (status);
799
108
}
800
109
801
110
void
802
111
cglfbi::DirectDrawObject::updateAllocation (GLenum bindPoint)
803
112
{
804
113
    return priv->bindableFramebuffer->updateAllocation (bindPoint);
805
114
}
806
115
807
116
void
808
117
cglfbi::DirectDrawObject::directDraw (const CompRect         &src,
809
118
				      const CompRect         &dst,
810
119
				      cglfb::BlitMask mask,
811
120
				      cglfb::Filter	     filter)
812
121
{
813
122
    if (!checkStatus ())
814
123
	return;
815
124
816
125
    priv->directDrawStrategies->draw (src, dst, mask, filter);
817
126
}
818
127
819
128
bool
820
129
cglfbi::rectangleDrawFromReadBuffer (const CompRect             &src,
821
130
				     const CompRect             &dst,
822
131
				     GLbitfield                 mask,
823
132
				     GLenum                     filter,
824
133
				     cglfb::BindableFramebuffer *bindable,
825
134
				     const cglfbi::BindReadBufferFunc &bindReadBuffer,
826
135
				     cglfb::RectangularDraw     strategy)
827
136
{
828
137
    bool status = false;
829
138
    /* Bind to the read framebuffer first */
830
139
    cglfb::BindableFramebuffer *old = bindReadBuffer (bindable);
831
140
832
141
    if (old)
833
142
	status = strategy (src, dst, mask, filter);
834
143
835
144
    /* Intentionally not rebinding the old one */
836
145
837
146
    return status;
838
147
}
839
148
840
149
cglfbi::DirectDrawStrategies::DirectDrawStrategies (const cglfb::RectangularDrawList &strategies) :
841
150
    priv (new cglfbi::PrivateDirectDrawStrategies (strategies))
842
151
{
843
152
}
844
153
845
154
void
846
155
cglfbi::DirectDrawStrategies::draw (const CompRect         &src,
847
156
				    const CompRect         &dst,
848
157
				    cglfb::BlitMask mask,
849
158
				    cglfb::Filter          filter)
850
159
{
851
160
    if (!mask)
852
161
	return;
853
162
854
163
    const GLbitfield glMask  = (mask & cglfb::ColorData ? GL_COLOR_BUFFER_BIT : 0) |
855
164
			       (mask & cglfb::StencilData ? GL_STENCIL_BUFFER_BIT : 0);
856
165
    const GLenum glFilter = (filter == cglfb::Fast ? GL_NEAREST : GL_LINEAR);
857
166
858
167
    while (!priv->rectDrawList.empty ())
859
168
    {
860
169
	const cglfb::RectangularDraw &strategy = priv->rectDrawList.back ();
861
170
862
171
	/* If one method fails, try the next */
863
172
	if (!strategy (src, dst,  glMask, glFilter))
864
173
	    priv->rectDrawList.pop_back ();
865
174
	else
866
175
	    break;
867
176
    }
868
177
}
869
0
178
870
=== added directory 'plugins/opengl/src/fbdirectdraw/tests'
871
=== added file 'plugins/opengl/src/fbdirectdraw/tests/CMakeLists.txt'
872
--- plugins/opengl/src/fbdirectdraw/tests/CMakeLists.txt	1970-01-01 00:00:00 +0000
873
+++ plugins/opengl/src/fbdirectdraw/tests/CMakeLists.txt	2013-02-13 11:45:25 +0000
874
@@ -0,0 +1,24 @@
875
1
find_library (GMOCK_LIBRARY gmock)
876
2
find_library (GMOCK_MAIN_LIBRARY gmock_main)
877
3
878
4
if (NOT GMOCK_LIBRARY OR NOT GMOCK_MAIN_LIBRARY OR NOT GTEST_FOUND)
879
5
  message ("Google Mock and Google Test not found - cannot build tests!")
880
6
  set (COMPIZ_BUILD_TESTING OFF)
881
7
endif (NOT GMOCK_LIBRARY OR NOT GMOCK_MAIN_LIBRARY OR NOT GTEST_FOUND)
882
8
883
9
include_directories (${GTEST_INCLUDE_DIRS})
884
10
885
11
link_directories (${COMPIZ_LIBRARY_DIRS})
886
12
887
13
add_executable (compiz_test_opengl_framebuffer_direct_draw
888
14
                ${CMAKE_CURRENT_SOURCE_DIR}/test-opengl-framebuffer-direct-draw.cpp)
889
15
890
16
target_link_libraries (compiz_test_opengl_framebuffer_direct_draw
891
17
                       compiz_opengl_framebuffer_direct_draw
892
18
                       ${GTEST_BOTH_LIBRARIES}
893
19
		       ${GMOCK_LIBRARY}
894
20
		       ${GMOCK_MAIN_LIBRARY}
895
21
		       ${CMAKE_THREAD_LIBS_INIT} # Link in pthread.
896
22
                       )
897
23
898
24
compiz_discover_tests (compiz_test_opengl_framebuffer_direct_draw COVERAGE compiz_opengl_framebuffer_direct_draw)
899
0
25
900
=== added file 'plugins/opengl/src/fbdirectdraw/tests/test-opengl-framebuffer-direct-draw.cpp'
901
--- plugins/opengl/src/fbdirectdraw/tests/test-opengl-framebuffer-direct-draw.cpp	1970-01-01 00:00:00 +0000
902
+++ plugins/opengl/src/fbdirectdraw/tests/test-opengl-framebuffer-direct-draw.cpp	2013-02-13 11:45:25 +0000
903
@@ -0,0 +1,236 @@
904
1
/*
905
2
 * Compiz, opengl plugin, DirectDrawFramebufferStrategies class
906
3
 *
907
4
 * Copyright (c) 2012 Canonical Ltd.
908
5
 * Authors: Sam Spilsbury <sam.spilsbury@canonical.com>
909
6
 * 
910
7
 * Permission is hereby granted, free of charge, to any person obtaining a
911
8
 * copy of this software and associated documentation files (the "Software"),
912
9
 * to deal in the Software without restriction, including without limitation
913
10
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
914
11
 * and/or sell copies of the Software, and to permit persons to whom the
915
12
 * Software is furnished to do so, subject to the following conditions:
916
13
 * 
917
14
 * The above copyright notice and this permission notice shall be included in
918
15
 * all copies or substantial portions of the Software.
919
16
 * 
920
17
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
921
18
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
922
19
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
923
20
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
924
21
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
925
22
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
926
23
 * DEALINGS IN THE SOFTWARE.
927
24
 */
928
25
#include <memory>
929
26
#include <boost/function.hpp>
930
27
#include <boost/bind.hpp>
931
28
#include <gtest/gtest.h>
932
29
#include <gmock/gmock.h>
933
30
#include <opengl/opengl-api.h>
934
31
#include <opengl/framebufferobject.h>
935
32
#include "framebuffer-direct-draw.h"
936
33
937
34
using ::testing::Return;
938
35
using ::testing::_;
939
36
using ::testing::Expectation;
940
37
using ::testing::StrictMock;
941
38
using ::testing::NiceMock;
942
39
using ::testing::ReturnNull;
943
40
944
41
namespace cglfb = compiz::opengl;
945
42
namespace cglfbi = compiz::opengl::impl;
946
43
947
44
namespace
948
45
{
949
46
class MockDrawStrategy
950
47
{
951
48
    public:
952
49
953
50
	MOCK_METHOD4 (draw, bool (const CompRect &,
954
51
				  const CompRect &,
955
52
				  GLbitfield,
956
53
				  GLenum));
957
54
};
958
55
959
56
class MockBindLocation :
960
57
    public cglfb::BindLocation
961
58
{
962
59
    public:
963
60
964
61
	MOCK_METHOD1 (bind, cglfb::BindableFramebuffer * (cglfb::BindableFramebuffer *));
965
62
};
966
63
967
64
class MockBindable :
968
65
    public cglfb::BindableFramebuffer
969
66
{
970
67
    public:
971
68
972
69
	MOCK_METHOD1 (updateAllocation, void (GLenum));
973
70
	MOCK_METHOD1 (setBindStatus, bool (GLenum));
974
71
	MOCK_CONST_METHOD0 (getResourceId, GLuint ());
975
72
};
976
73
977
74
}
978
75
979
76
class FBDirectDrawStrategies :
980
77
    public ::testing::Test
981
78
{
982
79
    public:
983
80
984
81
	FBDirectDrawStrategies () :
985
82
	    blitFramebuffer (boost::bind (&MockDrawStrategy::draw, &mpfb, _1, _2, _3, _4)),
986
83
	    rtdraw (boost::bind (&MockDrawStrategy::draw, &mdr,
987
84
				 _1, _2, _3, _4))
988
85
	{
989
86
	}
990
87
991
88
	void SetUpStrategyList (const cglfb::RectangularDraw &blit,
992
89
				const cglfb::RectangularDraw &draw)
993
90
	{
994
91
	    strategyList.clear ();
995
92
	    strategyList.push_back (draw);
996
93
	    strategyList.push_back (blit);
997
94
	}
998
95
999
96
	virtual void SetUp ()
1000
97
	{
1001
98
	    boost::function <cglfb::BindableFramebuffer * (cglfb::BindableFramebuffer *)> readBind
1002
99
		    (boost::bind (&MockBindLocation::bind, &mockBindLocation, _1));
1003
100
	    blitFramebufferWithReadPushed = boost::bind (&cglfbi::rectangleDrawFromReadBuffer,
1004
101
							 _1, _2, _3, _4,
1005
102
							 &mockBindable,
1006
103
							 readBind,
1007
104
							 blitFramebuffer);
1008
105
1009
106
	    SetUpStrategyList (blitFramebuffer, rtdraw);
1010
107
	    directDraw.reset (new cglfbi::DirectDrawStrategies (strategyList));
1011
108
	}
1012
109
1013
110
	std::auto_ptr <cglfbi::DirectDrawStrategies> directDraw;
1014
111
	MockDrawStrategy        mpfb;
1015
112
	cglfb::RectangularDraw     blitFramebuffer;
1016
113
	cglfb::RectangularDraw     blitFramebufferWithReadPushed;
1017
114
	MockDrawStrategy        mdr;
1018
115
	StrictMock <MockBindable>     mockBindable;
1019
116
	StrictMock <MockBindLocation> mockBindLocation;
1020
117
	cglfb::RectangularDraw     rtdraw;
1021
118
	cglfb::RectangularDrawList strategyList;
1022
119
1023
120
};
1024
121
1025
122
TEST_F (FBDirectDrawStrategies, BufferBitsSet)
1026
123
{
1027
124
    CompRect srcAndDst (0, 0, 0, 0);
1028
125
1029
126
    EXPECT_CALL (mpfb, draw (srcAndDst, srcAndDst, GL_COLOR_BUFFER_BIT |
1030
127
						   GL_STENCIL_BUFFER_BIT,
1031
128
			     _)).WillOnce (Return (true));
1032
129
1033
130
    directDraw->draw (srcAndDst,
1034
131
		      srcAndDst,
1035
132
		      static_cast <cglfb::BlitMask> (cglfb::ColorData |
1036
133
							    cglfb::StencilData),
1037
134
		      cglfb::Good);
1038
135
}
1039
136
1040
137
TEST_F (FBDirectDrawStrategies, BufferNoBitsSet)
1041
138
{
1042
139
    CompRect srcAndDst (0, 0, 0, 0);
1043
140
1044
141
    EXPECT_CALL (mpfb, draw (srcAndDst, srcAndDst, 0,
1045
142
			     _)).Times (0);
1046
143
1047
144
    directDraw->draw (srcAndDst,
1048
145
		      srcAndDst,
1049
146
		      static_cast <cglfb::BlitMask> (0),
1050
147
		      cglfb::Good);
1051
148
}
1052
149
1053
150
TEST_F (FBDirectDrawStrategies, GoodToLinear)
1054
151
{
1055
152
    CompRect srcAndDst (0, 0, 0, 0);
1056
153
1057
154
    EXPECT_CALL (mpfb, draw (srcAndDst, srcAndDst, _,
1058
155
			     GL_LINEAR)).WillOnce (Return (true));
1059
156
1060
157
    directDraw->draw (srcAndDst,
1061
158
		      srcAndDst,
1062
159
		      cglfb::ColorData,
1063
160
		      cglfb::Good);
1064
161
}
1065
162
1066
163
TEST_F (FBDirectDrawStrategies, FastToNearest)
1067
164
{
1068
165
    CompRect srcAndDst (0, 0, 0, 0);
1069
166
1070
167
    EXPECT_CALL (mpfb, draw (srcAndDst, srcAndDst, _,
1071
168
			     GL_NEAREST)).WillOnce (Return (true));
1072
169
1073
170
    directDraw->draw (srcAndDst,
1074
171
		      srcAndDst,
1075
172
		      cglfb::ColorData,
1076
173
		      cglfb::Fast);
1077
174
}
1078
175
1079
176
TEST_F (FBDirectDrawStrategies, RevertToPaintWhenBlitUnavailable)
1080
177
{
1081
178
    CompRect srcAndDst (0, 0, 0, 0);
1082
179
1083
180
    EXPECT_CALL (mpfb, draw (srcAndDst, srcAndDst, _,
1084
181
			     _)).WillOnce (Return (false));
1085
182
    EXPECT_CALL (mdr, draw (srcAndDst, srcAndDst, _, _));
1086
183
1087
184
    directDraw->draw (srcAndDst,
1088
185
		      srcAndDst,
1089
186
		      cglfb::ColorData,
1090
187
		      cglfb::Fast);
1091
188
}
1092
189
1093
190
TEST_F (FBDirectDrawStrategies, RevertOnBlitUnavailablePermanent)
1094
191
{
1095
192
    StrictMock <MockDrawStrategy> strictMdr;
1096
193
    CompRect srcAndDst (0, 0, 0, 0);
1097
194
1098
195
    rtdraw = boost::bind (&MockDrawStrategy::draw, &strictMdr, _1, _2, _3, _4);
1099
196
1100
197
    SetUpStrategyList (blitFramebuffer, rtdraw);
1101
198
    directDraw.reset (new cglfbi::DirectDrawStrategies (strategyList));
1102
199
1103
200
    EXPECT_CALL (mpfb, draw (srcAndDst, srcAndDst, _, _)).WillOnce (Return (false));
1104
201
    ON_CALL (strictMdr, draw (_, _, _, _)).WillByDefault (Return (true));
1105
202
    EXPECT_CALL (strictMdr, draw (srcAndDst, srcAndDst, _, _)).Times (2);
1106
203
1107
204
    directDraw->draw (srcAndDst,
1108
205
		      srcAndDst,
1109
206
		      cglfb::ColorData,
1110
207
		      cglfb::Fast);
1111
208
    directDraw->draw (srcAndDst,
1112
209
		      srcAndDst,
1113
210
		      cglfb::ColorData,
1114
211
		      cglfb::Fast);
1115
212
}
1116
213
1117
214
TEST_F (FBDirectDrawStrategies, BindReadFramebufferOnBlit)
1118
215
{
1119
216
    CompRect srcAndDst (0, 0, 0, 0);
1120
217
1121
218
    SetUpStrategyList (blitFramebufferWithReadPushed, rtdraw);
1122
219
    directDraw.reset (new cglfbi::DirectDrawStrategies (strategyList));
1123
220
1124
221
    MockBindable backBuffer;
1125
222
1126
223
    EXPECT_CALL (mockBindLocation, bind (&mockBindable)).WillOnce (Return (&backBuffer));
1127
224
    EXPECT_CALL (mpfb, draw (srcAndDst, srcAndDst, _, _)).WillOnce (Return (false));
1128
225
    ON_CALL (mdr, draw (_, _, _, _)).WillByDefault (Return (true));
1129
226
    EXPECT_CALL (mdr, draw (srcAndDst, srcAndDst, _, _)).Times (2);
1130
227
1131
228
    directDraw->draw (srcAndDst,
1132
229
		      srcAndDst,
1133
230
		      cglfb::ColorData,
1134
231
		      cglfb::Fast);
1135
232
    directDraw->draw (srcAndDst,
1136
233
		      srcAndDst,
1137
234
		      cglfb::ColorData,
1138
235
		      cglfb::Fast);
1139
236
}
1140
0
237
1141
=== modified file 'plugins/opengl/src/framebufferobject.cpp'
1142
--- plugins/opengl/src/framebufferobject.cpp	2012-08-06 09:44:49 +0000
1143
+++ plugins/opengl/src/framebufferobject.cpp	2013-02-13 11:45:25 +0000
1144
@@ -22,88 +22,96 @@
1145
22
 *
22
 *
1146
23
 * Authors: Pekka Paalanen <ppaalanen@gmail.com>
23
 * Authors: Pekka Paalanen <ppaalanen@gmail.com>
1147
24
 */
24
 */
1149
25
25
#include <memory>
1150
26
#include <map>
26
#include <map>
1151
27
#include <opengl/opengl.h>
1152
27
#include <opengl/framebufferobject.h>
28
#include <opengl/framebufferobject.h>
1153
28
#include <opengl/texture.h>
29
#include <opengl/texture.h>
1154
29
30
1155
31
#include "framebuffer-direct-draw.h"
1156
32
1157
33
namespace cglfb = compiz::opengl;
1158
34
namespace cglfbi = compiz::opengl::impl;
1159
35
1160
36
namespace compiz
1161
37
{
1162
38
namespace opengl
1163
39
{
1164
40
namespace impl
1165
41
{
1166
30
struct PrivateGLFramebufferObject
42
struct PrivateGLFramebufferObject
1167
31
{
43
{
1168
32
    PrivateGLFramebufferObject () :
44
    PrivateGLFramebufferObject () :
1169
33
	fboId (0),
45
	fboId (0),
1170
34
	pushedId (0),
1171
35
	glTex (NULL),
46
	glTex (NULL),
1172
36
	status (-1)
47
	status (-1)
1173
37
    {
48
    {
1174
38
    }
49
    }
1175
39
50
1176
40
    void pushFBO ();
1177
41
    void popFBO ();
1178
42
1179
43
    GLuint fboId;
51
    GLuint fboId;
1180
44
    GLuint pushedId;
1181
45
    GLuint rbStencilId;
52
    GLuint rbStencilId;
1182
46
    GLTexture *glTex;
53
    GLTexture *glTex;
1183
47
54
1184
48
    GLint status;
55
    GLint status;
1185
49
56
1188
50
    static GLuint boundId;
57
    std::auto_ptr <cglfb::DirectDrawStrategies> mDirectDraw;
1189
51
    static std::map<GLuint, GLFramebufferObject *> idMap;
58
    GLVertexBuffer                              *vertexBuffer;
1190
52
};
59
};
1191
53
60
1218
54
GLuint PrivateGLFramebufferObject::boundId = 0;
61
}
1219
55
std::map<GLuint, GLFramebufferObject *> PrivateGLFramebufferObject::idMap;
62
}
1220
56
63
}
1221
57
void
64
1222
58
PrivateGLFramebufferObject::pushFBO ()
65
GLuint
1223
59
{
66
cglfbi::FramebufferObject::getResourceId () const
1224
60
    pushedId = boundId;
67
{
1225
61
    if (boundId != fboId)
68
    return priv->fboId;
1226
62
    {
69
}
1227
63
	(*GL::bindFramebuffer) (GL::FRAMEBUFFER, fboId);
70
1228
64
	boundId = fboId;
71
bool
1229
65
    }
72
cglfbi::FramebufferObject::setBindStatus (GLenum status)
1230
66
}
73
{
1231
67
74
    priv->status = status;
1232
68
void
75
    return checkStatus ();
1233
69
PrivateGLFramebufferObject::popFBO ()
76
}
1234
70
{
77
1235
71
    if (boundId != pushedId)
78
void
1236
72
    {
79
cglfbi::FramebufferObject::updateAllocation (GLenum bindingLocation)
1237
73
	(*GL::bindFramebuffer) (GL::FRAMEBUFFER, pushedId);
80
{
1238
74
	boundId = pushedId;
81
    if (priv->status == -1)
1239
75
    }
82
    {
1240
76
}
83
	(*GL::framebufferTexture2D) (bindingLocation, GL::COLOR_ATTACHMENT0,
1241
77
84
				     priv->glTex->target (),
1242
78
GLFramebufferObject::GLFramebufferObject () :
85
				     priv->glTex->name (), 0);
1243
79
    priv (new PrivateGLFramebufferObject)
86
	(*GL::framebufferRenderbuffer) (bindingLocation, GL::DEPTH_ATTACHMENT, GL::RENDERBUFFER, priv->rbStencilId);
1244
87
	(*GL::framebufferRenderbuffer) (bindingLocation, GL::STENCIL_ATTACHMENT, GL::RENDERBUFFER, priv->rbStencilId);
1245
88
    }
1246
89
1247
90
}
1248
91
1249
92
cglfbi::FramebufferObject::FramebufferObject () :
1250
93
    priv (new cglfbi::PrivateGLFramebufferObject ())
1251
80
{
94
{
1252
81
    (*GL::genFramebuffers) (1, &priv->fboId);
95
    (*GL::genFramebuffers) (1, &priv->fboId);
1253
82
    (*GL::genRenderbuffers) (1, &priv->rbStencilId);
96
    (*GL::genRenderbuffers) (1, &priv->rbStencilId);
1254
83
1255
84
    if (priv->fboId != 0)
1256
85
	PrivateGLFramebufferObject::idMap[priv->fboId] = this;
1257
86
}
97
}
1258
87
98
1260
88
GLFramebufferObject::~GLFramebufferObject ()
99
cglfbi::FramebufferObject::~FramebufferObject ()
1261
89
{
100
{
1262
90
    if (priv->glTex)
101
    if (priv->glTex)
1263
91
	GLTexture::decRef (priv->glTex);
102
	GLTexture::decRef (priv->glTex);
1264
92
103
1265
93
    PrivateGLFramebufferObject::idMap.erase (priv->fboId);
1266
94
    (*GL::deleteFramebuffers) (1, &priv->fboId);
104
    (*GL::deleteFramebuffers) (1, &priv->fboId);
1267
95
    (*GL::deleteRenderbuffers) (1, &priv->rbStencilId);
105
    (*GL::deleteRenderbuffers) (1, &priv->rbStencilId);
1268
96
106
1269
97
1270
98
    delete priv;
107
    delete priv;
1271
99
}
108
}
1272
100
109
1273
101
bool
110
bool
1276
102
GLFramebufferObject::allocate (const CompSize &size, const char *image,
111
cglfbi::FramebufferObject::allocate (const CompSize &size,
1277
103
			       GLenum format, GLenum type)
112
				     const char *image,
1278
113
				     GLenum format, GLenum type)
1279
104
{
114
{
1280
105
    priv->status = -1;
1281
106
1282
107
    if (!priv->glTex ||
115
    if (!priv->glTex ||
1283
108
        size.width () != priv->glTex->width () ||
116
        size.width () != priv->glTex->width () ||
1284
109
        size.height () != priv->glTex->height ())
117
        size.height () != priv->glTex->height ())
1285
@@ -125,86 +133,39 @@
1286
125
	    (*GL::bindRenderbuffer) (GL::RENDERBUFFER, priv->rbStencilId);
133
	    (*GL::bindRenderbuffer) (GL::RENDERBUFFER, priv->rbStencilId);
1287
126
	    (*GL::renderbufferStorage) (GL::RENDERBUFFER, GL::DEPTH24_STENCIL8, size.width (), size.height ());
134
	    (*GL::renderbufferStorage) (GL::RENDERBUFFER, GL::DEPTH24_STENCIL8, size.width (), size.height ());
1288
127
	}
135
	}
1289
136
1290
137
        priv->status = -1;
1291
128
    }
138
    }
1292
129
139
1293
130
    priv->pushFBO ();
1294
131
1295
132
    (*GL::framebufferTexture2D) (GL::FRAMEBUFFER, GL::COLOR_ATTACHMENT0,
1296
133
                                 priv->glTex->target (),
1297
134
                                 priv->glTex->name (), 0);
1298
135
1299
136
    priv->status = (*GL::checkFramebufferStatus) (GL::DRAW_FRAMEBUFFER);
1300
137
1301
138
    priv->popFBO ();
1302
139
    return true;
140
    return true;
1303
140
}
141
}
1304
141
142
1345
142
GLFramebufferObject *
143
namespace
1346
143
GLFramebufferObject::bind ()
144
{
1347
144
{
145
const char *
1308
145
    GLFramebufferObject *old = NULL;
1309
146
1310
147
    if (priv->boundId != 0)
1311
148
    {
1312
149
	std::map<GLuint, GLFramebufferObject *>::iterator it;
1313
150
	it = PrivateGLFramebufferObject::idMap.find (priv->boundId);
1314
151
1315
152
	if (it != PrivateGLFramebufferObject::idMap.end ())
1316
153
	    old = it->second;
1317
154
	else
1318
155
	    compLogMessage ("opengl", CompLogLevelError,
1319
156
		"An FBO without GLFramebufferObject cannot be restored");
1320
157
    }
1321
158
1322
159
    (*GL::bindFramebuffer) (GL::FRAMEBUFFER, priv->fboId);
1323
160
    priv->boundId = priv->fboId;
1324
161
1325
162
    (*GL::framebufferRenderbuffer) (GL::FRAMEBUFFER, GL::DEPTH_ATTACHMENT, GL::RENDERBUFFER, priv->rbStencilId);
1326
163
    (*GL::framebufferRenderbuffer) (GL::FRAMEBUFFER, GL::STENCIL_ATTACHMENT, GL::RENDERBUFFER, priv->rbStencilId);
1327
164
1328
165
    return old;
1329
166
}
1330
167
1331
168
// static
1332
169
void
1333
170
GLFramebufferObject::rebind (GLFramebufferObject *fbo)
1334
171
{
1335
172
    GLuint id = fbo ? fbo->priv->fboId : 0;
1336
173
1337
174
    if (id != fbo->priv->boundId)
1338
175
    {
1339
176
	(*GL::bindFramebuffer) (GL::FRAMEBUFFER, id);
1340
177
	fbo->priv->boundId = id;
1341
178
    }
1342
179
}
1343
180
1344
181
static const char *
1348
182
getFboErrorString (GLint status)
146
getFboErrorString (GLint status)
1349
183
{
147
{
1350
184
    switch (status)
148
    switch (status)
1351
185
    {
149
    {
1353
186
	case        GL::FRAMEBUFFER_COMPLETE:
150
	case GL::FRAMEBUFFER_COMPLETE:
1354
187
	    return "GL::FRAMEBUFFER_COMPLETE";
151
	    return "GL::FRAMEBUFFER_COMPLETE";
1356
188
	case        GL::FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
152
	case GL::FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
1357
189
	    return "GL::FRAMEBUFFER_INCOMPLETE_ATTACHMENT";
153
	    return "GL::FRAMEBUFFER_INCOMPLETE_ATTACHMENT";
1359
190
	case        GL::FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
154
	case GL::FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
1360
191
	    return "GL::FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT";
155
	    return "GL::FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT";
1362
192
	case        GL::FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
156
	case GL::FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
1363
193
	    return "GL::FRAMEBUFFER_INCOMPLETE_DIMENSIONS";
157
	    return "GL::FRAMEBUFFER_INCOMPLETE_DIMENSIONS";
1365
194
	case        GL::FRAMEBUFFER_UNSUPPORTED:
158
	case GL::FRAMEBUFFER_UNSUPPORTED:
1366
195
	    return "GL::FRAMEBUFFER_UNSUPPORTED";
159
	    return "GL::FRAMEBUFFER_UNSUPPORTED";
1367
196
	default:
160
	default:
1368
197
	    return "unexpected status";
161
	    return "unexpected status";
1369
198
    }
162
    }
1370
199
}
163
}
1371
164
}
1372
200
165
1373
201
bool
166
bool
1375
202
GLFramebufferObject::checkStatus ()
167
cglfbi::FramebufferObject::checkStatus ()
1376
203
{
168
{
1377
204
    priv->pushFBO ();
1378
205
    priv-> status = (*GL::checkFramebufferStatus) (GL_FRAMEBUFFER);
1379
206
    priv->popFBO ();
1380
207
1381
208
    if (priv->status == static_cast <GLint> (GL::FRAMEBUFFER_COMPLETE))
169
    if (priv->status == static_cast <GLint> (GL::FRAMEBUFFER_COMPLETE))
1382
209
	return true;
170
	return true;
1383
210
171
1384
@@ -215,7 +176,47 @@
1385
215
}
176
}
1386
216
177
1387
217
GLTexture *
178
GLTexture *
1389
218
GLFramebufferObject::tex ()
179
cglfbi::FramebufferObject::tex ()
1390
219
{
180
{
1391
220
    return priv->glTex;
181
    return priv->glTex;
1392
221
}
182
}
1393
183
1394
184
class cglfbi::FBOBindLocation::Private
1395
185
{
1396
186
    public:
1397
187
1398
188
	Private (GLenum                     binding,
1399
189
		 cglfb::BindableFramebuffer *back) :
1400
190
	    mCurrentlyBound (back),
1401
191
	    mBindPoint (binding)
1402
192
	{
1403
193
	}
1404
194
1405
195
	cglfb::BindableFramebuffer *mCurrentlyBound;
1406
196
	GLenum                     mBindPoint;
1407
197
};
1408
198
1409
199
cglfbi::FBOBindLocation::FBOBindLocation (GLenum                     binding,
1410
200
					  cglfb::BindableFramebuffer *back) :
1411
201
    priv (new cglfbi::FBOBindLocation::Private (binding, back))
1412
202
{
1413
203
}
1414
204
1415
205
cglfb::BindableFramebuffer *
1416
206
cglfbi::FBOBindLocation::bind (cglfb::BindableFramebuffer *next)
1417
207
{
1418
208
    if (priv->mCurrentlyBound == next)
1419
209
	return next;
1420
210
1421
211
    (*GL::bindFramebuffer) (priv->mBindPoint, next->getResourceId ());
1422
212
    next->updateAllocation (priv->mBindPoint);
1423
213
    if (!next->setBindStatus ((*GL::checkFramebufferStatus) (priv->mBindPoint)))
1424
214
    {
1425
215
	(*GL::bindFramebuffer) (priv->mBindPoint, priv->mCurrentlyBound->getResourceId ());
1426
216
	return NULL;
1427
217
    }
1428
218
1429
219
    cglfb::BindableFramebuffer *last = priv->mCurrentlyBound;
1430
220
    priv->mCurrentlyBound = next;
1431
221
    return last;
1432
222
}
1433
222
223
1434
=== modified file 'plugins/opengl/src/paint.cpp'
1435
--- plugins/opengl/src/paint.cpp	2013-01-01 10:04:50 +0000
1436
+++ plugins/opengl/src/paint.cpp	2013-02-13 11:45:25 +0000
1437
@@ -44,6 +44,7 @@
1438
44
#define DEG2RAD (M_PI / 180.0f)
44
#define DEG2RAD (M_PI / 180.0f)
1439
45
45
1440
46
using namespace compiz::opengl;
46
using namespace compiz::opengl;
1441
47
namespace cglfb = compiz::opengl;
1442
47
48
1443
48
GLScreenPaintAttrib defaultScreenPaintAttrib = {
49
GLScreenPaintAttrib defaultScreenPaintAttrib = {
1444
49
    0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -DEFAULT_Z_CAMERA
50
    0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -DEFAULT_Z_CAMERA
1445
@@ -669,89 +670,16 @@
1446
669
}
670
}
1447
670
671
1448
671
void
672
void
1452
672
GLScreen::glPaintCompositedOutput (const CompRegion    &region,
673
GLScreen::glPaintCompositedOutput (const CompRegion			       &region,
1453
673
				   GLFramebufferObject *fbo,
674
				   compiz::opengl::DirectDrawObject *fbo,
1454
674
				   unsigned int         mask)
675
				   unsigned int				       mask)
1455
675
{
676
{
1456
676
    WRAPABLE_HND_FUNCTN (glPaintCompositedOutput, region, fbo, mask)
677
    WRAPABLE_HND_FUNCTN (glPaintCompositedOutput, region, fbo, mask)
1457
677
678
1535
678
    GLMatrix sTransform;
679
    /* Draw every rect individually, this could be a little slow
1536
679
    const GLTexture::Matrix & texmatrix = fbo->tex ()->matrix ();
680
     * for lots of rects, but the general usecase isn't that */
1537
680
    GLVertexBuffer *streamingBuffer = GLVertexBuffer::streamingBuffer ();
681
    foreach (const CompRect &r, region.rects ())
1538
681
682
	fbo->directDraw (r, r, cglfb::ColorData, cglfb::Fast);
1462
682
    streamingBuffer->begin (GL_TRIANGLES);
1463
683
1464
684
    if (mask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK)
1465
685
    {
1466
686
	GLfloat tx1 = COMP_TEX_COORD_X (texmatrix, 0.0f);
1467
687
	GLfloat tx2 = COMP_TEX_COORD_X (texmatrix, screen->width ());
1468
688
	GLfloat ty1 = 1.0 - COMP_TEX_COORD_Y (texmatrix, 0.0f);
1469
689
	GLfloat ty2 = 1.0 - COMP_TEX_COORD_Y (texmatrix, screen->height ());
1470
690
1471
691
	const GLfloat vertexData[] = {
1472
692
	    0.0f,                    0.0f,                     0.0f,
1473
693
	    0.0f,                    (float)screen->height (), 0.0f,
1474
694
	    (float)screen->width (), 0.0f,                     0.0f,
1475
695
1476
696
	    0.0f,                    (float)screen->height (), 0.0f,
1477
697
	    (float)screen->width (), (float)screen->height (), 0.0f,
1478
698
	    (float)screen->width (), 0.0f,                     0.0f,
1479
699
	};
1480
700
1481
701
	const GLfloat textureData[] = {
1482
702
	    tx1, ty1,
1483
703
	    tx1, ty2,
1484
704
	    tx2, ty1,
1485
705
	    tx1, ty2,
1486
706
	    tx2, ty2,
1487
707
	    tx2, ty1,
1488
708
	};
1489
709
1490
710
	streamingBuffer->addVertices (6, &vertexData[0]);
1491
711
	streamingBuffer->addTexCoords (0, 6, &textureData[0]);
1492
712
    }
1493
713
    else
1494
714
    {
1495
715
	BoxPtr pBox = const_cast <Region> (region.handle ())->rects;
1496
716
	int nBox = const_cast <Region> (region.handle ())->numRects;
1497
717
1498
718
	while (nBox--)
1499
719
	{
1500
720
	    GLfloat tx1 = COMP_TEX_COORD_X (texmatrix, pBox->x1);
1501
721
	    GLfloat tx2 = COMP_TEX_COORD_X (texmatrix, pBox->x2);
1502
722
	    GLfloat ty1 = 1.0 - COMP_TEX_COORD_Y (texmatrix, pBox->y1);
1503
723
	    GLfloat ty2 = 1.0 - COMP_TEX_COORD_Y (texmatrix, pBox->y2);
1504
724
1505
725
	    const GLfloat vertexData[] = {
1506
726
		(float)pBox->x1, (float)pBox->y1, 0.0f,
1507
727
		(float)pBox->x1, (float)pBox->y2, 0.0f,
1508
728
		(float)pBox->x2, (float)pBox->y1, 0.0f,
1509
729
1510
730
		(float)pBox->x1, (float)pBox->y2, 0.0f,
1511
731
		(float)pBox->x2, (float)pBox->y2, 0.0f,
1512
732
		(float)pBox->x2, (float)pBox->y1, 0.0f,
1513
733
	    };
1514
734
1515
735
	    const GLfloat textureData[] = {
1516
736
		tx1, ty1,
1517
737
		tx1, ty2,
1518
738
		tx2, ty1,
1519
739
		tx1, ty2,
1520
740
		tx2, ty2,
1521
741
		tx2, ty1,
1522
742
	    };
1523
743
1524
744
	    streamingBuffer->addVertices (6, &vertexData[0]);
1525
745
	    streamingBuffer->addTexCoords (0, 6, &textureData[0]);
1526
746
	    pBox++;
1527
747
	}
1528
748
    }
1529
749
1530
750
    streamingBuffer->end ();
1531
751
    fbo->tex ()->enable (GLTexture::Fast);
1532
752
    sTransform.toScreenSpace (&screen->fullscreenOutput (), -DEFAULT_Z_CAMERA);
1533
753
    streamingBuffer->render (sTransform);
1534
754
    fbo->tex ()->disable ();
1539
755
}
683
}
1540
756
684
1541
757
static void
685
static void
1542
758
686
1543
=== modified file 'plugins/opengl/src/privates.h'
1544
--- plugins/opengl/src/privates.h	2013-01-01 09:41:41 +0000
1545
+++ plugins/opengl/src/privates.h	2013-02-13 11:45:25 +0000
1546
@@ -29,21 +29,27 @@
1547
29
#define _OPENGL_PRIVATES_H
29
#define _OPENGL_PRIVATES_H
1548
30
30
1549
31
#include <memory>
31
#include <memory>
1550
32
1551
33
#include <composite/composite.h>
32
#include <composite/composite.h>
1552
34
#include <opengl/opengl.h>
33
#include <opengl/opengl.h>
1553
35
#include <core/atoms.h>
34
#include <core/atoms.h>
1554
36
1555
37
#ifdef USE_GLES
1556
38
#include <opengl/framebufferobject.h>
35
#include <opengl/framebufferobject.h>
1557
39
#endif
1558
40
1559
41
#include <opengl/doublebuffer.h>
36
#include <opengl/doublebuffer.h>
1560
42
37
1561
43
#include "privatetexture.h"
38
#include "privatetexture.h"
1562
44
#include "privatevertexbuffer.h"
39
#include "privatevertexbuffer.h"
1563
45
#include "opengl_options.h"
40
#include "opengl_options.h"
1564
46
41
1565
42
namespace compiz
1566
43
{
1567
44
    namespace opengl
1568
45
    {
1569
46
	namespace impl
1570
47
	{
1571
48
	    class DirectDrawObject;
1572
49
	}
1573
50
    }
1574
51
}
1575
52
1576
47
extern CompOutput *targetOutput;
53
extern CompOutput *targetOutput;
1577
48
54
1578
49
class GLDoubleBuffer :
55
class GLDoubleBuffer :
1579
@@ -85,6 +91,17 @@
1580
85
	Window mOutput;
91
	Window mOutput;
1581
86
};
92
};
1582
87
93
1583
94
namespace compiz
1584
95
{
1585
96
    namespace opengl
1586
97
    {
1587
98
	bool blitFramebufferGLX (const CompRect &src,
1588
99
				 const CompRect &dst,
1589
100
				 GLbitfield     mask,
1590
101
				 GLenum         filter);
1591
102
    }
1592
103
}
1593
104
1594
88
#else
105
#else
1595
89
106
1596
90
class EGLDoubleBuffer :
107
class EGLDoubleBuffer :
1597
@@ -108,6 +125,17 @@
1598
108
	EGLSurface const & mSurface;
125
	EGLSurface const & mSurface;
1599
109
};
126
};
1600
110
127
1601
128
namespace compiz
1602
129
{
1603
130
    namespace opengl
1604
131
    {
1605
132
	bool blitFramebufferEGL (const CompRect &src,
1606
133
				 const CompRect &dst,
1607
134
				 GLbitfield     mask,
1608
135
				 GLenum         filter);
1609
136
    }
1610
137
}
1611
138
1612
111
#endif
139
#endif
1613
112
140
1614
113
class GLIcon
141
class GLIcon
1615
@@ -119,6 +147,16 @@
1616
119
	GLTexture::List textures;
147
	GLTexture::List textures;
1617
120
};
148
};
1618
121
149
1619
150
class BindableBackbuffer :
1620
151
    public compiz::opengl::BindableFramebuffer
1621
152
{
1622
153
    public:
1623
154
1624
155
	GLuint getResourceId () const;
1625
156
	bool   setBindStatus (GLenum);
1626
157
	void   updateAllocation (GLenum);
1627
158
};
1628
159
1629
122
class PrivateGLScreen :
160
class PrivateGLScreen :
1630
123
    public ScreenInterface,
161
    public ScreenInterface,
1631
124
    public compiz::composite::PaintHandler,
162
    public compiz::composite::PaintHandler,
1632
@@ -196,8 +234,9 @@
1633
196
	GLXDoubleBuffer doubleBuffer;
234
	GLXDoubleBuffer doubleBuffer;
1634
197
	#endif
235
	#endif
1635
198
236
1638
199
	GLFramebufferObject *scratchFbo;
237
	std::auto_ptr <compiz::opengl::DirectDrawObject> scratchFbo;
1639
200
	CompRegion outputRegion;
238
	compiz::opengl::BlitFramebufferFunc		 blitFramebuffer;
1640
239
	CompRegion					 outputRegion;
1641
201
240
1642
202
	XRectangle lastViewport;
241
	XRectangle lastViewport;
1643
203
	bool refreshSubBuffer;
242
	bool refreshSubBuffer;
1644
@@ -221,6 +260,9 @@
1645
221
	Pixmap rootPixmapCopy;
260
	Pixmap rootPixmapCopy;
1646
222
	CompSize rootPixmapSize;
261
	CompSize rootPixmapSize;
1647
223
262
1648
263
	BindableBackbuffer                    backbuffer;
1649
264
	compiz::opengl::impl::FBOBindLocation drawFramebufferBinding;
1650
265
	compiz::opengl::impl::FBOBindLocation readFramebufferBinding;
1651
224
	const char *glVendor, *glRenderer, *glVersion;
266
	const char *glVendor, *glRenderer, *glVersion;
1652
225
267
1653
226
	mutable CompString prevRegex;
268
	mutable CompString prevRegex;
1654
227
269
1655
=== modified file 'plugins/opengl/src/screen.cpp'
1656
--- plugins/opengl/src/screen.cpp	2013-01-09 10:57:03 +0000
1657
+++ plugins/opengl/src/screen.cpp	2013-02-13 11:45:25 +0000
1658
@@ -36,6 +36,7 @@
1659
36
#include <boost/make_shared.hpp>
36
#include <boost/make_shared.hpp>
1660
37
37
1661
38
#include "privates.h"
38
#include "privates.h"
1662
39
#include "framebuffer-direct-draw.h"
1663
39
#include "blacklist/blacklist.h"
40
#include "blacklist/blacklist.h"
1664
40
41
1665
41
#include <dlfcn.h>
42
#include <dlfcn.h>
1666
@@ -67,6 +68,26 @@
1667
67
68
1668
68
69
1669
69
using namespace compiz::opengl;
70
using namespace compiz::opengl;
1670
71
namespace cglfb = compiz::opengl;
1671
72
namespace cgli = compiz::opengl::impl;
1672
73
1673
74
namespace compiz
1674
75
{
1675
76
    namespace opengl
1676
77
    {
1677
78
#ifndef USE_GLES
1678
79
	bool blitFramebufferGLX (const CompRect &src,
1679
80
				 const CompRect &dst,
1680
81
				 GLbitfield     mask,
1681
82
				 GLenum         filter);
1682
83
#else
1683
84
	bool blitFramebufferEGL (const CompRect &src,
1684
85
				 const CompRect &dst,
1685
86
				 GLbitfield     mask,
1686
87
				 GLenum         filter);
1687
88
#endif
1688
89
    }
1689
90
}
1690
70
91
1691
71
namespace GL {
92
namespace GL {
1692
72
    #ifdef USE_GLES
93
    #ifdef USE_GLES
1693
@@ -164,11 +185,12 @@
1694
164
    GLDisableVertexAttribArrayProc disableVertexAttribArray = NULL;
185
    GLDisableVertexAttribArrayProc disableVertexAttribArray = NULL;
1695
165
    GLVertexAttribPointerProc      vertexAttribPointer = NULL;
186
    GLVertexAttribPointerProc      vertexAttribPointer = NULL;
1696
166
187
1699
167
    GLGenRenderbuffersProc genRenderbuffers = NULL;
188
    GLGenRenderbuffersProc        genRenderbuffers = NULL;
1700
168
    GLDeleteRenderbuffersProc deleteRenderbuffers = NULL;
189
    GLDeleteRenderbuffersProc     deleteRenderbuffers = NULL;
1701
169
    GLFramebufferRenderbufferProc framebufferRenderbuffer = NULL;
190
    GLFramebufferRenderbufferProc framebufferRenderbuffer = NULL;
1704
170
    GLBindRenderbufferProc bindRenderbuffer = NULL;
191
    GLBindRenderbufferProc        bindRenderbuffer = NULL;
1705
171
    GLRenderbufferStorageProc renderbufferStorage = NULL;
192
    GLRenderbufferStorageProc     renderbufferStorage = NULL;
1706
193
    GLBlitFramebufferProc         blitFramebuffer = NULL;
1707
172
194
1708
173
    bool  textureFromPixmap = true;
195
    bool  textureFromPixmap = true;
1709
174
    bool  textureRectangle = false;
196
    bool  textureRectangle = false;
1710
@@ -299,6 +321,115 @@
1711
299
    GLScreen *gScreen;
321
    GLScreen *gScreen;
1712
300
};
322
};
1713
301
323
1714
324
namespace
1715
325
{
1716
326
bool defaultRectangularFramebufferDraw (GLVertexBuffer       *vertexBuffer,
1717
327
					GLFramebufferObject  *fbo,
1718
328
					const CompRect       &src,
1719
329
					const CompRect       &dst,
1720
330
					GLbitfield           mask,
1721
331
					GLenum               filter)
1722
332
{
1723
333
    GLTexture *texture = fbo->tex ();
1724
334
    GLMatrix sTransform;
1725
335
    const GLTexture::Matrix & texmatrix = texture->matrix ();
1726
336
    const GLfloat tx1 = COMP_TEX_COORD_X (texmatrix, src.x1 ());
1727
337
    const GLfloat tx2 = COMP_TEX_COORD_X (texmatrix, src.x2 ());
1728
338
    const GLfloat ty1 = 1.0 - COMP_TEX_COORD_Y (texmatrix, src.y1 ());
1729
339
    const GLfloat ty2 = 1.0 - COMP_TEX_COORD_Y (texmatrix, src.y2 ());
1730
340
1731
341
    const GLfloat vx1 = src.x1 ();
1732
342
    const GLfloat vx2 = src.x2 ();
1733
343
    const GLfloat vy1 = src.y1 ();
1734
344
    const GLfloat vy2 = src.y2 ();
1735
345
1736
346
    const GLTexture::Filter texFilter =
1737
347
	(filter == GL_LINEAR) ? GLTexture::Good :
1738
348
				GLTexture::Fast;
1739
349
1740
350
    GLfloat vertexData[] = {
1741
351
	vx1, vy1, 0.0f,
1742
352
	vx1, vy2, 0.0f,
1743
353
	vx2, vy1, 0.0f,
1744
354
1745
355
	vx1, vy2, 0.0f,
1746
356
	vx2, vy2, 0.0f,
1747
357
	vx2, vy1, 0.0f,
1748
358
    };
1749
359
1750
360
    GLfloat textureData[] = {
1751
361
	tx1, ty1,
1752
362
	tx1, ty2,
1753
363
	tx2, ty1,
1754
364
	tx1, ty2,
1755
365
	tx2, ty2,
1756
366
	tx2, ty1,
1757
367
    };
1758
368
1759
369
    vertexBuffer->begin (GL_TRIANGLES);
1760
370
    vertexBuffer->addVertices (6, vertexData);
1761
371
    vertexBuffer->addTexCoords (0, 6, textureData);
1762
372
1763
373
    if (vertexBuffer->end ())
1764
374
    {
1765
375
	texture->enable (texFilter);
1766
376
	sTransform.toScreenSpace (&screen->fullscreenOutput (), -DEFAULT_Z_CAMERA);
1767
377
	vertexBuffer->render (sTransform);
1768
378
	texture->disable ();
1769
379
    }
1770
380
1771
381
    return true;
1772
382
}
1773
383
1774
384
void initDirectDraw (cgli::DirectDrawStrategies::Ptr        &directDraw,
1775
385
		     const compiz::opengl::RectangularDraw  &blitFramebuffer,
1776
386
		     const compiz::opengl::RectangularDraw  &rectangularTextureDraw,
1777
387
		     const cgli::BindReadBufferFunc         &func,
1778
388
		     compiz::opengl::BindableFramebuffer    *bindable)
1779
389
{
1780
390
    cglfb::RectangularDraw blitFramebufferBound (
1781
391
	boost::bind (
1782
392
	    cgli::rectangleDrawFromReadBuffer,
1783
393
	    _1, _2, _3, _4,
1784
394
	    bindable,
1785
395
	    func,
1786
396
	    blitFramebuffer));
1787
397
1788
398
    /* Tries each of these from back to front */
1789
399
    cglfb::RectangularDrawList strategies;
1790
400
1791
401
    strategies.push_back (rectangularTextureDraw);
1792
402
    strategies.push_back (blitFramebufferBound);
1793
403
    directDraw.reset (new cgli::DirectDrawStrategies (strategies));
1794
404
}
1795
405
}
1796
406
1797
407
namespace compiz
1798
408
{
1799
409
namespace opengl
1800
410
{
1801
411
DirectDrawObject *
1802
412
createBlittableFramebufferObjectWithFallback (const CompSize &sz,
1803
413
					      GLScreen       *gScreen)
1804
414
{
1805
415
    boost::shared_ptr <cgli::DirectDrawStrategies> directDraw;
1806
416
    boost::shared_ptr <cgli::FramebufferObject> fbo (boost::make_shared <cgli::FramebufferObject> ());
1807
417
    cglfb::RectangularDraw rectangularTextureDraw (boost::bind (defaultRectangularFramebufferDraw,
1808
418
								GLVertexBuffer::streamingBuffer (),
1809
419
								fbo.get (),
1810
420
								_1, _2, _3, _4));
1811
421
    initDirectDraw (directDraw,
1812
422
		    gScreen->blitFramebufferFunc (),
1813
423
		    rectangularTextureDraw,
1814
424
		    boost::bind (&GLScreen::bindFramebufferForReading, gScreen, _1),
1815
425
		    fbo.get ());
1816
426
    DirectDrawObject *dd (new cgli::DirectDrawObject (directDraw, fbo, fbo));
1817
427
    dd->allocate (*screen, NULL, GL_BGRA);
1818
428
    return dd;
1819
429
}
1820
430
}
1821
431
}
1822
432
1823
302
#ifndef USE_GLES
433
#ifndef USE_GLES
1824
303
434
1825
304
namespace compiz
435
namespace compiz
1826
@@ -591,6 +722,7 @@
1827
591
    if (GL::textureFromPixmap)
722
    if (GL::textureFromPixmap)
1828
592
	registerBindPixmap (EglTexture::bindPixmapToTexture);
723
	registerBindPixmap (EglTexture::bindPixmapToTexture);
1829
593
724
1830
725
    priv->blitFramebuffer = boost::bind (compiz::opengl::blitFramebufferEGL, _1, _2, _3, _4);
1831
594
    priv->incorrectRefreshRate = false;
726
    priv->incorrectRefreshRate = false;
1832
595
727
1833
596
    #else
728
    #else
1834
@@ -779,6 +911,10 @@
1835
779
	    GL::fboSupported = true;
911
	    GL::fboSupported = true;
1836
780
    }
912
    }
1837
781
913
1838
914
    if (GL::fboSupported &&
1839
915
        strstr (glExtensions, "GL_EXT_framebuffer_blit"))
1840
916
	GL::blitFramebuffer = (GL::GLBlitFramebufferProc) getProcAddress ("glBlitFramebufferEXT");
1841
917
1842
782
    GL::fboStencilSupported = GL::fboSupported &&
918
    GL::fboStencilSupported = GL::fboSupported &&
1843
783
        strstr (glExtensions, "GL_EXT_packed_depth_stencil");
919
        strstr (glExtensions, "GL_EXT_packed_depth_stencil");
1844
784
920
1845
@@ -895,13 +1031,13 @@
1846
895
1031
1847
896
    if (GL::textureFromPixmap)
1032
    if (GL::textureFromPixmap)
1848
897
	registerBindPixmap (TfpTexture::bindPixmapToTexture);
1033
	registerBindPixmap (TfpTexture::bindPixmapToTexture);
1849
1034
1850
1035
    priv->blitFramebuffer = boost::bind (compiz::opengl::blitFramebufferGLX, _1, _2, _3, _4);
1851
898
#endif
1036
#endif
1852
899
1037
1853
900
    if (GL::fboSupported)
1038
    if (GL::fboSupported)
1858
901
    {
1039
	priv->scratchFbo.reset (compiz::opengl::createBlittableFramebufferObjectWithFallback (*screen,
1859
902
	priv->scratchFbo = new GLFramebufferObject;
1040
											      this));
1856
903
	priv->scratchFbo->allocate (*screen, NULL, GL_BGRA);
1857
904
    }
1860
905
1041
1861
906
    GLVertexBuffer::streamingBuffer ()->setAutoProgram (priv->autoProgram);
1042
    GLVertexBuffer::streamingBuffer ()->setAutoProgram (priv->autoProgram);
1862
907
1043
1863
@@ -1209,9 +1345,6 @@
1864
1209
	glXDestroyContext (screen->dpy (), priv->ctx);
1345
	glXDestroyContext (screen->dpy (), priv->ctx);
1865
1210
    #endif
1346
    #endif
1866
1211
1347
1867
1212
    if (priv->scratchFbo)
1868
1213
	delete priv->scratchFbo;
1869
1214
1870
1215
    delete priv;
1348
    delete priv;
1871
1216
}
1349
}
1872
1217
1350
1873
@@ -1234,6 +1367,7 @@
1874
1234
    doubleBuffer (screen->dpy (), *screen, surface),
1367
    doubleBuffer (screen->dpy (), *screen, surface),
1875
1235
    #endif
1368
    #endif
1876
1236
    scratchFbo (NULL),
1369
    scratchFbo (NULL),
1877
1370
    blitFramebuffer (),
1878
1237
    outputRegion (),
1371
    outputRegion (),
1879
1238
    refreshSubBuffer (false),
1372
    refreshSubBuffer (false),
1880
1239
    lastMask (0),
1373
    lastMask (0),
1881
@@ -1246,6 +1380,10 @@
1882
1246
    autoProgram (new GLScreenAutoProgram(gs)),
1380
    autoProgram (new GLScreenAutoProgram(gs)),
1883
1247
    rootPixmapCopy (None),
1381
    rootPixmapCopy (None),
1884
1248
    rootPixmapSize (),
1382
    rootPixmapSize (),
1885
1383
    drawFramebufferBinding (GL::DRAW_FRAMEBUFFER,
1886
1384
			    &backbuffer),
1887
1385
    readFramebufferBinding (GL::READ_FRAMEBUFFER,
1888
1386
			    &backbuffer),
1889
1249
    glVendor (NULL),
1387
    glVendor (NULL),
1890
1250
    glRenderer (NULL),
1388
    glRenderer (NULL),
1891
1251
    glVersion (NULL),
1389
    glVersion (NULL),
1892
@@ -1441,11 +1579,19 @@
1893
1441
void
1579
void
1894
1442
PrivateGLScreen::outputChangeNotify ()
1580
PrivateGLScreen::outputChangeNotify ()
1895
1443
{
1581
{
1896
1582
    compiz::opengl::BindableFramebuffer *previousReadBuffer =
1897
1583
	    readFramebufferBinding.bind (&backbuffer);
1898
1584
    compiz::opengl::BindableFramebuffer *previousDrawBuffer =
1899
1585
	    drawFramebufferBinding.bind (&backbuffer);
1900
1586
1901
1444
    screen->outputChangeNotify ();
1587
    screen->outputChangeNotify ();
1902
1445
1588
1904
1446
    if (scratchFbo)
1589
    if (scratchFbo.get ())
1905
1447
	scratchFbo->allocate (*screen, NULL, GL_BGRA);
1590
	scratchFbo->allocate (*screen, NULL, GL_BGRA);
1906
1448
    updateView ();
1591
    updateView ();
1907
1592
1908
1593
    readFramebufferBinding.bind (previousReadBuffer);
1909
1594
    drawFramebufferBinding.bind (previousDrawBuffer);
1910
1449
}
1595
}
1911
1450
1596
1912
1451
#ifndef USE_GLES
1597
#ifndef USE_GLES
1913
@@ -1670,9 +1816,9 @@
1914
1670
    WRAPABLE_DEF (projectionMatrix)
1816
    WRAPABLE_DEF (projectionMatrix)
1915
1671
1817
1916
1672
void
1818
void
1920
1673
GLScreenInterface::glPaintCompositedOutput (const CompRegion    &region,
1819
GLScreenInterface::glPaintCompositedOutput (const CompRegion				&region,
1921
1674
					    GLFramebufferObject *fbo,
1820
					    compiz::opengl::DirectDrawObject *fbo,
1922
1675
					    unsigned int         mask)
1821
					    unsigned int				mask)
1923
1676
    WRAPABLE_DEF (glPaintCompositedOutput, region, fbo, mask)
1822
    WRAPABLE_DEF (glPaintCompositedOutput, region, fbo, mask)
1924
1677
1823
1925
1678
void
1824
void
1926
@@ -1899,6 +2045,30 @@
1927
1899
2045
1928
1900
}
2046
}
1929
1901
2047
1930
2048
bool
1931
2049
cglfb::blitFramebufferGLX (const CompRect &src,
1932
2050
			   const CompRect &dst,
1933
2051
			   GLbitfield     mask,
1934
2052
			   GLenum         filter)
1935
2053
{
1936
2054
    /* Must have GL_EXT_blit_framebuffer */
1937
2055
    if (!GL::blitFramebuffer)
1938
2056
	return false;
1939
2057
1940
2058
    /* Be sure to invert y-coords too */
1941
2059
    (*GL::blitFramebuffer) (src.x1 (), // sx0
1942
2060
			    screen->height () - src.y2 (), // sy0
1943
2061
			    src.x2 (), // sx1
1944
2062
			    screen->height () - src.y1 (), // sy1
1945
2063
			    dst.x1 (), // dx0
1946
2064
			    screen->height () - dst.y2 (), // dy0
1947
2065
			    dst.x2 (), // dx1,
1948
2066
			    screen->height () - dst.y1 (), // dy1
1949
2067
			    GL_COLOR_BUFFER_BIT,
1950
2068
			    GL_LINEAR);
1951
2069
    return true;
1952
2070
}
1953
2071
1954
1902
#else
2072
#else
1955
1903
2073
1956
1904
EGLDoubleBuffer::EGLDoubleBuffer (Display          *d,
2074
EGLDoubleBuffer::EGLDoubleBuffer (Display          *d,
1957
@@ -1957,6 +2127,16 @@
1958
1957
{
2127
{
1959
1958
}
2128
}
1960
1959
2129
1961
2130
bool
1962
2131
cglfb::blitFramebufferEGL (const CompRect &src,
1963
2132
			   const CompRect &dst,
1964
2133
			   GLbitfield     mask,
1965
2134
			   GLenum         filter)
1966
2135
{
1967
2136
    /* Not supported on OpenGL|ES2 */
1968
2137
    return false;
1969
2138
}
1970
2139
1971
1960
#endif
2140
#endif
1972
1961
2141
1973
1962
void
2142
void
1974
@@ -1977,17 +2157,11 @@
1975
1977
    glDepthMask (GL_FALSE);
2157
    glDepthMask (GL_FALSE);
1976
1978
    glStencilMask (0);
2158
    glStencilMask (0);
1977
1979
2159
1980
1980
    GLFramebufferObject *oldFbo = NULL;
2160
    compiz::opengl::BindableFramebuffer *oldFbo = NULL;
1979
1981
    bool useFbo = false;
1981
1982
2161
1982
1983
    /* Clear the color buffer where appropriate */
2162
    /* Clear the color buffer where appropriate */
1990
1984
    if (GL::fboEnabled && scratchFbo)
2163
    if (GL::fboEnabled && scratchFbo.get ())
1991
1985
    {
2164
	oldFbo = drawFramebufferBinding.bind (scratchFbo.get ());
1985
1986
	oldFbo = scratchFbo->bind ();
1986
1987
	useFbo = scratchFbo->checkStatus () && scratchFbo->tex ();
1987
1988
	if (!useFbo)
1988
1989
	    GLFramebufferObject::rebind (oldFbo);
1989
1990
    }
1992
1991
2165
1993
1992
#ifdef UNSAFE_ARM_SGX_FIXME
2166
#ifdef UNSAFE_ARM_SGX_FIXME
1994
1993
    refreshSubBuffer = ((lastMask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK) &&
2167
    refreshSubBuffer = ((lastMask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK) &&
1995
@@ -2080,13 +2254,10 @@
1996
2080
2254
1997
2081
    glViewport (0, 0, screen->width (), screen->height ());
2255
    glViewport (0, 0, screen->width (), screen->height ());
1998
2082
2256
2000
2083
    if (useFbo)
2257
    if (oldFbo)
2001
2084
    {
2258
    {
2007
2085
	GLFramebufferObject::rebind (oldFbo);
2259
	drawFramebufferBinding.bind (oldFbo);
2008
2086
2260
	gScreen->glPaintCompositedOutput (screen->region (), scratchFbo.get (), mask);
2004
2087
	// FIXME: does not work if screen dimensions exceed max texture size
2005
2088
	//        We should try to use glBlitFramebuffer instead.
2006
2089
	gScreen->glPaintCompositedOutput (screen->region (), scratchFbo, mask);
2009
2090
    }
2261
    }
2010
2091
2262
2011
2092
    if (cScreen->outputWindowChanged ())
2263
    if (cScreen->outputWindowChanged ())
2012
@@ -2101,13 +2272,13 @@
2013
2101
    }
2272
    }
2014
2102
2273
2015
2103
    bool alwaysSwap = optionGetAlwaysSwapBuffers ();
2274
    bool alwaysSwap = optionGetAlwaysSwapBuffers ();
2017
2104
    bool fullscreen = useFbo ||
2275
    bool fullscreen = oldFbo ||
2018
2105
                      alwaysSwap ||
2276
                      alwaysSwap ||
2019
2106
                      ((mask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK) &&
2277
                      ((mask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK) &&
2020
2107
                       commonFrontbuffer);
2278
                       commonFrontbuffer);
2021
2108
2279
2022
2109
    doubleBuffer.set (DoubleBuffer::VSYNC, optionGetSyncToVblank ());
2280
    doubleBuffer.set (DoubleBuffer::VSYNC, optionGetSyncToVblank ());
2024
2110
    doubleBuffer.set (DoubleBuffer::HAVE_PERSISTENT_BACK_BUFFER, useFbo);
2281
    doubleBuffer.set (DoubleBuffer::HAVE_PERSISTENT_BACK_BUFFER, oldFbo ? true : false);
2025
2111
    doubleBuffer.set (DoubleBuffer::NEED_PERSISTENT_BACK_BUFFER, alwaysSwap);
2282
    doubleBuffer.set (DoubleBuffer::NEED_PERSISTENT_BACK_BUFFER, alwaysSwap);
2026
2112
    doubleBuffer.render (tmpRegion, fullscreen);
2283
    doubleBuffer.render (tmpRegion, fullscreen);
2027
2113
2284
2028
@@ -2195,10 +2366,34 @@
2029
2195
    }
2366
    }
2030
2196
}
2367
}
2031
2197
2368
2033
2198
GLFramebufferObject *
2369
compiz::opengl::FramebufferObject *
2034
2199
GLScreen::fbo ()
2370
GLScreen::fbo ()
2035
2200
{
2371
{
2037
2201
    return priv->scratchFbo;
2372
    return priv->scratchFbo.get ();
2038
2373
}
2039
2374
2040
2375
compiz::opengl::BindableFramebuffer *
2041
2376
GLScreen::backbuffer ()
2042
2377
{
2043
2378
    return &priv->backbuffer;
2044
2379
}
2045
2380
2046
2381
compiz::opengl::BindableFramebuffer *
2047
2382
GLScreen::bindFramebufferForDrawing (compiz::opengl::BindableFramebuffer *next)
2048
2383
{
2049
2384
    return priv->drawFramebufferBinding.bind (next);
2050
2385
}
2051
2386
2052
2387
compiz::opengl::BindableFramebuffer *
2053
2388
GLScreen::bindFramebufferForReading (compiz::opengl::BindableFramebuffer *next)
2054
2389
{
2055
2390
    return priv->readFramebufferBinding.bind (next);
2056
2391
}
2057
2392
2058
2393
const cglfb::BlitFramebufferFunc &
2059
2394
GLScreen::blitFramebufferFunc ()
2060
2395
{
2061
2396
    return priv->blitFramebuffer;
2062
2202
}
2397
}
2063
2203
2398
2064
2204
GLTexture *
2399
GLTexture *
2065
@@ -2240,3 +2435,19 @@
2066
2240
    priv->rasterPos.setY (0);
2435
    priv->rasterPos.setY (0);
2067
2241
}
2436
}
2068
2242
2437
2069
2438
GLuint
2070
2439
BindableBackbuffer::getResourceId () const
2071
2440
{
2072
2441
    return 0;
2073
2442
}
2074
2443
2075
2444
bool
2076
2445
BindableBackbuffer::setBindStatus (GLenum)
2077
2446
{
2078
2447
    return true;
2079
2448
}
2080
2449
2081
2450
void
2082
2451
BindableBackbuffer::updateAllocation (GLenum)
2083
2452
{
2084
2453
}
2085
2243
2454
2086
=== modified file 'plugins/water/src/water.cpp'
2087
--- plugins/water/src/water.cpp	2013-01-28 19:45:04 +0000
2088
+++ plugins/water/src/water.cpp	2013-02-13 11:45:25 +0000
2089
@@ -62,7 +62,11 @@
2090
62
    if (!useFbo)
62
    if (!useFbo)
2091
63
	return false;
63
	return false;
2092
64
64
2094
65
    oldFbo = waterFbo[fIndex]->bind ();
65
    oldFbo = gScreen->bindFramebufferForDrawing (waterFbo[fIndex]);
2095
66
2096
67
    if (!oldFbo)
2097
68
	return false;
2098
69
2099
66
    glGetIntegerv(GL_VIEWPORT,  &oldViewport[0]);
70
    glGetIntegerv(GL_VIEWPORT,  &oldViewport[0]);
2100
67
    glViewport (0, 0, texWidth, texHeight);
71
    glViewport (0, 0, texWidth, texHeight);
2101
68
72
2102
@@ -72,7 +76,7 @@
2103
72
void
76
void
2104
73
WaterScreen::fboEpilogue ()
77
WaterScreen::fboEpilogue ()
2105
74
{
78
{
2107
75
    GLFramebufferObject::rebind (oldFbo);
79
    gScreen->bindFramebufferForDrawing (oldFbo);
2108
76
    glViewport (oldViewport[0], oldViewport[1], oldViewport[2], oldViewport[3]);
80
    glViewport (oldViewport[0], oldViewport[1], oldViewport[2], oldViewport[3]);
2109
77
}
81
}
2110
78
82
2111
@@ -305,28 +309,32 @@
2112
305
	    waterFbo[i]->allocate (size, (char *) t0,
309
	    waterFbo[i]->allocate (size, (char *) t0,
2113
306
				   GL_BGRA, GL_UNSIGNED_BYTE);
310
				   GL_BGRA, GL_UNSIGNED_BYTE);
2114
307
	    // check if FBOs are working. If not, fallback to software textures
311
	    // check if FBOs are working. If not, fallback to software textures
2118
308
	    oldFbo = waterFbo[i]->bind ();
312
	    oldFbo = gScreen->bindFramebufferForDrawing (waterFbo[i]);
2119
309
	    waterFbo[i]->rebind (oldFbo);
313
	    if (!oldFbo)
2117
310
	    if (!waterFbo[i]->checkStatus ())
2120
311
	    {
314
	    {
2121
312
		useFbo = false;
315
		useFbo = false;
2122
313
		delete waterFbo[i];
316
		delete waterFbo[i];
2123
314
		break;
317
		break;
2124
315
	    }
318
	    }
2125
319
	    gScreen->bindFramebufferForDrawing (oldFbo);
2126
316
	}
320
	}
2127
317
    }
321
    }
2128
318
}
322
}
2129
319
323
2130
320
void
324
void
2134
321
WaterScreen::glPaintCompositedOutput (const CompRegion    &region,
325
WaterScreen::glPaintCompositedOutput (const CompRegion				  &region,
2135
322
                                      GLFramebufferObject *fbo,
326
				      compiz::opengl::DirectDrawObject *fbo,
2136
323
                                      unsigned int         mask)
327
				      unsigned int				  mask)
2137
324
{
328
{
2138
325
    if (count)
329
    if (count)
2139
326
    {
330
    {
2140
327
	if (GL::vboEnabled && GL::shaders)
331
	if (GL::vboEnabled && GL::shaders)
2141
328
	{
332
	{
2143
329
	    GLFramebufferObject::rebind (oldFbo);
333
	    /* This seems redundant to me */
2144
334
	    gScreen->bindFramebufferForDrawing (oldFbo);
2145
335
2146
336
	    oldFbo = NULL;
2147
337
2148
330
	    glViewport (oldViewport[0], oldViewport[1],
338
	    glViewport (oldViewport[0], oldViewport[1],
2149
331
			oldViewport[2], oldViewport[3]);
339
			oldViewport[2], oldViewport[3]);
2150
332
340
2151
333
341
2152
=== modified file 'plugins/water/src/water.h'
2153
--- plugins/water/src/water.h	2012-09-07 23:56:21 +0000
2154
+++ plugins/water/src/water.h	2013-02-13 11:45:25 +0000
2155
@@ -64,9 +64,9 @@
2156
64
64
2157
65
	void handleEvent (XEvent *);
65
	void handleEvent (XEvent *);
2158
66
66
2162
67
	void glPaintCompositedOutput (const CompRegion    &region,
67
	void glPaintCompositedOutput (const CompRegion				  &region,
2163
68
				      GLFramebufferObject *fbo,
68
				      compiz::opengl::DirectDrawObject *fbo,
2164
69
				      unsigned int         mask);
69
				      unsigned int				  mask);
2165
70
	void preparePaint (int);
70
	void preparePaint (int);
2166
71
	void donePaint ();
71
	void donePaint ();
2167
72
72
2168
@@ -100,7 +100,7 @@
2169
100
100
2170
101
	GLFramebufferObject *waterFbo[TEXTURE_NUM];
101
	GLFramebufferObject *waterFbo[TEXTURE_NUM];
2171
102
102
2173
103
	GLFramebufferObject *oldFbo;
103
	compiz::opengl::BindableFramebuffer *oldFbo;
2174
104
	GLint oldViewport[4];
104
	GLint oldViewport[4];
2175
105
	int    fboIndex;
105
	int    fboIndex;
2176
106
	bool   useFbo;
106
	bool   useFbo;
2177
107
107
2178
=== modified file 'src/event.cpp'
2179
--- src/event.cpp	2013-01-03 16:06:41 +0000
2180
+++ src/event.cpp	2013-02-13 11:45:25 +0000
2181
@@ -1288,17 +1288,6 @@
2182
1288
	if (!XGetWindowAttributes (privateScreen.dpy, event->xcreatewindow.window, &wa))
1288
	if (!XGetWindowAttributes (privateScreen.dpy, event->xcreatewindow.window, &wa))
2183
1289
	    privateScreen.setDefaultWindowAttributes (&wa);
1289
	    privateScreen.setDefaultWindowAttributes (&wa);
2184
1290
1290
2185
1291
	/* That being said, we should store as much information as possible
2186
1292
	 * about it. There may be requests relative to this window that could
2187
1293
	 * use the data in the XCreateWindowEvent structure, especially the
2188
1294
	 * override redirect state */
2189
1295
	wa.x = event->xcreatewindow.x;
2190
1296
	wa.y = event->xcreatewindow.y;
2191
1297
	wa.width = event->xcreatewindow.width;
2192
1298
	wa.height = event->xcreatewindow.height;
2193
1299
	wa.border_width = event->xcreatewindow.border_width;
2194
1300
	wa.override_redirect = event->xcreatewindow.override_redirect;
2195
1301
2196
1302
	foreach (CompWindow *w, screen->windows ())
1291
	foreach (CompWindow *w, screen->windows ())
2197
1303
	{
1292
	{
2198
1304
	    if (w->priv->serverFrame == event->xcreatewindow.window)
1293
	    if (w->priv->serverFrame == event->xcreatewindow.window)
2199
@@ -1478,15 +1467,7 @@
2200
1478
		if (!XGetWindowAttributes (privateScreen.dpy, event->xcreatewindow.window, &wa))
1467
		if (!XGetWindowAttributes (privateScreen.dpy, event->xcreatewindow.window, &wa))
2201
1479
		    privateScreen.setDefaultWindowAttributes (&wa);
1468
		    privateScreen.setDefaultWindowAttributes (&wa);
2202
1480
1469
2212
1481
		/* That being said, we should store as much information as possible
1470
		PrivateWindow::createCompWindow (getTopWindow ()->id (), getTopServerWindow ()->id (), wa, event->xcreatewindow.window);
2204
1482
		 * about it. There may be requests relative to this window that could
2205
1483
		 * use the data in the XCreateWindowEvent structure, especially the
2206
1484
		 * override redirect state */
2207
1485
		wa.x = event->xreparent.x;
2208
1486
		wa.y = event->xreparent.y;
2209
1487
		wa.override_redirect = event->xreparent.override_redirect;
2210
1488
2211
1489
		PrivateWindow::createCompWindow (getTopWindow ()->id (), getTopServerWindow ()->id (), wa, event->xreparent.window);
2213
1490
		break;
1471
		break;
2214
1491
	    }
1472
	    }
2215
1492
	    else
1473
	    else
2216
@@ -2118,10 +2099,7 @@
2217
2118
					ServerLock lock (screen->serverGrabInterface ());
2099
					ServerLock lock (screen->serverGrabInterface ());
2218
2119
2100
2219
2120
					/* This will be the window that we must lower relative to */
2101
					/* This will be the window that we must lower relative to */
2224
2121
					CompWindow *sibling =
2102
					CompWindow *sibling = PrivateWindow::findValidStackSiblingBelow (active, fsw, lock);
2221
2122
						PrivateWindow::findValidStackSiblingBelow (active,
2222
2123
											   fsw,
2223
2124
											   lock);
2225
2125
2103
2226
2126
					if (sibling)
2104
					if (sibling)
2227
2127
					{
2105
					{
2228
@@ -2199,11 +2177,7 @@
2229
2199
		if (w)
2177
		if (w)
2230
2200
		{
2178
		{
2231
2201
		    ServerLock lock (screen->serverGrabInterface ());
2179
		    ServerLock lock (screen->serverGrabInterface ());
2237
2202
		    if (PrivateWindow::stackDocks (w,
2180
		    if (PrivateWindow::stackDocks (w, dockWindows, &xwc, &mask, lock))
2233
2203
						   dockWindows,
2234
2204
						   &xwc,
2235
2205
						   &mask,
2236
2206
						   lock))
2238
2207
		    {
2181
		    {
2239
2208
			Window sibling = xwc.sibling;
2182
			Window sibling = xwc.sibling;
2240
2209
			xwc.stack_mode = Above;
2183
			xwc.stack_mode = Above;
2241
2210
2184
2242
=== modified file 'src/option/tests/CMakeLists.txt'
2243
--- src/option/tests/CMakeLists.txt	2012-12-10 13:01:00 +0000
2244
+++ src/option/tests/CMakeLists.txt	2013-02-13 11:45:25 +0000
2245
@@ -10,7 +10,6 @@
2246
10
  ${compiz_SOURCE_DIR}/src/point/include
10
  ${compiz_SOURCE_DIR}/src/point/include
2247
11
  ${compiz_SOURCE_DIR}/src/window/geometry/include
11
  ${compiz_SOURCE_DIR}/src/window/geometry/include
2248
12
  ${compiz_SOURCE_DIR}/src/window/extents/include
12
  ${compiz_SOURCE_DIR}/src/window/extents/include
2249
13
  ${compiz_SOURCE_DIR}/src/servergrab/include
2250
14
  ${COMPIZ_INCLUDE_DIRS}
13
  ${COMPIZ_INCLUDE_DIRS}
2251
15
)
14
)
2252
16
15
2253
17
16
2254
=== modified file 'src/option/tests/option.cpp'
2255
--- src/option/tests/option.cpp	2012-12-10 13:01:00 +0000
2256
+++ src/option/tests/option.cpp	2013-02-13 11:45:25 +0000
2257
@@ -1,9 +1,5 @@
2258
1
#include <gtest/gtest.h>
1
#include <gtest/gtest.h>
2259
2
2
2260
3
/* XXX: including core.h means that we pull in
2261
4
 * both window.h and screen.h which are cascading
2262
5
 * includes. We should eliminate this dependency
2263
6
 */
2264
7
#include "core/core.h"
3
#include "core/core.h"
2265
8
#include "core/action.h"
4
#include "core/action.h"
2266
9
#include "core/match.h"
5
#include "core/match.h"
2267
10
6
2268
=== modified file 'src/outputdevices.h'
2269
--- src/outputdevices.h	2012-12-10 13:01:00 +0000
2270
+++ src/outputdevices.h	2013-02-13 11:45:25 +0000
2271
@@ -25,11 +25,6 @@
2272
25
#include <core/output.h>
25
#include <core/output.h>
2273
26
#include <core/rect.h>
26
#include <core/rect.h>
2274
27
#include <core/region.h>
27
#include <core/region.h>
2275
28
2276
29
/* XXX: Including screen.h includes window.h and other unnecessary
2277
30
 * headers which cause cascading header dependencies. We should seek to
2278
31
 * eliminate this dependency
2279
32
 */
2280
33
#include <core/screen.h>
28
#include <core/screen.h>
2281
34
29
2282
35
namespace compiz
30
namespace compiz
2283
36
31
2284
=== modified file 'src/privatewindow.h'
2285
--- src/privatewindow.h	2013-01-03 16:06:41 +0000
2286
+++ src/privatewindow.h	2013-02-13 11:45:25 +0000
2287
@@ -33,6 +33,8 @@
2288
33
#include <core/point.h>
33
#include <core/point.h>
2289
34
#include <core/timer.h>
34
#include <core/timer.h>
2290
35
35
2291
36
class ServerLock;
2292
37
2293
36
#include <boost/shared_ptr.hpp>
38
#include <boost/shared_ptr.hpp>
2294
37
39
2295
38
#define XWINDOWCHANGES_INIT {0, 0, 0, 0, 0, None, 0}
40
#define XWINDOWCHANGES_INIT {0, 0, 0, 0, 0, None, 0}
2296
@@ -127,22 +129,23 @@
2297
127
129
2298
128
	bool isInvisible() const;
130
	bool isInvisible() const;
2299
129
131
2303
130
	static bool stackLayerCheck (CompWindow       *w,
132
	static bool stackLayerCheck (CompWindow *w,
2304
131
				     Window           clientLeader,
133
				     Window     clientLeader,
2305
132
				     CompWindow       *below,
134
				     CompWindow *below,
2306
133
				     const ServerLock &lock);
135
				     const ServerLock &lock);
2307
134
136
2309
135
	static bool avoidStackingRelativeTo (CompWindow *w, const ServerLock &lock);
137
	static bool avoidStackingRelativeTo (CompWindow *w,
2310
138
					     const ServerLock &lock);
2311
136
139
2314
137
	static CompWindow * findSiblingBelow (CompWindow       *w,
140
	static CompWindow * findSiblingBelow (CompWindow *w,
2315
138
					      bool             aboveFs,
141
					      bool       aboveFs,
2316
139
					      const ServerLock &lock);
142
					      const ServerLock &lock);
2317
140
143
2319
141
	static CompWindow * findLowestSiblingBelow (CompWindow       *w,
144
	static CompWindow * findLowestSiblingBelow (CompWindow *w,
2320
142
						    const ServerLock &lock);
145
						    const ServerLock &lock);
2321
143
146
2324
144
	static bool validSiblingBelow (CompWindow       *w,
147
	static bool validSiblingBelow (CompWindow *w,
2325
145
				       CompWindow       *sibling,
148
				       CompWindow *sibling,
2326
146
				       const ServerLock &lock);
149
				       const ServerLock &lock);
2327
147
150
2328
148
	void saveGeometry (int mask);
151
	void saveGeometry (int mask);
2329
@@ -152,21 +155,21 @@
2330
152
	void reconfigureXWindow (unsigned int   valueMask,
155
	void reconfigureXWindow (unsigned int   valueMask,
2331
153
				 XWindowChanges *xwc);
156
				 XWindowChanges *xwc);
2332
154
157
2337
155
	static bool stackDocks (CompWindow       *w,
158
	static bool stackDocks (CompWindow     *w,
2338
156
				CompWindowList   &updateList,
159
				CompWindowList &updateList,
2339
157
				XWindowChanges   *xwc,
160
				XWindowChanges *xwc,
2340
158
				unsigned int     *mask,
161
				unsigned int   *mask,
2341
159
				const ServerLock &lock);
162
				const ServerLock &lock);
2342
160
163
2347
161
	static bool stackTransients (CompWindow       *w,
164
	static bool stackTransients (CompWindow     *w,
2348
162
				     CompWindow       *avoid,
165
				     CompWindow     *avoid,
2349
163
				     XWindowChanges   *xwc,
166
				     XWindowChanges *xwc,
2350
164
				     CompWindowList   &updateList,
167
				     CompWindowList &updateList,
2351
165
				     const ServerLock &lock);
168
				     const ServerLock &lock);
2352
166
169
2356
167
	static void stackAncestors (CompWindow       *w,
170
	static void stackAncestors (CompWindow *w,
2357
168
				    XWindowChanges   *xwc,
171
				    XWindowChanges *xwc,
2358
169
				    CompWindowList   &updateList,
172
				    CompWindowList &updateList,
2359
170
				    const ServerLock &lock);
173
				    const ServerLock &lock);
2360
171
174
2361
172
	static bool isAncestorTo (CompWindow *transient,
175
	static bool isAncestorTo (CompWindow *transient,
2362
@@ -179,8 +182,8 @@
2363
179
	int addWindowSizeChanges (XWindowChanges *xwc,
182
	int addWindowSizeChanges (XWindowChanges *xwc,
2364
180
				  CompWindow::Geometry old);
183
				  CompWindow::Geometry old);
2365
181
184
2368
182
	int addWindowStackChanges (XWindowChanges   *xwc,
185
	int addWindowStackChanges (XWindowChanges *xwc,
2369
183
				   CompWindow       *sibling,
186
				   CompWindow     *sibling,
2370
184
				   const ServerLock &lock);
187
				   const ServerLock &lock);
2371
185
188
2372
186
	static CompWindow * findValidStackSiblingBelow (CompWindow *w,
189
	static CompWindow * findValidStackSiblingBelow (CompWindow *w,
2373
187
190
2374
=== modified file 'src/tests/CMakeLists.txt'
2375
--- src/tests/CMakeLists.txt	2013-01-03 16:06:41 +0000
2376
+++ src/tests/CMakeLists.txt	2013-02-13 11:45:25 +0000
2377
@@ -10,7 +10,6 @@
2378
10
    ${COMPIZ_MAIN_SOURCE_DIR}/pluginclasshandler/include
10
    ${COMPIZ_MAIN_SOURCE_DIR}/pluginclasshandler/include
2379
11
    ${COMPIZ_MAIN_SOURCE_DIR}/window/geometry/include
11
    ${COMPIZ_MAIN_SOURCE_DIR}/window/geometry/include
2380
12
    ${COMPIZ_MAIN_SOURCE_DIR}/window/extents/include
12
    ${COMPIZ_MAIN_SOURCE_DIR}/window/extents/include
2381
13
    ${COMPIZ_MAIN_SOURCE_DIR}/servergrab/include
2382
14
    ${COMPIZ_INCLUDE_DIRS}
13
    ${COMPIZ_INCLUDE_DIRS}
2383
15
)
14
)
2384
16
15
2385
17
16
2386
=== modified file 'src/window.cpp'
2387
--- src/window.cpp	2013-02-12 22:02:10 +0000
2388
+++ src/window.cpp	2013-02-13 11:45:25 +0000
2389
@@ -41,6 +41,7 @@
2390
41
#include <core/icon.h>
41
#include <core/icon.h>
2391
42
#include <core/atoms.h>
42
#include <core/atoms.h>
2392
43
#include "core/windowconstrainment.h"
43
#include "core/windowconstrainment.h"
2393
44
#include <core/servergrab.h>
2394
44
#include "privatewindow.h"
45
#include "privatewindow.h"
2395
45
#include "privatescreen.h"
46
#include "privatescreen.h"
2396
46
#include "privatestackdebugger.h"
47
#include "privatestackdebugger.h"
2397
47
48
2398
=== modified file 'tests/system/xorg-gtest/tests/compiz_xorg_gtest_test_window_stacking.cpp'
2399
--- tests/system/xorg-gtest/tests/compiz_xorg_gtest_test_window_stacking.cpp	2012-12-10 12:38:48 +0000
2400
+++ tests/system/xorg-gtest/tests/compiz_xorg_gtest_test_window_stacking.cpp	2013-02-13 11:45:25 +0000
2401
@@ -293,83 +293,3 @@
2402
293
    EXPECT_EQ (*it++, w3);
293
    EXPECT_EQ (*it++, w3);
2403
294
    EXPECT_EQ (*it++, w2);
294
    EXPECT_EQ (*it++, w2);
2404
295
}
295
}
2405
296
2406
297
TEST_F (CompizXorgSystemStackingTest, TestCreateRelativeToDestroyedWindowFindsAnotherAppropriatePosition)
2407
298
{
2408
299
    ::Display *dpy = Display ();
2409
300
    ct::PropertyNotifyXEventMatcher matcher (dpy, "_NET_CLIENT_LIST_STACKING");
2410
301
2411
302
    Window dock = ct::CreateNormalWindow (dpy);
2412
303
2413
304
    /* Make it a dock */
2414
305
    MakeDock (dpy, dock);
2415
306
2416
307
    /* Immediately map the dock window and clear the event queue for it */
2417
308
    XMapRaised (dpy, dock);
2418
309
2419
310
    ASSERT_TRUE (Advance (dpy, ct::WaitForEventOfTypeOnWindow (dpy, dock, ReparentNotify, -1, -1)));
2420
311
    ASSERT_TRUE (Advance (dpy, ct::WaitForEventOfTypeOnWindow (dpy, dock, MapNotify, -1, -1)));
2421
312
2422
313
    /* Dock window needs to be in the client list */
2423
314
    ASSERT_TRUE (Advance (dpy, ct::WaitForEventOfTypeOnWindowMatching (dpy,
2424
315
								       DefaultRootWindow (dpy),
2425
316
								       PropertyNotify,
2426
317
								       -1,
2427
318
								       -1,
2428
319
								       matcher)));
2429
320
    std::list <Window> clientList = ct::NET_CLIENT_LIST_STACKING (dpy);
2430
321
    ASSERT_EQ (clientList.size (), 1);
2431
322
2432
323
    Window w1 = ct::CreateNormalWindow (dpy);
2433
324
    Window w2 = ct::CreateNormalWindow (dpy);
2434
325
2435
326
    XMapRaised (dpy, w1);
2436
327
2437
328
    /* All reparented and mapped */
2438
329
    ASSERT_TRUE (Advance (dpy, ct::WaitForEventOfTypeOnWindow (dpy,w1, ReparentNotify, -1, -1)));
2439
330
    ASSERT_TRUE (Advance (dpy, ct::WaitForEventOfTypeOnWindow (dpy, w1, MapNotify, -1, -1)));
2440
331
2441
332
    /* Grab the server so that we can guaruntee that all of these requests
2442
333
     * happen before compiz gets them */
2443
334
    XGrabServer (dpy);
2444
335
    XSync (dpy, false);
2445
336
2446
337
    /* Map the second window, so it ideally goes above w1. Compiz will
2447
338
     * receive the MapRequest for this first */
2448
339
    XMapRaised (dpy, w2);
2449
340
2450
341
    /* Create window that has w2 as its ideal above-candidate
2451
342
     * (compiz will receive the CreateNotify for this window
2452
343
     *  after the MapRequest but before the subsequent MapNotify) */
2453
344
    Window w3 = ct::CreateNormalWindow (dpy);
2454
345
2455
346
    XMapRaised (dpy, w3);
2456
347
2457
348
    /* Destroy w2 */
2458
349
    XDestroyWindow (dpy, w2);
2459
350
2460
351
    XUngrabServer (dpy);
2461
352
    XSync (dpy, false);
2462
353
2463
354
    /* Reparented and mapped */
2464
355
    ASSERT_TRUE (Advance (dpy, ct::WaitForEventOfTypeOnWindow (dpy, w3, ReparentNotify, -1, -1)));
2465
356
    ASSERT_TRUE (Advance (dpy, ct::WaitForEventOfTypeOnWindow (dpy, w3, MapNotify, -1, -1)));
2466
357
2467
358
    /* Update _NET_CLIENT_LIST_STACKING twice */
2468
359
    ASSERT_TRUE (Advance (dpy, ct::WaitForEventOfTypeOnWindowMatching (dpy,
2469
360
								       DefaultRootWindow (dpy),
2470
361
								       PropertyNotify,
2471
362
								       -1,
2472
363
								       -1,
2473
364
								       matcher)));
2474
365
2475
366
    /* Check the client list to see that dock > w3 > w1 */
2476
367
    clientList = ct::NET_CLIENT_LIST_STACKING (dpy);
2477
368
2478
369
    std::list <Window>::iterator it = clientList.begin ();
2479
370
2480
371
    EXPECT_EQ (3, clientList.size ());
2481
372
    EXPECT_EQ (w1, (*it++));
2482
373
    EXPECT_EQ (w3, (*it++));
2483
374
    EXPECT_EQ (dock, (*it++));
2484
375
}
Reviewer	Review Type	Date Requested	Status
PS Jenkins bot (community)	continuous-integration	2013-02-12	Needs Fixing on 2013-02-13
Sam Spilsbury			Pending
jenkins	continuous-integration	2013-02-12	Pending
Review via email: mp+147837@code.launchpad.net