1
=== modified file 'plugins/animation/src/animation.cpp'
2
--- plugins/animation/src/animation.cpp	2013-02-27 11:33:10 +0000
3
+++ plugins/animation/src/animation.cpp	2013-04-24 14:57:28 +0000
4
@@ -1617,7 +1617,7 @@
5
1617
    // Is this the first glPaint call this round
1617
    // Is this the first glPaint call this round
6
1618
    // without the mask PAINT_WINDOW_OCCLUSION_DETECTION_MASK?
1618
    // without the mask PAINT_WINDOW_OCCLUSION_DETECTION_MASK?
7
1619
    if (mPAScreen->mStartingNewPaintRound &&
1619
    if (mPAScreen->mStartingNewPaintRound &&
9
1620
	!(mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK))
1620
	!(mask & PAINT_WINDOW_NO_DRAW_MASKS))
10
1621
    {
1621
    {
11
1622
	mPAScreen->mStartingNewPaintRound = false;
1622
	mPAScreen->mStartingNewPaintRound = false;
12
1623
1623
13
1624
1624
14
=== modified file 'plugins/composite/CMakeLists.txt'
15
--- plugins/composite/CMakeLists.txt	2012-09-25 01:15:36 +0000
16
+++ plugins/composite/CMakeLists.txt	2013-04-24 14:57:28 +0000
17
@@ -2,9 +2,14 @@
18
2
2
19
3
include (CompizPlugin)
3
include (CompizPlugin)
20
4
4
21
5
include_directories (${CMAKE_CURRENT_SOURCE_DIR}/include)
22
5
include_directories (${CMAKE_CURRENT_SOURCE_DIR}/src/pixmapbinding/include)
6
include_directories (${CMAKE_CURRENT_SOURCE_DIR}/src/pixmapbinding/include)
23
7
include_directories (${CMAKE_CURRENT_SOURCE_DIR}/src/backbuffertracking/include)
24
8
25
6
link_directories (${CMAKE_CURRENT_BINARY_DIR}/src/pixmapbinding)
9
link_directories (${CMAKE_CURRENT_BINARY_DIR}/src/pixmapbinding)
26
10
link_directories (${CMAKE_CURRENT_BINARY_DIR}/src/backbuffertracking)
27
7
11
29
8
compiz_plugin (composite LIBRARIES compiz_composite_pixmapbinding)
12
compiz_plugin (composite LIBRARIES compiz_composite_pixmapbinding compiz_composite_backbuffertracking)
30
9
13
31
10
add_subdirectory (src/pixmapbinding)
14
add_subdirectory (src/pixmapbinding)
32
15
add_subdirectory (src/backbuffertracking)
33
11
16
34
=== added file 'plugins/composite/include/composite/agedamagequery.h'
35
--- plugins/composite/include/composite/agedamagequery.h	1970-01-01 00:00:00 +0000
36
+++ plugins/composite/include/composite/agedamagequery.h	2013-04-24 14:57:28 +0000
37
@@ -0,0 +1,53 @@
38
1
/*
39
2
 * Compiz, composite plugin, GLX_EXT_buffer_age logic
40
3
 *
41
4
 * Copyright (c) 2012 Sam Spilsbury
42
5
 * Authors: Sam Spilsbury <smspillaz@gmail.com>
43
6
 *
44
7
 * Permission is hereby granted, free of charge, to any person obtaining a
45
8
 * copy of this software and associated documentation files (the "Software"),
46
9
 * to deal in the Software without restriction, including without limitation
47
10
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
48
11
 * and/or sell copies of the Software, and to permit persons to whom the
49
12
 * Software is furnished to do so, subject to the following conditions:
50
13
 *
51
14
 * The above copyright notice and this permission notice shall be included in
52
15
 * all copies or substantial portions of the Software.
53
16
 *
54
17
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
55
18
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
56
19
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
57
20
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
58
21
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
59
22
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
60
23
 * DEALINGS IN THE SOFTWARE.
61
24
 */
62
25
#ifndef _COMPIZ_COMPOSITE_AGEDAMAGEQUERY_H
63
26
#define _COMPIZ_COMPOSITE_AGEDAMAGEQUERY_H
64
27
65
28
#include <boost/shared_ptr.hpp>
66
29
#include <core/region.h>
67
30
68
31
namespace compiz
69
32
{
70
33
namespace composite
71
34
{
72
35
namespace buffertracking
73
36
{
74
37
class AgeDamageQuery
75
38
{
76
39
    public:
77
40
78
41
	typedef boost::shared_ptr <AgeDamageQuery> Ptr;
79
42
	typedef boost::function <bool (const CompRegion &)> AreaShouldBeMarkedDirty;
80
43
81
44
	virtual ~AgeDamageQuery () {}
82
45
	virtual CompRegion damageForFrameAge (unsigned int) = 0;
83
46
	virtual const CompRegion & currentFrameDamage () = 0;
84
47
};
85
48
}
86
49
}
87
50
}
88
51
89
52
#endif
90
53
91
0
54
92
=== modified file 'plugins/composite/include/composite/composite.h'
93
--- plugins/composite/include/composite/composite.h	2012-10-16 05:11:10 +0000
94
+++ plugins/composite/include/composite/composite.h	2013-04-24 14:57:28 +0000
95
@@ -30,7 +30,7 @@
96
30
30
97
31
#include <X11/extensions/Xcomposite.h>
31
#include <X11/extensions/Xcomposite.h>
98
32
32
100
33
#define COMPIZ_COMPOSITE_ABI 5
33
#define COMPIZ_COMPOSITE_ABI 6
101
34
34
102
35
#include "core/pluginclasshandler.h"
35
#include "core/pluginclasshandler.h"
103
36
#include "core/timer.h"
36
#include "core/timer.h"
104
@@ -38,6 +38,8 @@
105
38
#include "core/screen.h"
38
#include "core/screen.h"
106
39
#include "core/wrapsystem.h"
39
#include "core/wrapsystem.h"
107
40
40
108
41
#include "composite/agedamagequery.h"
109
42
110
41
#define COMPOSITE_SCREEN_DAMAGE_PENDING_MASK (1 << 0)
43
#define COMPOSITE_SCREEN_DAMAGE_PENDING_MASK (1 << 0)
111
42
#define COMPOSITE_SCREEN_DAMAGE_REGION_MASK  (1 << 1)
44
#define COMPOSITE_SCREEN_DAMAGE_REGION_MASK  (1 << 1)
112
43
#define COMPOSITE_SCREEN_DAMAGE_ALL_MASK     (1 << 2)
45
#define COMPOSITE_SCREEN_DAMAGE_ALL_MASK     (1 << 2)
113
@@ -98,18 +100,19 @@
114
98
namespace composite
100
namespace composite
115
99
{
101
{
116
100
class PaintHandler {
102
class PaintHandler {
129
101
public:
103
    public:
130
102
    virtual ~PaintHandler () {};
104
	virtual ~PaintHandler () {};
131
103
105
132
104
    virtual void paintOutputs (CompOutput::ptrList &outputs,
106
	virtual void paintOutputs (CompOutput::ptrList &outputs,
133
105
			       unsigned int        mask,
107
				   unsigned int        mask,
134
106
			       const CompRegion    &region) = 0;
108
				   const CompRegion    &region) = 0;
135
107
109
136
108
    virtual bool hasVSync () { return false; };
110
	virtual bool hasVSync () { return false; };
137
109
    virtual bool requiredForcedRefreshRate () { return false; };
111
	virtual bool requiredForcedRefreshRate () { return false; };
138
110
112
139
111
    virtual void prepareDrawing () {};
113
	virtual void prepareDrawing () {};
140
112
    virtual bool compositingActive () { return false; };
114
	virtual bool compositingActive () { return false; };
141
115
	virtual unsigned int getFrameAge () { return 1; }
142
113
};
116
};
143
114
}
117
}
144
115
}
118
}
145
@@ -173,12 +176,19 @@
146
173
	 * Hookable function to damage regions directly
176
	 * Hookable function to damage regions directly
147
174
	 */
177
	 */
148
175
	virtual void damageRegion (const CompRegion &r);
178
	virtual void damageRegion (const CompRegion &r);
149
179
150
180
	/**
151
181
	 * Hookable function to notify plugins that the last damage
152
182
	 * event for this frame has been received, and all further damage
153
183
	 * events will be for the next frame
154
184
	 */
155
185
	virtual void damageCutoff ();
156
176
};
186
};
157
177
187
158
178
extern template class PluginClassHandler<CompositeScreen, CompScreen, COMPIZ_COMPOSITE_ABI>;
188
extern template class PluginClassHandler<CompositeScreen, CompScreen, COMPIZ_COMPOSITE_ABI>;
159
179
189
160
180
class CompositeScreen :
190
class CompositeScreen :
162
181
    public WrapableHandler<CompositeScreenInterface, 7>,
191
    public WrapableHandler<CompositeScreenInterface, 8>,
163
182
    public PluginClassHandler<CompositeScreen, CompScreen, COMPIZ_COMPOSITE_ABI>,
192
    public PluginClassHandler<CompositeScreen, CompScreen, COMPIZ_COMPOSITE_ABI>,
164
183
    public CompOption::Class
193
    public CompOption::Class
165
184
{
194
{
166
@@ -203,6 +213,24 @@
167
203
	void damageScreen ();
213
	void damageScreen ();
168
204
214
169
205
	void damagePending ();
215
	void damagePending ();
170
216
171
217
	/**
172
218
	 * Causes the damage that was recorded on N - 1 number of
173
219
	 * frames ago to be added to the current frame, applied
174
220
	 * culmulatively. An age of "zero" means that the entire frame
175
221
	 * is considered undefined and must be completely repaired,
176
222
	 * wheras an age of 1 means that this frame is the same as the
177
223
	 * last frame, so no damage is required.
178
224
	 */
179
225
	void applyDamageForFrameAge (unsigned int);
180
226
	unsigned int getFrameAge ();
181
227
	void addOverdrawDamageRegion (const CompRegion &);
182
228
183
229
	typedef compiz::composite::buffertracking::AgeDamageQuery DamageQuery;
184
230
	typedef DamageQuery::AreaShouldBeMarkedDirty AreaShouldBeMarkedDirty;
185
231
186
232
	DamageQuery::Ptr
187
233
	getDamageQuery (const AreaShouldBeMarkedDirty &callback);
188
206
	
234
	
189
207
235
190
208
	unsigned int damageMask ();
236
	unsigned int damageMask ();
191
@@ -248,6 +276,7 @@
192
248
	 * event loop
276
	 * event loop
193
249
	 */
277
	 */
194
250
	WRAPABLE_HND (6, CompositeScreenInterface, void, damageRegion, const CompRegion &);
278
	WRAPABLE_HND (6, CompositeScreenInterface, void, damageRegion, const CompRegion &);
195
279
	WRAPABLE_HND (7, CompositeScreenInterface, void, damageCutoff);
196
251
280
197
252
	friend class PrivateCompositeDisplay;
281
	friend class PrivateCompositeDisplay;
198
253
282
199
@@ -310,6 +339,12 @@
200
310
 */
339
 */
201
311
#define PAINT_WINDOW_BLEND_MASK			(1 << 19)
340
#define PAINT_WINDOW_BLEND_MASK			(1 << 19)
202
312
341
203
342
/**
204
343
 * flags that would indicate the window is never actually drawn
205
344
 */
206
345
#define PAINT_WINDOW_NO_DRAW_MASKS (PAINT_WINDOW_OCCLUSION_DETECTION_MASK | \
207
346
				    PAINT_WINDOW_NO_CORE_INSTANCE_MASK)
208
347
209
313
class CompositeWindowInterface;
348
class CompositeWindowInterface;
210
314
extern template class WrapableInterface<CompositeWindow, CompositeWindowInterface>;
349
extern template class WrapableInterface<CompositeWindow, CompositeWindowInterface>;
211
315
350
212
316
351
213
=== added directory 'plugins/composite/src/backbuffertracking'
214
=== added file 'plugins/composite/src/backbuffertracking/CMakeLists.txt'
215
--- plugins/composite/src/backbuffertracking/CMakeLists.txt	1970-01-01 00:00:00 +0000
216
+++ plugins/composite/src/backbuffertracking/CMakeLists.txt	2013-04-24 14:57:28 +0000
217
@@ -0,0 +1,31 @@
218
1
INCLUDE_DIRECTORIES (  
219
2
  ${CMAKE_CURRENT_SOURCE_DIR}/../../include
220
3
  ${CMAKE_CURRENT_SOURCE_DIR}/include
221
4
  ${CMAKE_CURRENT_SOURCE_DIR}/src
222
5
    
223
6
  ${Boost_INCLUDE_DIRS}
224
7
)
225
8
226
9
LINK_DIRECTORIES (${COMPIZ_LIBRARY_DIRS}) 
227
10
228
11
SET( 
229
12
  SRCS 
230
13
  ${CMAKE_CURRENT_SOURCE_DIR}/src/backbuffertracking.cpp
231
14
)
232
15
233
16
ADD_LIBRARY( 
234
17
  compiz_composite_backbuffertracking STATIC
235
18
  
236
19
  ${SRCS}
237
20
)
238
21
239
22
if (COMPIZ_BUILD_TESTING)
240
23
ADD_SUBDIRECTORY( ${CMAKE_CURRENT_SOURCE_DIR}/tests )
241
24
endif (COMPIZ_BUILD_TESTING)
242
25
243
26
TARGET_LINK_LIBRARIES(
244
27
  compiz_composite_backbuffertracking
245
28
246
29
  compiz_size
247
30
  compiz_core
248
31
)
249
0
32
250
=== added directory 'plugins/composite/src/backbuffertracking/include'
251
=== added file 'plugins/composite/src/backbuffertracking/include/backbuffertracking.h'
252
--- plugins/composite/src/backbuffertracking/include/backbuffertracking.h	1970-01-01 00:00:00 +0000
253
+++ plugins/composite/src/backbuffertracking/include/backbuffertracking.h	2013-04-24 14:57:28 +0000
254
@@ -0,0 +1,125 @@
255
1
/*
256
2
 * Compiz, composite plugin, GLX_EXT_buffer_age logic
257
3
 *
258
4
 * Copyright (c) 2012 Sam Spilsbury
259
5
 * Authors: Sam Spilsbury <smspillaz@gmail.com>
260
6
 *
261
7
 * Permission is hereby granted, free of charge, to any person obtaining a
262
8
 * copy of this software and associated documentation files (the "Software"),
263
9
 * to deal in the Software without restriction, including without limitation
264
10
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
265
11
 * and/or sell copies of the Software, and to permit persons to whom the
266
12
 * Software is furnished to do so, subject to the following conditions:
267
13
 *
268
14
 * The above copyright notice and this permission notice shall be included in
269
15
 * all copies or substantial portions of the Software.
270
16
 *
271
17
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
272
18
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
273
19
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
274
20
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
275
21
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
276
22
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
277
23
 * DEALINGS IN THE SOFTWARE.
278
24
 */
279
25
#ifndef _COMPIZ_COMPOSITE_BACKBUFFERTRACKING_H
280
26
#define _COMPIZ_COMPOSITE_BACKBUFFERTRACKING_H
281
27
282
28
#include <memory>
283
29
#include <boost/noncopyable.hpp>
284
30
#include <boost/shared_ptr.hpp>
285
31
#include <boost/weak_ptr.hpp>
286
32
#include <boost/function.hpp>
287
33
288
34
#include <composite/agedamagequery.h>
289
35
290
36
class CompSize;
291
37
class CompRegion;
292
38
293
39
namespace compiz
294
40
{
295
41
namespace composite
296
42
{
297
43
namespace buffertracking
298
44
{
299
45
class DamageAgeTracking
300
46
{
301
47
    public:
302
48
303
49
	virtual ~DamageAgeTracking () {};
304
50
	virtual void dirtyAreaOnCurrentFrame (const CompRegion &) = 0;
305
51
	virtual void overdrawRegionOnPaintingFrame (const CompRegion &) = 0;
306
52
	virtual void subtractObscuredArea (const CompRegion &) = 0;
307
53
	virtual void incrementFrameAges () = 0;
308
54
};
309
55
310
56
class AgeingDamageBufferObserver
311
57
{
312
58
    public:
313
59
314
60
	virtual ~AgeingDamageBufferObserver () {};
315
61
	virtual void observe (DamageAgeTracking &damageAgeTracker) = 0;
316
62
	virtual void unobserve (DamageAgeTracking &damageAgeTracker) = 0;
317
63
};
318
64
319
65
class AgeingDamageBuffers :
320
66
    public AgeingDamageBufferObserver,
321
67
    boost::noncopyable
322
68
{
323
69
    public:
324
70
325
71
	AgeingDamageBuffers ();
326
72
327
73
	void observe (DamageAgeTracking &damageAgeTracker);
328
74
	void unobserve (DamageAgeTracking &damageAgeTracker);
329
75
	void incrementAges ();
330
76
	void markAreaDirty (const CompRegion &reg);
331
77
	void markAreaDirtyOnLastFrame (const CompRegion &reg);
332
78
	void subtractObscuredArea (const CompRegion &reg);
333
79
334
80
    private:
335
81
336
82
	class Private;
337
83
	std::auto_ptr <Private> priv;
338
84
};
339
85
340
86
class FrameRoster :
341
87
    public DamageAgeTracking,
342
88
    public AgeDamageQuery,
343
89
    boost::noncopyable
344
90
{
345
91
    public:
346
92
347
93
	typedef AgeDamageQuery::AreaShouldBeMarkedDirty AreaShouldBeMarkedDirty;
348
94
	typedef boost::shared_ptr <FrameRoster> Ptr;
349
95
350
96
	FrameRoster (const CompSize                   &size,
351
97
		     AgeingDamageBufferObserver       &tracker,
352
98
		     const AreaShouldBeMarkedDirty    &shouldMarkDirty);
353
99
354
100
	~FrameRoster ();
355
101
356
102
	void dirtyAreaOnCurrentFrame (const CompRegion &);
357
103
	void overdrawRegionOnPaintingFrame (const CompRegion &);
358
104
	void subtractObscuredArea (const CompRegion &);
359
105
	void incrementFrameAges ();
360
106
	CompRegion damageForFrameAge (unsigned int);
361
107
	const CompRegion & currentFrameDamage ();
362
108
363
109
	class Private;
364
110
	std::auto_ptr <Private> priv;
365
111
366
112
	static const unsigned int NUM_TRACKED_FRAMES = 10;
367
113
368
114
	static
369
115
	FrameRoster::Ptr create (const CompSize                &size,
370
116
371
117
				 const AreaShouldBeMarkedDirty &shouldMarkDirty);
372
118
373
119
    private:
374
120
375
121
};
376
122
} // namespace buffertracking
377
123
} // namespace composite
378
124
} // namespace compiz
379
125
#endif
380
0
126
381
=== added directory 'plugins/composite/src/backbuffertracking/src'
382
=== added file 'plugins/composite/src/backbuffertracking/src/backbuffertracking.cpp'
383
--- plugins/composite/src/backbuffertracking/src/backbuffertracking.cpp	1970-01-01 00:00:00 +0000
384
+++ plugins/composite/src/backbuffertracking/src/backbuffertracking.cpp	2013-04-24 14:57:28 +0000
385
@@ -0,0 +1,214 @@
386
1
/*
387
2
 * Compiz, composite plugin, GLX_EXT_buffer_age logic
388
3
 *
389
4
 * Copyright (c) 2012 Sam Spilsbury
390
5
 * Authors: Sam Spilsbury <smspillaz@gmail.com>
391
6
 *
392
7
 * Permission is hereby granted, free of charge, to any person obtaining a
393
8
 * copy of this software and associated documentation files (the "Software"),
394
9
 * to deal in the Software without restriction, including without limitation
395
10
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
396
11
 * and/or sell copies of the Software, and to permit persons to whom the
397
12
 * Software is furnished to do so, subject to the following conditions:
398
13
 *
399
14
 * The above copyright notice and this permission notice shall be included in
400
15
 * all copies or substantial portions of the Software.
401
16
 *
402
17
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
403
18
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
404
19
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
405
20
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
406
21
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
407
22
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
408
23
 * DEALINGS IN THE SOFTWARE.
409
24
 */
410
25
#include <deque>
411
26
#include <core/size.h>
412
27
#include <core/region.h>
413
28
#include "backbuffertracking.h"
414
29
#include <cstdio>
415
30
416
31
namespace bt = compiz::composite::buffertracking;
417
32
418
33
class bt::FrameRoster::Private
419
34
{
420
35
    public:
421
36
422
37
	Private (const CompSize                                 &size,
423
38
		 bt::AgeingDamageBufferObserver                 &observer,
424
39
		 const bt::FrameRoster::AreaShouldBeMarkedDirty &shouldBeMarkedDirty) :
425
40
	    screenSize (size),
426
41
	    observer (observer),
427
42
	    shouldBeMarkedDirty (shouldBeMarkedDirty),
428
43
	    oldFrames (1)
429
44
	{
430
45
	}
431
46
432
47
	CompSize                                 screenSize;
433
48
	bt::AgeingDamageBufferObserver           &observer;
434
49
	bt::FrameRoster::AreaShouldBeMarkedDirty shouldBeMarkedDirty;
435
50
	std::deque <CompRegion>                  oldFrames;
436
51
};
437
52
438
53
bt::FrameRoster::FrameRoster (const CompSize                 &size,
439
54
			      bt::AgeingDamageBufferObserver &tracker,
440
55
			      const AreaShouldBeMarkedDirty  &shouldBeMarkedDirty) :
441
56
    priv (new bt::FrameRoster::Private (size,
442
57
					tracker,
443
58
					shouldBeMarkedDirty))
444
59
{
445
60
    priv->observer.observe (*this);
446
61
}
447
62
448
63
bt::FrameRoster::~FrameRoster ()
449
64
{
450
65
    priv->observer.unobserve (*this);
451
66
}
452
67
453
68
CompRegion
454
69
bt::FrameRoster::damageForFrameAge (unsigned int age)
455
70
{
456
71
    if (!age)
457
72
	return CompRegion (0, 0,
458
73
			   priv->screenSize.width (),
459
74
			   priv->screenSize.height ());
460
75
461
76
    if (age >= priv->oldFrames.size ())
462
77
	return CompRegion (0, 0,
463
78
			   priv->screenSize.width (),
464
79
			   priv->screenSize.height ());
465
80
466
81
    CompRegion accumulatedDamage;
467
82
468
83
    while (age--)
469
84
    {
470
85
	unsigned int frameNum = (priv->oldFrames.size () - age) - 1;
471
86
	accumulatedDamage += priv->oldFrames[frameNum];
472
87
    }
473
88
474
89
    return accumulatedDamage;
475
90
}
476
91
477
92
void
478
93
bt::FrameRoster::dirtyAreaOnCurrentFrame (const CompRegion &r)
479
94
{
480
95
    if (priv->shouldBeMarkedDirty (r))
481
96
	(*priv->oldFrames.rbegin ()) += r;
482
97
}
483
98
484
99
void
485
100
bt::FrameRoster::subtractObscuredArea (const CompRegion &r)
486
101
{
487
102
    (*priv->oldFrames.rbegin ()) -= r;
488
103
}
489
104
490
105
void
491
106
bt::FrameRoster::overdrawRegionOnPaintingFrame (const CompRegion &r)
492
107
{
493
108
    assert (priv->oldFrames.size () > 1);
494
109
    std::deque <CompRegion>::reverse_iterator it = priv->oldFrames.rbegin ();
495
110
    ++it;
496
111
    (*it) += r;
497
112
}
498
113
499
114
void
500
115
bt::FrameRoster::incrementFrameAges ()
501
116
{
502
117
    priv->oldFrames.push_back (CompRegion ());
503
118
504
119
    /* Get rid of old frames */
505
120
    if (priv->oldFrames.size () > NUM_TRACKED_FRAMES)
506
121
	priv->oldFrames.pop_front ();
507
122
}
508
123
509
124
const CompRegion &
510
125
bt::FrameRoster::currentFrameDamage ()
511
126
{
512
127
    return *priv->oldFrames.rbegin ();
513
128
}
514
129
515
130
class bt::AgeingDamageBuffers::Private
516
131
{
517
132
    public:
518
133
519
134
	std::vector <bt::DamageAgeTracking *> damageAgeTrackers;
520
135
};
521
136
522
137
bt::AgeingDamageBuffers::AgeingDamageBuffers () :
523
138
    priv (new bt::AgeingDamageBuffers::Private ())
524
139
{
525
140
}
526
141
527
142
void
528
143
bt::AgeingDamageBuffers::observe (bt::DamageAgeTracking &damageAgeTracker)
529
144
{
530
145
    priv->damageAgeTrackers.push_back (&damageAgeTracker);
531
146
}
532
147
533
148
void
534
149
bt::AgeingDamageBuffers::unobserve (bt::DamageAgeTracking &damageAgeTracker)
535
150
{
536
151
    std::vector <bt::DamageAgeTracking *>::iterator it =
537
152
	std::find (priv->damageAgeTrackers.begin (),
538
153
		   priv->damageAgeTrackers.end (),
539
154
		   &damageAgeTracker);
540
155
541
156
    if (it != priv->damageAgeTrackers.end ())
542
157
	priv->damageAgeTrackers.erase (it);
543
158
}
544
159
545
160
void
546
161
bt::AgeingDamageBuffers::incrementAges ()
547
162
{
548
163
    for (std::vector <bt::DamageAgeTracking *>::iterator it =
549
164
	 priv->damageAgeTrackers.begin ();
550
165
	 it != priv->damageAgeTrackers.end ();
551
166
	 ++it)
552
167
    {
553
168
	bt::DamageAgeTracking *tracker = *it;
554
169
555
170
	tracker->incrementFrameAges ();
556
171
    }
557
172
}
558
173
559
174
void
560
175
bt::AgeingDamageBuffers::markAreaDirty (const CompRegion &reg)
561
176
{
562
177
    for (std::vector <bt::DamageAgeTracking *>::iterator it =
563
178
	 priv->damageAgeTrackers.begin ();
564
179
	 it != priv->damageAgeTrackers.end ();
565
180
	 ++it)
566
181
    {
567
182
	bt::DamageAgeTracking *tracker = *it;
568
183
569
184
	tracker->dirtyAreaOnCurrentFrame (reg);
570
185
    }
571
186
}
572
187
573
188
void
574
189
bt::AgeingDamageBuffers::subtractObscuredArea (const CompRegion &reg)
575
190
{
576
191
    for (std::vector <bt::DamageAgeTracking *>::iterator it =
577
192
	 priv->damageAgeTrackers.begin ();
578
193
	 it != priv->damageAgeTrackers.end ();
579
194
	 ++it)
580
195
    {
581
196
	bt::DamageAgeTracking *tracker = *it;
582
197
583
198
	tracker->subtractObscuredArea (reg);
584
199
    }
585
200
}
586
201
587
202
void
588
203
bt::AgeingDamageBuffers::markAreaDirtyOnLastFrame (const CompRegion &reg)
589
204
{
590
205
    for (std::vector <bt::DamageAgeTracking *>::iterator it =
591
206
	 priv->damageAgeTrackers.begin ();
592
207
	 it != priv->damageAgeTrackers.end ();
593
208
	 ++it)
594
209
    {
595
210
	bt::DamageAgeTracking *tracker = *it;
596
211
597
212
	tracker->overdrawRegionOnPaintingFrame (reg);
598
213
    }
599
214
}
600
0
215
601
=== added directory 'plugins/composite/src/backbuffertracking/tests'
602
=== added file 'plugins/composite/src/backbuffertracking/tests/CMakeLists.txt'
603
--- plugins/composite/src/backbuffertracking/tests/CMakeLists.txt	1970-01-01 00:00:00 +0000
604
+++ plugins/composite/src/backbuffertracking/tests/CMakeLists.txt	2013-04-24 14:57:28 +0000
605
@@ -0,0 +1,24 @@
606
1
find_library (GMOCK_LIBRARY gmock)
607
2
find_library (GMOCK_MAIN_LIBRARY gmock_main)
608
3
609
4
if (NOT GMOCK_LIBRARY OR NOT GMOCK_MAIN_LIBRARY OR NOT GTEST_FOUND)
610
5
  message ("Google Mock and Google Test not found - cannot build tests!")
611
6
  set (COMPIZ_BUILD_TESTING OFF)
612
7
endif (NOT GMOCK_LIBRARY OR NOT GMOCK_MAIN_LIBRARY OR NOT GTEST_FOUND)
613
8
614
9
include_directories (${GTEST_INCLUDE_DIRS})
615
10
616
11
link_directories (${COMPIZ_LIBRARY_DIRS})
617
12
618
13
add_executable (compiz_test_composite_backbuffertracking
619
14
                ${CMAKE_CURRENT_SOURCE_DIR}/test-composite-backbuffertracking.cpp)
620
15
621
16
target_link_libraries (compiz_test_composite_backbuffertracking
622
17
                       compiz_composite_backbuffertracking
623
18
                       ${GTEST_BOTH_LIBRARIES}
624
19
		       ${GMOCK_LIBRARY}
625
20
		       ${GMOCK_MAIN_LIBRARY}
626
21
		       ${CMAKE_THREAD_LIBS_INIT} # Link in pthread.
627
22
                       )
628
23
629
24
compiz_discover_tests (compiz_test_composite_backbuffertracking COVERAGE compiz_composite_backbuffertracking)
630
0
25
631
=== added file 'plugins/composite/src/backbuffertracking/tests/test-composite-backbuffertracking.cpp'
632
--- plugins/composite/src/backbuffertracking/tests/test-composite-backbuffertracking.cpp	1970-01-01 00:00:00 +0000
633
+++ plugins/composite/src/backbuffertracking/tests/test-composite-backbuffertracking.cpp	2013-04-24 14:57:28 +0000
634
@@ -0,0 +1,450 @@
635
1
/*
636
2
 * Compiz, composite plugin, GLX_EXT_buffer_age logic
637
3
 *
638
4
 * Copyright (c) 2012 Sam Spilsbury
639
5
 * Authors: Sam Spilsbury <smspillaz@gmail.com>
640
6
 *
641
7
 * Permission is hereby granted, free of charge, to any person obtaining a
642
8
 * copy of this software and associated documentation files (the "Software"),
643
9
 * to deal in the Software without restriction, including without limitation
644
10
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
645
11
 * and/or sell copies of the Software, and to permit persons to whom the
646
12
 * Software is furnished to do so, subject to the following conditions:
647
13
 *
648
14
 * The above copyright notice and this permission notice shall be included in
649
15
 * all copies or substantial portions of the Software.
650
16
 *
651
17
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
652
18
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
653
19
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
654
20
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
655
21
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
656
22
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
657
23
 * DEALINGS IN THE SOFTWARE.
658
24
 */
659
25
#include <boost/bind.hpp>
660
26
661
27
#include <gtest/gtest.h>
662
28
#include <gmock/gmock.h>
663
29
664
30
#include <core/region.h>
665
31
#include <core/size.h>
666
32
667
33
#include "backbuffertracking.h"
668
34
669
35
using ::testing::NiceMock;
670
36
using ::testing::_;
671
37
using ::testing::AtLeast;
672
38
673
39
namespace bt = compiz::composite::buffertracking;
674
40
675
41
namespace
676
42
{
677
43
class MockAgeingDamageBufferObserver :
678
44
    public bt::AgeingDamageBufferObserver
679
45
{
680
46
    public:
681
47
682
48
	MOCK_METHOD1 (observe, void (bt::DamageAgeTracking &));
683
49
	MOCK_METHOD1 (unobserve, void (bt::DamageAgeTracking &));
684
50
};
685
51
686
52
bool alwaysTrackDamage (const CompRegion &)
687
53
{
688
54
    return true;
689
55
}
690
56
691
57
692
58
class BackbufferTracking :
693
59
    public ::testing::Test
694
60
{
695
61
    public:
696
62
697
63
	BackbufferTracking () :
698
64
	    screen (1000, 1000),
699
65
	    roster ()
700
66
	{
701
67
	}
702
68
703
69
	virtual void SetUp ()
704
70
	{
705
71
	    SetupRoster ();
706
72
	}
707
73
708
74
	virtual void SetupRoster ()
709
75
	{
710
76
	    roster.reset (new bt::FrameRoster (screen,
711
77
					       niceTracker,
712
78
					       boost::bind (alwaysTrackDamage,
713
79
							   _1)));
714
80
	}
715
81
716
82
    protected:
717
83
718
84
	CompSize                           screen;
719
85
	NiceMock <MockAgeingDamageBufferObserver> niceTracker;
720
86
	bt::FrameRoster::Ptr               roster;
721
87
};
722
88
723
89
class BackbufferTrackingCallbacks :
724
90
    public BackbufferTracking
725
91
{
726
92
    public:
727
93
728
94
	BackbufferTrackingCallbacks () :
729
95
	    shouldDamage (false)
730
96
	{
731
97
	}
732
98
733
99
    protected:
734
100
735
101
	void allowDamage (bool allow)
736
102
	{
737
103
	    shouldDamage = allow;
738
104
	}
739
105
740
106
    private:
741
107
742
108
	virtual void SetupRoster ()
743
109
	{
744
110
	    roster.reset (new bt::FrameRoster (screen,
745
111
					       niceTracker,
746
112
					       boost::bind (&BackbufferTrackingCallbacks::shouldDamageCallback,
747
113
							    this, _1)));
748
114
	}
749
115
750
116
	bool shouldDamageCallback (const CompRegion &)
751
117
	{
752
118
	    return shouldDamage;
753
119
	}
754
120
755
121
	bool shouldDamage;
756
122
};
757
123
}
758
124
759
125
std::ostream &
760
126
operator<< (std::ostream &os, const CompRegion &reg)
761
127
{
762
128
    os << "Region with Bounding Rectangle : " <<
763
129
	  reg.boundingRect ().x () << " " <<
764
130
	  reg.boundingRect ().y () << " " <<
765
131
	  reg.boundingRect ().width () << " " <<
766
132
	  reg.boundingRect ().height () << std::endl;
767
133
    CompRect::vector rects (reg.rects ());
768
134
    for (CompRect::vector::iterator it = rects.begin ();
769
135
	 it != rects.end ();
770
136
	 it++)
771
137
	os << " - subrectangle: " <<
772
138
	      (*it).x () << " " <<
773
139
	      (*it).y () << " " <<
774
140
	      (*it).width () << " " <<
775
141
	      (*it).height () << " " << std::endl;
776
142
777
143
    return os;
778
144
}
779
145
780
146
TEST (BackbufferTrackingConstruction, CreateAddsToObserverList)
781
147
{
782
148
    MockAgeingDamageBufferObserver mockAgeingDamageBufferObserver;
783
149
784
150
    /* We can't verify the argument here,
785
151
     * but we can verify the function call */
786
152
    EXPECT_CALL (mockAgeingDamageBufferObserver, observe (_));
787
153
    EXPECT_CALL (mockAgeingDamageBufferObserver, unobserve (_)).Times (AtLeast (0));
788
154
    bt::FrameRoster roster (CompSize (),
789
155
			    mockAgeingDamageBufferObserver,
790
156
			    boost::bind (alwaysTrackDamage, _1));
791
157
}
792
158
793
159
TEST (BackbufferTrackingConstruction, DestroyRemovesFromObserverList)
794
160
{
795
161
    MockAgeingDamageBufferObserver mockAgeingDamageBufferObserver;
796
162
797
163
    /* We can't verify the argument here,
798
164
     * but we can verify the function call */
799
165
    EXPECT_CALL (mockAgeingDamageBufferObserver, observe (_)).Times (AtLeast (0));
800
166
    EXPECT_CALL (mockAgeingDamageBufferObserver, unobserve (_));
801
167
    bt::FrameRoster roster (CompSize (),
802
168
			    mockAgeingDamageBufferObserver,
803
169
			    boost::bind (alwaysTrackDamage, _1));
804
170
}
805
171
806
172
TEST_F (BackbufferTrackingCallbacks, TrackIntoCurrentIfCallbackTrue)
807
173
{
808
174
    allowDamage (true);
809
175
    CompRegion damage (100, 100, 100, 100);
810
176
    roster->dirtyAreaOnCurrentFrame (damage);
811
177
    EXPECT_EQ (damage, roster->currentFrameDamage ());
812
178
}
813
179
814
180
TEST_F (BackbufferTrackingCallbacks, NoTrackIntoCurrentIfCallbackFalse)
815
181
{
816
182
    allowDamage (false);
817
183
    CompRegion damage (100, 100, 100, 100);
818
184
    roster->dirtyAreaOnCurrentFrame (damage);
819
185
    EXPECT_EQ (emptyRegion, roster->currentFrameDamage ());
820
186
}
821
187
822
188
TEST_F (BackbufferTracking, DirtyAreaSubtraction)
823
189
{
824
190
    CompRegion dirty (100, 100, 100, 100);
825
191
    CompRegion obscured (150, 150, 50, 50);
826
192
    roster->dirtyAreaOnCurrentFrame (dirty);
827
193
    roster->subtractObscuredArea (obscured);
828
194
    EXPECT_EQ (dirty - obscured, roster->currentFrameDamage ());
829
195
}
830
196
831
197
TEST_F (BackbufferTracking, DirtyAreaForAgeZeroAll)
832
198
{
833
199
    EXPECT_EQ (CompRegion (0, 0, screen.width (), screen.height ()),
834
200
	       roster->damageForFrameAge (0));
835
201
}
836
202
837
203
TEST_F (BackbufferTracking, DirtyAreaAllForOlderThanTrackedAge)
838
204
{
839
205
    EXPECT_EQ (CompRegion (0, 0, screen.width (), screen.height ()),
840
206
	       roster->damageForFrameAge (1));
841
207
}
842
208
843
209
TEST_F (BackbufferTracking, NoDirtyAreaForLastFrame)
844
210
{
845
211
    CompRegion all (0, 0, screen.width (), screen.height ());
846
212
    roster->dirtyAreaOnCurrentFrame (all);
847
213
    roster->incrementFrameAges ();
848
214
    EXPECT_EQ (emptyRegion, roster->damageForFrameAge (1));
849
215
}
850
216
851
217
TEST_F (BackbufferTracking, DirtyAreaIfMoreSinceLastFrame)
852
218
{
853
219
    CompRegion all (0, 0, screen.width (), screen.height ());
854
220
    roster->dirtyAreaOnCurrentFrame (all);
855
221
    roster->incrementFrameAges ();
856
222
    roster->dirtyAreaOnCurrentFrame(all);
857
223
    EXPECT_EQ (all, roster->damageForFrameAge (1));
858
224
}
859
225
860
226
TEST_F (BackbufferTracking, AddOverdrawRegionForLastFrame)
861
227
{
862
228
    CompRegion all (0, 0, screen.width (), screen.height ());
863
229
    roster->dirtyAreaOnCurrentFrame (all);
864
230
    roster->incrementFrameAges ();
865
231
    roster->incrementFrameAges ();
866
232
    roster->overdrawRegionOnPaintingFrame (all);
867
233
    EXPECT_EQ (all, roster->damageForFrameAge (2));
868
234
}
869
235
870
236
TEST_F (BackbufferTracking, TwoFramesAgo)
871
237
{
872
238
    CompRegion all (0, 0, screen.width (), screen.height ());
873
239
    CompRegion topleft (0, 0, screen.width () / 2, screen.height () / 2);
874
240
875
241
    roster->dirtyAreaOnCurrentFrame (all);
876
242
    roster->incrementFrameAges ();
877
243
    roster->dirtyAreaOnCurrentFrame (topleft);
878
244
    roster->incrementFrameAges ();
879
245
    EXPECT_EQ (topleft, roster->damageForFrameAge (2));
880
246
}
881
247
882
248
TEST_F (BackbufferTracking, TwoFramesAgoCulmulative)
883
249
{
884
250
    CompRegion all (0, 0, screen.width (), screen.height ());
885
251
    CompRegion topleft (0, 0, screen.width () / 2, screen.height () / 2);
886
252
    CompRegion topright (0, screen.width () / 2,
887
253
			 screen.width () / 2,
888
254
			 screen.height () / 2);
889
255
890
256
    roster->dirtyAreaOnCurrentFrame (all);
891
257
    roster->incrementFrameAges ();
892
258
    roster->dirtyAreaOnCurrentFrame (topleft);
893
259
    roster->dirtyAreaOnCurrentFrame (topright);
894
260
    roster->incrementFrameAges ();
895
261
    EXPECT_EQ (topleft + topright, roster->damageForFrameAge (2));
896
262
}
897
263
898
264
TEST_F (BackbufferTracking, ThreeFramesAgo)
899
265
{
900
266
    CompRegion all (0, 0, screen.width (), screen.height ());
901
267
    CompRegion topleft (0, 0, screen.width () / 2, screen.height () / 2);
902
268
    CompRegion bottomright (screen.width () / 2,
903
269
			    screen.height () / 2,
904
270
			    screen.width () / 2,
905
271
			    screen.height () / 2);
906
272
907
273
    roster->dirtyAreaOnCurrentFrame (all);
908
274
    roster->incrementFrameAges ();
909
275
    roster->dirtyAreaOnCurrentFrame (topleft);
910
276
    roster->incrementFrameAges ();
911
277
    roster->dirtyAreaOnCurrentFrame (bottomright);
912
278
    roster->incrementFrameAges ();
913
279
914
280
    EXPECT_EQ (topleft + bottomright, roster->damageForFrameAge (3));
915
281
}
916
282
917
283
/* These are more or less functional tests from this point forward
918
284
 * just checking a number of different situations */
919
285
920
286
TEST_F (BackbufferTracking, ThreeFramesAgoWithFourFrames)
921
287
{
922
288
    CompRegion all (0, 0, screen.width (), screen.height ());
923
289
    CompRegion topleft (0, 0, screen.width () / 2, screen.height () / 2);
924
290
    CompRegion bottomright (screen.width () / 2,
925
291
			    screen.height () / 2,
926
292
			    screen.width () / 2,
927
293
			    screen.height () / 2);
928
294
    CompRegion topright (screen.width () / 2,
929
295
			 0,
930
296
			 screen.width () / 2,
931
297
			 screen.height () / 2);
932
298
933
299
    roster->dirtyAreaOnCurrentFrame (all);
934
300
    roster->incrementFrameAges ();
935
301
    roster->dirtyAreaOnCurrentFrame (topleft);
936
302
    roster->incrementFrameAges ();
937
303
    roster->dirtyAreaOnCurrentFrame (bottomright);
938
304
    roster->incrementFrameAges ();
939
305
    roster->dirtyAreaOnCurrentFrame (topright);
940
306
    roster->incrementFrameAges ();
941
307
942
308
    EXPECT_EQ (topright + bottomright, roster->damageForFrameAge (3));
943
309
}
944
310
945
311
TEST_F (BackbufferTracking, ThreeFramesAgoWithFourFramesAndOverlap)
946
312
{
947
313
    CompRegion all (0, 0, screen.width (), screen.height ());
948
314
    CompRegion topleft (0, 0, screen.width () / 2, screen.height () / 2);
949
315
    CompRegion bottomright (screen.width () / 2,
950
316
			    screen.height () / 2,
951
317
			    screen.width () / 2,
952
318
			    screen.height () / 2);
953
319
    CompRegion topright (screen.width () / 2,
954
320
			 0,
955
321
			 screen.width () / 2,
956
322
			 screen.height () / 2);
957
323
958
324
    roster->dirtyAreaOnCurrentFrame (all);
959
325
    roster->incrementFrameAges ();
960
326
    roster->dirtyAreaOnCurrentFrame (topleft);
961
327
    roster->incrementFrameAges ();
962
328
    roster->dirtyAreaOnCurrentFrame (bottomright);
963
329
    roster->incrementFrameAges ();
964
330
    roster->dirtyAreaOnCurrentFrame (bottomright);
965
331
    roster->incrementFrameAges ();
966
332
967
333
    EXPECT_EQ (bottomright, roster->damageForFrameAge (3));
968
334
}
969
335
970
336
TEST_F (BackbufferTracking, AllDamageForExceedingMaxTrackedFrames)
971
337
{
972
338
    CompRegion all (0, 0, screen.width (), screen.height ());
973
339
    CompRegion damage (0, 0, 1, 1);
974
340
975
341
    roster->dirtyAreaOnCurrentFrame (all);
976
342
977
343
    for (unsigned int i = 0; i < bt::FrameRoster::NUM_TRACKED_FRAMES - 1; ++i)
978
344
    {
979
345
	roster->incrementFrameAges ();
980
346
	roster->dirtyAreaOnCurrentFrame (damage);
981
347
    }
982
348
983
349
    EXPECT_EQ (all, roster->damageForFrameAge (bt::FrameRoster::NUM_TRACKED_FRAMES + 1));
984
350
}
985
351
986
352
TEST_F (BackbufferTracking, DamageForMaxTrackedFrame)
987
353
{
988
354
    CompRegion all (0, 0, screen.width (), screen.height ());
989
355
    CompRegion damage (0, 0, 1, 1);
990
356
991
357
    roster->dirtyAreaOnCurrentFrame (all);
992
358
993
359
    for (unsigned int i = 0; i < bt::FrameRoster::NUM_TRACKED_FRAMES + 1; ++i)
994
360
    {
995
361
	roster->incrementFrameAges ();
996
362
	roster->dirtyAreaOnCurrentFrame (damage);
997
363
    }
998
364
999
365
    EXPECT_EQ (all, roster->damageForFrameAge (bt::FrameRoster::NUM_TRACKED_FRAMES));
1000
366
}
1001
367
1002
368
class MockDamageAgeTracking :
1003
369
    public bt::DamageAgeTracking
1004
370
{
1005
371
    public:
1006
372
1007
373
	typedef boost::shared_ptr <MockDamageAgeTracking> Ptr;
1008
374
1009
375
	MOCK_METHOD0 (incrementFrameAges, void ());
1010
376
	MOCK_METHOD1 (dirtyAreaOnCurrentFrame, void (const CompRegion &));
1011
377
	MOCK_METHOD1 (subtractObscuredArea, void (const CompRegion &));
1012
378
	MOCK_METHOD1 (overdrawRegionOnPaintingFrame, void (const CompRegion &));
1013
379
};
1014
380
1015
381
class AgeingDamageBuffers :
1016
382
    public ::testing::Test
1017
383
{
1018
384
    public:
1019
385
1020
386
	AgeingDamageBuffers ()
1021
387
	{
1022
388
	    ageing.observe (mockDamageAgeTracker);
1023
389
	}
1024
390
1025
391
	MockDamageAgeTracking   mockDamageAgeTracker;
1026
392
	bt::AgeingDamageBuffers ageing;
1027
393
};
1028
394
1029
395
TEST_F (AgeingDamageBuffers, IncrementAgesOnValidRosters)
1030
396
{
1031
397
    EXPECT_CALL (mockDamageAgeTracker, incrementFrameAges ());
1032
398
    ageing.incrementAges ();
1033
399
}
1034
400
1035
401
TEST_F (AgeingDamageBuffers, DirtyAreaOnValidRosters)
1036
402
{
1037
403
    CompRegion dirtyArea (100, 100, 100, 100);
1038
404
    EXPECT_CALL (mockDamageAgeTracker, dirtyAreaOnCurrentFrame (dirtyArea));
1039
405
    ageing.markAreaDirty (dirtyArea);
1040
406
}
1041
407
1042
408
TEST_F (AgeingDamageBuffers, SubtractObscuredAreaOnValidRosters)
1043
409
{
1044
410
    CompRegion obscuredArea (100, 100, 100, 100);
1045
411
    EXPECT_CALL (mockDamageAgeTracker, subtractObscuredArea (obscuredArea));
1046
412
    ageing.subtractObscuredArea (obscuredArea);
1047
413
}
1048
414
1049
415
TEST_F (AgeingDamageBuffers, AddOverdrawAreaOnValidRosters)
1050
416
{
1051
417
    CompRegion overdrawArea (100, 100, 100, 100);
1052
418
    EXPECT_CALL (mockDamageAgeTracker, overdrawRegionOnPaintingFrame (overdrawArea));
1053
419
    ageing.markAreaDirtyOnLastFrame (overdrawArea);
1054
420
}
1055
421
1056
422
TEST_F (AgeingDamageBuffers, IncrementAgesOnInvalidRosters)
1057
423
{
1058
424
    EXPECT_CALL (mockDamageAgeTracker, incrementFrameAges ()).Times (0);
1059
425
    ageing.unobserve (mockDamageAgeTracker);
1060
426
    ageing.incrementAges ();
1061
427
}
1062
428
1063
429
TEST_F (AgeingDamageBuffers, DirtyAreaOnInvalidRosters)
1064
430
{
1065
431
    EXPECT_CALL (mockDamageAgeTracker, dirtyAreaOnCurrentFrame (_)).Times (0);
1066
432
    ageing.unobserve (mockDamageAgeTracker);
1067
433
    ageing.markAreaDirty (emptyRegion);
1068
434
}
1069
435
1070
436
TEST_F (AgeingDamageBuffers, SubtractObscuredAreaOnInvalidRosters)
1071
437
{
1072
438
    EXPECT_CALL (mockDamageAgeTracker, subtractObscuredArea (_)).Times (0);
1073
439
    ageing.unobserve (mockDamageAgeTracker);
1074
440
    ageing.subtractObscuredArea (emptyRegion);
1075
441
}
1076
442
1077
443
TEST_F (AgeingDamageBuffers, AddOverdrawAreaOnInvalidRosters)
1078
444
{
1079
445
    EXPECT_CALL (mockDamageAgeTracker, overdrawRegionOnPaintingFrame (_)).Times (0);
1080
446
    ageing.unobserve (mockDamageAgeTracker);
1081
447
    ageing.markAreaDirtyOnLastFrame (emptyRegion);
1082
448
}
1083
449
1084
450
1085
0
451
1086
=== modified file 'plugins/composite/src/privates.h'
1087
--- plugins/composite/src/privates.h	2012-09-20 09:35:40 +0000
1088
+++ plugins/composite/src/privates.h	2013-04-24 14:57:28 +0000
1089
@@ -36,12 +36,20 @@
1090
36
#include <map>
36
#include <map>
1091
37
37
1092
38
#include "pixmapbinding.h"
38
#include "pixmapbinding.h"
1093
39
#include "backbuffertracking.h"
1094
39
#include "composite_options.h"
40
#include "composite_options.h"
1095
40
41
1096
41
extern CompPlugin::VTable *compositeVTable;
42
extern CompPlugin::VTable *compositeVTable;
1097
42
43
1098
43
extern CompWindow *lastDamagedWindow;
44
extern CompWindow *lastDamagedWindow;
1099
44
45
1100
46
enum DamageTracking
1101
47
{
1102
48
    DamageForCurrentFrame = 0,
1103
49
    DamageForLastFrame = 1,
1104
50
    DamageFinalPaintRegion
1105
51
};
1106
52
1107
45
class PrivateCompositeScreen :
53
class PrivateCompositeScreen :
1108
46
    ScreenInterface,
54
    ScreenInterface,
1109
47
    public CompositeOptions
55
    public CompositeOptions
1110
@@ -66,6 +74,8 @@
1111
66
74
1112
67
	void scheduleRepaint ();
75
	void scheduleRepaint ();
1113
68
76
1114
77
	const CompRegion * damageTrackedBuffer (const CompRegion &);
1115
78
1116
69
    public:
79
    public:
1117
70
80
1118
71
	CompositeScreen *cScreen;
81
	CompositeScreen *cScreen;
1119
@@ -80,10 +90,12 @@
1120
80
	bool randrExtension;
90
	bool randrExtension;
1121
81
	int  randrEvent, randrError;
91
	int  randrEvent, randrError;
1122
82
92
1124
83
	CompRegion    damage;
93
	CompRegion    lastFrameDamage;
1125
84
	unsigned long damageMask;
94
	unsigned long damageMask;
1126
85
95
1128
86
	CompRegion    tmpRegion;
96
	CompRegion     tmpRegion;
1129
97
1130
98
	DamageTracking currentlyTrackingDamage;
1131
87
99
1132
88
	Window	      overlay;
100
	Window	      overlay;
1133
89
	Window	      output;
101
	Window	      output;
1134
@@ -99,6 +111,7 @@
1135
99
	int            redrawTime;
111
	int            redrawTime;
1136
100
	int            optimalRedrawTime;
112
	int            optimalRedrawTime;
1137
101
	bool           scheduled, painting, reschedule;
113
	bool           scheduled, painting, reschedule;
1138
114
	bool           damageRequiresRepaintReschedule;
1139
102
115
1140
103
	bool slowAnimations;
116
	bool slowAnimations;
1141
104
117
1142
@@ -115,6 +128,9 @@
1143
115
128
1144
116
	/* Map Damage handle to its bounding box */
129
	/* Map Damage handle to its bounding box */
1145
117
	std::map<Damage, XRectangle> damages;
130
	std::map<Damage, XRectangle> damages;
1146
131
1147
132
	compiz::composite::buffertracking::AgeingDamageBuffers ageingBuffers;
1148
133
	compiz::composite::buffertracking::FrameRoster         roster;
1149
118
};
134
};
1150
119
135
1151
120
class PrivateCompositeWindow :
136
class PrivateCompositeWindow :
1152
121
137
1153
=== modified file 'plugins/composite/src/screen.cpp'
1154
--- plugins/composite/src/screen.cpp	2013-04-19 11:03:09 +0000
1155
+++ plugins/composite/src/screen.cpp	2013-04-24 14:57:28 +0000
1156
@@ -47,6 +47,8 @@
1157
47
47
1158
48
template class WrapableInterface<CompositeScreen, CompositeScreenInterface>;
48
template class WrapableInterface<CompositeScreen, CompositeScreenInterface>;
1159
49
49
1160
50
namespace bt = compiz::composite::buffertracking;
1161
51
1162
50
static const int FALLBACK_REFRESH_RATE = 60;   /* if all else fails */
52
static const int FALLBACK_REFRESH_RATE = 60;   /* if all else fails */
1163
51
53
1164
52
CompWindow *lastDamagedWindow = 0;
54
CompWindow *lastDamagedWindow = 0;
1165
@@ -265,6 +267,15 @@
1166
265
    delete priv;
267
    delete priv;
1167
266
}
268
}
1168
267
269
1169
270
namespace
1170
271
{
1171
272
bool alwaysMarkDirty ()
1172
273
{
1173
274
    return true;
1174
275
}
1175
276
}
1176
277
1177
278
1178
268
PrivateCompositeScreen::PrivateCompositeScreen (CompositeScreen *cs) :
279
PrivateCompositeScreen::PrivateCompositeScreen (CompositeScreen *cs) :
1179
269
    cScreen (cs),
280
    cScreen (cs),
1180
270
    compositeEvent (0),
281
    compositeEvent (0),
1181
@@ -282,6 +293,7 @@
1182
282
    randrEvent (0),
293
    randrEvent (0),
1183
283
    randrError (0),
294
    randrError (0),
1184
284
    damageMask (COMPOSITE_SCREEN_DAMAGE_ALL_MASK),
295
    damageMask (COMPOSITE_SCREEN_DAMAGE_ALL_MASK),
1185
296
    currentlyTrackingDamage (DamageForCurrentFrame),
1186
285
    overlay (None),
297
    overlay (None),
1187
286
    output (None),
298
    output (None),
1188
287
    exposeRects (),
299
    exposeRects (),
1189
@@ -293,12 +305,16 @@
1190
293
    scheduled (false),
305
    scheduled (false),
1191
294
    painting (false),
306
    painting (false),
1192
295
    reschedule (false),
307
    reschedule (false),
1193
308
    damageRequiresRepaintReschedule (true),
1194
296
    slowAnimations (false),
309
    slowAnimations (false),
1195
297
    pHnd (NULL),
310
    pHnd (NULL),
1196
298
    FPSLimiterMode (CompositeFPSLimiterModeDefault),
311
    FPSLimiterMode (CompositeFPSLimiterModeDefault),
1197
299
    withDestroyedWindows (),
312
    withDestroyedWindows (),
1198
300
    cmSnAtom (0),
313
    cmSnAtom (0),
1200
301
    newCmSnOwner (None)
314
    newCmSnOwner (None),
1201
315
    roster (*screen,
1202
316
	    ageingBuffers,
1203
317
	    boost::bind (alwaysMarkDirty))
1204
302
{
318
{
1205
303
    gettimeofday (&lastRedraw, 0);
319
    gettimeofday (&lastRedraw, 0);
1206
304
    // wrap outputChangeNotify
320
    // wrap outputChangeNotify
1207
@@ -474,22 +490,62 @@
1208
474
    return false;
490
    return false;
1209
475
}
491
}
1210
476
492
1211
493
const CompRegion *
1212
494
PrivateCompositeScreen::damageTrackedBuffer (const CompRegion &region)
1213
495
{
1214
496
    const CompRegion *currentDamage = NULL;
1215
497
1216
498
    switch (currentlyTrackingDamage)
1217
499
    {
1218
500
	case DamageForCurrentFrame:
1219
501
	    currentDamage = &(roster.currentFrameDamage ());
1220
502
	    ageingBuffers.markAreaDirty (region);
1221
503
	    break;
1222
504
	case DamageForLastFrame:
1223
505
	    currentDamage = &(lastFrameDamage);
1224
506
	    lastFrameDamage += region;
1225
507
	    break;
1226
508
	case DamageFinalPaintRegion:
1227
509
	    currentDamage = &(tmpRegion);
1228
510
	    tmpRegion += region;
1229
511
	    break;
1230
512
	default:
1231
513
	    compLogMessage ("composite", CompLogLevelFatal, "unreachable section");
1232
514
	    assert (false);
1233
515
	    abort ();
1234
516
    }
1235
517
1236
518
    assert (currentDamage);
1237
519
    return currentDamage;
1238
520
}
1239
521
1240
477
void
522
void
1241
478
CompositeScreen::damageScreen ()
523
CompositeScreen::damageScreen ()
1242
479
{
524
{
1243
525
    /* Don't tell plugins about damage events when the damage buffer is already full */
1244
480
    bool alreadyDamaged = priv->damageMask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK;
526
    bool alreadyDamaged = priv->damageMask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK;
1245
527
    alreadyDamaged |= ((currentDamage () & screen->region ()) == screen->region ());
1246
481
528
1247
482
    priv->damageMask |= COMPOSITE_SCREEN_DAMAGE_ALL_MASK;
529
    priv->damageMask |= COMPOSITE_SCREEN_DAMAGE_ALL_MASK;
1248
483
    priv->damageMask &= ~COMPOSITE_SCREEN_DAMAGE_REGION_MASK;
530
    priv->damageMask &= ~COMPOSITE_SCREEN_DAMAGE_REGION_MASK;
1249
484
531
1251
485
    priv->scheduleRepaint ();
532
    if (priv->damageRequiresRepaintReschedule)
1252
533
	priv->scheduleRepaint ();
1253
486
534
1254
487
    /*
535
    /*
1255
488
     * Call through damageRegion since plugins listening for incoming damage
536
     * Call through damageRegion since plugins listening for incoming damage
1256
489
     * may need to know that the whole screen was redrawn
537
     * may need to know that the whole screen was redrawn
1257
490
     */
538
     */
1258
491
    if (!alreadyDamaged)
539
    if (!alreadyDamaged)
1259
540
    {
1260
492
	damageRegion (CompRegion (0, 0, screen->width (), screen->height ()));
541
	damageRegion (CompRegion (0, 0, screen->width (), screen->height ()));
1261
542
1262
543
	/* Set the damage region as the fullscreen region, because if
1263
544
	 * windows are unredirected we need to correctly subtract from
1264
545
	 * it later
1265
546
	 */
1266
547
	priv->damageTrackedBuffer (screen->region ());
1267
548
    }
1268
493
}
549
}
1269
494
550
1270
495
void
551
void
1271
@@ -500,7 +556,12 @@
1272
500
    if (priv->damageMask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK)
556
    if (priv->damageMask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK)
1273
501
	return;
557
	return;
1274
502
558
1276
503
    priv->damage += region;
559
    /* Don't cause repaints to be scheduled for empty damage
1277
560
     * regions */
1278
561
    if (region.isEmpty ())
1279
562
        return;
1280
563
1281
564
    const CompRegion *currentDamage = priv->damageTrackedBuffer (region);
1282
504
    priv->damageMask |= COMPOSITE_SCREEN_DAMAGE_REGION_MASK;
565
    priv->damageMask |= COMPOSITE_SCREEN_DAMAGE_REGION_MASK;
1283
505
566
1284
506
    /* If the number of damage rectangles grows two much between repaints,
567
    /* If the number of damage rectangles grows two much between repaints,
1285
@@ -509,17 +570,61 @@
1286
509
     * the whole screen if we have a lot of damage rects
570
     * the whole screen if we have a lot of damage rects
1287
510
     */
571
     */
1288
511
572
1290
512
    if (priv->damage.numRects () > 100)
573
    if (currentDamage->numRects () > 100)
1291
513
	damageScreen ();
574
	damageScreen ();
1292
514
575
1294
515
    priv->scheduleRepaint ();
576
    if (priv->damageRequiresRepaintReschedule)
1295
577
	priv->scheduleRepaint ();
1296
578
}
1297
579
1298
580
void
1299
581
CompositeScreen::damageCutoff ()
1300
582
{
1301
583
    WRAPABLE_HND_FUNCTN (damageCutoff);
1302
516
}
584
}
1303
517
585
1304
518
void
586
void
1305
519
CompositeScreen::damagePending ()
587
CompositeScreen::damagePending ()
1306
520
{
588
{
1307
521
    priv->damageMask |= COMPOSITE_SCREEN_DAMAGE_PENDING_MASK;
589
    priv->damageMask |= COMPOSITE_SCREEN_DAMAGE_PENDING_MASK;
1309
522
    priv->scheduleRepaint ();
590
1310
591
    if (priv->damageRequiresRepaintReschedule)
1311
592
	priv->scheduleRepaint ();
1312
593
}
1313
594
1314
595
void
1315
596
CompositeScreen::applyDamageForFrameAge (unsigned int age)
1316
597
{
1317
598
    /* Track into "last frame damage" */
1318
599
    priv->currentlyTrackingDamage = DamageForLastFrame;
1319
600
    damageRegion (priv->roster.damageForFrameAge (age));
1320
601
    priv->currentlyTrackingDamage = DamageForCurrentFrame;
1321
602
}
1322
603
1323
604
unsigned int
1324
605
CompositeScreen::getFrameAge ()
1325
606
{
1326
607
    if (priv->pHnd)
1327
608
	return priv->pHnd->getFrameAge ();
1328
609
1329
610
    return 1;
1330
611
}
1331
612
1332
613
void
1333
614
CompositeScreen::addOverdrawDamageRegion (const CompRegion &r)
1334
615
{
1335
616
    priv->ageingBuffers.markAreaDirtyOnLastFrame (r);
1336
617
}
1337
618
1338
619
typedef CompositeScreen::AreaShouldBeMarkedDirty ShouldMarkDirty;
1339
620
1340
621
CompositeScreen::DamageQuery::Ptr
1341
622
CompositeScreen::getDamageQuery (const ShouldMarkDirty &callback)
1342
623
{
1343
624
    /* No initial damage */
1344
625
    return bt::FrameRoster::Ptr (new bt::FrameRoster (CompSize (),
1345
626
						      priv->ageingBuffers,
1346
627
						      callback));
1347
523
}
628
}
1348
524
629
1349
525
unsigned int
630
unsigned int
1350
@@ -758,6 +863,12 @@
1351
758
863
1352
759
    if (priv->damageMask)
864
    if (priv->damageMask)
1353
760
    {
865
    {
1354
866
	int         timeDiff;
1355
867
1356
868
	/* Damage that accumulates here does not require a repaint reschedule
1357
869
	 * as it will end up on this frame */
1358
870
	priv->damageRequiresRepaintReschedule = false;
1359
871
1360
761
	if (priv->pHnd)
872
	if (priv->pHnd)
1361
762
	    priv->pHnd->prepareDrawing ();
873
	    priv->pHnd->prepareDrawing ();
1362
763
874
1363
@@ -792,7 +903,7 @@
1364
792
		    continue;
903
		    continue;
1365
793
904
1366
794
		if (!CompositeWindow::get (w)->redirected ())
905
		if (!CompositeWindow::get (w)->redirected ())
1368
795
		    priv->damage -= w->region ();
906
		    priv->ageingBuffers.subtractObscuredArea (w->region ());
1369
796
907
1370
797
		break;
908
		break;
1371
798
	    }
909
	    }
1372
@@ -804,7 +915,13 @@
1373
804
	    }
915
	    }
1374
805
	}
916
	}
1375
806
917
1377
807
	priv->tmpRegion = priv->damage & screen->region ();
918
	/* All further damage is for the next frame now, as
1378
919
	 * priv->tmpRegion will be assigned. Notify plugins that do
1379
920
	 * damage tracking of this */
1380
921
	damageCutoff ();
1381
922
1382
923
	priv->tmpRegion = (priv->roster.currentFrameDamage () + priv->lastFrameDamage) & screen->region ();
1383
924
	priv->currentlyTrackingDamage = DamageFinalPaintRegion;
1384
808
925
1385
809
	if (priv->damageMask & COMPOSITE_SCREEN_DAMAGE_REGION_MASK &&
926
	if (priv->damageMask & COMPOSITE_SCREEN_DAMAGE_REGION_MASK &&
1386
810
	    priv->tmpRegion == screen->region ())
927
	    priv->tmpRegion == screen->region ())
1387
@@ -826,7 +943,9 @@
1388
826
	XSync (dpy, False);
943
	XSync (dpy, False);
1389
827
	priv->damages.clear ();
944
	priv->damages.clear ();
1390
828
945
1392
829
	priv->damage = CompRegion ();
946
	/* Any more damage requires a repaint reschedule */
1393
947
	priv->damageRequiresRepaintReschedule = true;
1394
948
	priv->lastFrameDamage = CompRegion ();
1395
830
949
1396
831
	int mask = priv->damageMask;
950
	int mask = priv->damageMask;
1397
832
	priv->damageMask = 0;
951
	priv->damageMask = 0;
1398
@@ -844,9 +963,13 @@
1399
844
	else
963
	else
1400
845
	    outputs.push_back (&screen->fullscreenOutput ());
964
	    outputs.push_back (&screen->fullscreenOutput ());
1401
846
965
1402
966
	priv->currentlyTrackingDamage = DamageForCurrentFrame;
1403
967
1404
968
	/* All new damage goes on the next frame */
1405
969
	priv->ageingBuffers.incrementAges ();
1406
970
1407
847
	paint (outputs, mask);
971
	paint (outputs, mask);
1408
848
972
1409
849
1410
850
	donePaint ();
973
	donePaint ();
1411
851
974
1412
852
	priv->outputShapeChanged = false;
975
	priv->outputShapeChanged = false;
1413
@@ -1003,8 +1126,12 @@
1414
1003
CompositeScreenInterface::damageRegion (const CompRegion &r)
1126
CompositeScreenInterface::damageRegion (const CompRegion &r)
1415
1004
    WRAPABLE_DEF (damageRegion, r);
1127
    WRAPABLE_DEF (damageRegion, r);
1416
1005
1128
1417
1129
void
1418
1130
CompositeScreenInterface::damageCutoff ()
1419
1131
    WRAPABLE_DEF (damageCutoff);
1420
1132
1421
1006
const CompRegion &
1133
const CompRegion &
1422
1007
CompositeScreen::currentDamage () const
1134
CompositeScreen::currentDamage () const
1423
1008
{
1135
{
1425
1009
    return priv->damage;
1136
    return priv->roster.currentFrameDamage ();
1426
1010
}
1137
}
1427
1011
1138
1428
=== modified file 'plugins/kdecompat/src/kdecompat.cpp'
1429
--- plugins/kdecompat/src/kdecompat.cpp	2012-08-14 06:33:22 +0000
1430
+++ plugins/kdecompat/src/kdecompat.cpp	2013-04-24 14:57:28 +0000
1431
@@ -196,7 +196,7 @@
1432
196
    if ((!(ks->optionGetPlasmaThumbnails () || mPreviews.empty ()) &&
196
    if ((!(ks->optionGetPlasmaThumbnails () || mPreviews.empty ()) &&
1433
197
        !(mSlideData || mSlideData->remaining)) ||
197
        !(mSlideData || mSlideData->remaining)) ||
1434
198
	!window->mapNum ()                ||
198
	!window->mapNum ()                ||
1436
199
	(mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK))
199
	(mask & PAINT_WINDOW_NO_DRAW_MASKS))
1437
200
    {
200
    {
1438
201
	status = gWindow->glPaint (attrib, transform, region, mask);
201
	status = gWindow->glPaint (attrib, transform, region, mask);
1439
202
	return status;
202
	return status;
1440
@@ -210,7 +210,7 @@
1441
210
	CompRect           clipBox (window->x (), window->y (),
210
	CompRect           clipBox (window->x (), window->y (),
1442
211
				    window->width (), window->height ());
211
				    window->width (), window->height ());
1443
212
212
1445
213
	if (mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK)
213
	if (mask & PAINT_WINDOW_NO_DRAW_MASKS)
1446
214
	    return false;
214
	    return false;
1447
215
215
1448
216
	remainder = (float) data->remaining / data->duration;
216
	remainder = (float) data->remaining / data->duration;
1449
217
217
1450
=== modified file 'plugins/opengl/include/opengl/opengl.h'
1451
--- plugins/opengl/include/opengl/opengl.h	2013-01-10 09:23:24 +0000
1452
+++ plugins/opengl/include/opengl/opengl.h	2013-04-24 14:57:28 +0000
1453
@@ -37,6 +37,13 @@
1454
37
#else
37
#else
1455
38
#include <GL/gl.h>
38
#include <GL/gl.h>
1456
39
#include <GL/glx.h>
39
#include <GL/glx.h>
1457
40
1458
41
/* Some implementations have not yet given a definition
1459
42
 * to GLX_BACK_BUFFER_AGE_EXT but this is the token as defined
1460
43
 * in the spec (https://www.opengl.org/registry/specs/EXT/glx_buffer_age.txt)
1461
44
 */
1462
45
#define GLX_BACK_BUFFER_AGE_EXT 0x20F4
1463
46
1464
40
#endif
47
#endif
1465
41
48
1466
42
#include <core/size.h>
49
#include <core/size.h>
1467
@@ -50,7 +57,7 @@
1468
50
#include <opengl/programcache.h>
57
#include <opengl/programcache.h>
1469
51
#include <opengl/shadercache.h>
58
#include <opengl/shadercache.h>
1470
52
59
1472
53
#define COMPIZ_OPENGL_ABI 6
60
#define COMPIZ_OPENGL_ABI 8
1473
54
61
1474
55
/*
62
/*
1475
56
 * Some plugins check for #ifdef USE_MODERN_COMPIZ_GL. Support it for now, but
63
 * Some plugins check for #ifdef USE_MODERN_COMPIZ_GL. Support it for now, but
1476
@@ -525,6 +532,7 @@
1477
525
    extern bool  shaders;
532
    extern bool  shaders;
1478
526
    extern bool  stencilBuffer;
533
    extern bool  stencilBuffer;
1479
527
    extern GLint maxTextureUnits;
534
    extern GLint maxTextureUnits;
1480
535
    extern bool  bufferAge;
1481
528
536
1482
529
    extern bool canDoSaturated;
537
    extern bool canDoSaturated;
1483
530
    extern bool canDoSlightlySaturated;
538
    extern bool canDoSlightlySaturated;
1484
@@ -663,6 +671,11 @@
1485
663
					      unsigned int         mask);
671
					      unsigned int         mask);
1486
664
672
1487
665
	/**
673
	/**
1488
674
	 * Return true if glPaintCompositedOutput is required for this frame
1489
675
	 */
1490
676
	virtual bool glPaintCompositedOutputRequired ();
1491
677
1492
678
	/**
1493
666
	 * Hookable function used by plugins to determine stenciling mask
679
	 * Hookable function used by plugins to determine stenciling mask
1494
667
	 */
680
	 */
1495
668
	virtual void glBufferStencil (const GLMatrix       &matrix,
681
	virtual void glBufferStencil (const GLMatrix       &matrix,
1496
@@ -674,7 +687,7 @@
1497
674
extern template class PluginClassHandler<GLScreen, CompScreen, COMPIZ_OPENGL_ABI>;
687
extern template class PluginClassHandler<GLScreen, CompScreen, COMPIZ_OPENGL_ABI>;
1498
675
688
1499
676
class GLScreen :
689
class GLScreen :
1501
677
    public WrapableHandler<GLScreenInterface, 8>,
690
    public WrapableHandler<GLScreenInterface, 9>,
1502
678
    public PluginClassHandler<GLScreen, CompScreen, COMPIZ_OPENGL_ABI>,
691
    public PluginClassHandler<GLScreen, CompScreen, COMPIZ_OPENGL_ABI>,
1503
679
    public CompOption::Class
692
    public CompOption::Class
1504
680
{
693
{
1505
@@ -788,7 +801,9 @@
1506
788
	WRAPABLE_HND (6, GLScreenInterface, void, glPaintCompositedOutput,
801
	WRAPABLE_HND (6, GLScreenInterface, void, glPaintCompositedOutput,
1507
789
		      const CompRegion &, GLFramebufferObject *, unsigned int);
802
		      const CompRegion &, GLFramebufferObject *, unsigned int);
1508
790
803
1510
791
	WRAPABLE_HND (7, GLScreenInterface, void, glBufferStencil, const GLMatrix &,
804
	WRAPABLE_HND (7, GLScreenInterface, bool, glPaintCompositedOutputRequired);
1511
805
1512
806
	WRAPABLE_HND (8, GLScreenInterface, void, glBufferStencil, const GLMatrix &,
1513
792
		      GLVertexBuffer &,
807
		      GLVertexBuffer &,
1514
793
		      CompOutput *);
808
		      CompOutput *);
1515
794
809
1516
795
810
1517
=== modified file 'plugins/opengl/src/paint.cpp'
1518
--- plugins/opengl/src/paint.cpp	2013-01-03 16:05:26 +0000
1519
+++ plugins/opengl/src/paint.cpp	2013-04-24 14:57:28 +0000
1520
@@ -418,11 +418,6 @@
1521
418
	if (w->destroyed ())
418
	if (w->destroyed ())
1522
419
	    continue;
419
	    continue;
1523
420
420
1524
421
        gw = GLWindow::get (w);
1525
422
1526
423
        /* Release any queued ConfigureWindow requests now */
1527
424
        gw->priv->configureLock->release ();
1528
425
1529
426
	if (unredirected.find (w) != unredirected.end ())
421
	if (unredirected.find (w) != unredirected.end ())
1530
427
	    continue;
422
	    continue;
1531
428
423
1532
@@ -432,6 +427,8 @@
1533
432
		continue;
427
		continue;
1534
433
	}
428
	}
1535
434
429
1536
430
	gw = GLWindow::get (w);
1537
431
1538
435
	const CompRegion &clip =
432
	const CompRegion &clip =
1539
436
	    (!(mask & PAINT_SCREEN_NO_OCCLUSION_DETECTION_MASK)) ?
433
	    (!(mask & PAINT_SCREEN_NO_OCCLUSION_DETECTION_MASK)) ?
1540
437
	    gw->clip () : region;
434
	    gw->clip () : region;
1541
@@ -629,8 +626,8 @@
1542
629
	    if (mask & PAINT_SCREEN_FULL_MASK)
626
	    if (mask & PAINT_SCREEN_FULL_MASK)
1543
630
	    {
627
	    {
1544
631
		glPaintTransformedOutput (sAttrib, sTransform,
628
		glPaintTransformedOutput (sAttrib, sTransform,
1547
632
					  CompRegion (*output), output, mask);
629
					  CompRegionRef (output->region ()), output, mask);
1548
633
630
		priv->cScreen->addOverdrawDamageRegion (CompRegionRef (output->region ()));
1549
634
		return true;
631
		return true;
1550
635
	    }
632
	    }
1551
636
633
1552
@@ -660,8 +657,9 @@
1553
660
    }
657
    }
1554
661
    else if (mask & PAINT_SCREEN_FULL_MASK)
658
    else if (mask & PAINT_SCREEN_FULL_MASK)
1555
662
    {
659
    {
1557
663
	glPaintTransformedOutput (sAttrib, sTransform, CompRegion (*output),
660
        glPaintTransformedOutput (sAttrib, sTransform, CompRegionRef (output->region ()),
1558
664
				  output, mask);
661
				  output, mask);
1559
662
	priv->cScreen->addOverdrawDamageRegion (CompRegionRef (output->region ()));
1560
665
663
1561
666
	return true;
664
	return true;
1562
667
    }
665
    }
1563
@@ -671,6 +669,13 @@
1564
671
    }
669
    }
1565
672
}
670
}
1566
673
671
1567
672
bool
1568
673
GLScreen::glPaintCompositedOutputRequired ()
1569
674
{
1570
675
    WRAPABLE_HND_FUNCTN_RETURN (bool, glPaintCompositedOutputRequired);
1571
676
    return false;
1572
677
}
1573
678
1574
674
void
679
void
1575
675
GLScreen::glPaintCompositedOutput (const CompRegion    &region,
680
GLScreen::glPaintCompositedOutput (const CompRegion    &region,
1576
676
				   GLFramebufferObject *fbo,
681
				   GLFramebufferObject *fbo,
1577
677
682
1578
=== modified file 'plugins/opengl/src/privates.h'
1579
--- plugins/opengl/src/privates.h	2013-01-03 16:05:26 +0000
1580
+++ plugins/opengl/src/privates.h	2013-04-24 14:57:28 +0000
1581
@@ -29,11 +29,13 @@
1582
29
#define _OPENGL_PRIVATES_H
29
#define _OPENGL_PRIVATES_H
1583
30
30
1584
31
#include <memory>
31
#include <memory>
1585
32
#include <vector>
1586
33
#include <tr1/tuple>
1587
34
#include <boost/shared_ptr.hpp>
1588
32
35
1589
33
#include <composite/composite.h>
36
#include <composite/composite.h>
1590
34
#include <opengl/opengl.h>
37
#include <opengl/opengl.h>
1591
35
#include <core/atoms.h>
38
#include <core/atoms.h>
1592
36
#include <core/configurerequestbuffer.h>
1593
37
39
1594
38
#ifdef USE_GLES
40
#ifdef USE_GLES
1595
39
#include <opengl/framebufferobject.h>
41
#include <opengl/framebufferobject.h>
1596
@@ -120,8 +122,26 @@
1597
120
	GLTexture::List textures;
122
	GLTexture::List textures;
1598
121
};
123
};
1599
122
124
1600
125
class FrameProvider
1601
126
{
1602
127
    public:
1603
128
1604
129
	typedef boost::shared_ptr <FrameProvider> Ptr;
1605
130
	typedef std::tr1::tuple <GLFramebufferObject *, int> Frame;
1606
131
1607
132
	virtual ~FrameProvider () {}
1608
133
1609
134
	virtual GLuint getCurrentFrame () = 0;
1610
135
	virtual void endFrame () = 0;
1611
136
1612
137
	virtual bool providesPersistence () = 0;
1613
138
	virtual bool alwaysPostprocess () = 0;
1614
139
	virtual void invalidateAll () = 0;
1615
140
};
1616
141
1617
123
class PrivateGLScreen :
142
class PrivateGLScreen :
1618
124
    public ScreenInterface,
143
    public ScreenInterface,
1619
144
    public CompositeScreenInterface,
1620
125
    public compiz::composite::PaintHandler,
145
    public compiz::composite::PaintHandler,
1621
126
    public OpenglOptions
146
    public OpenglOptions
1622
127
{
147
{
1623
@@ -142,12 +162,17 @@
1624
142
	bool hasVSync ();
162
	bool hasVSync ();
1625
143
	bool requiredForcedRefreshRate ();
163
	bool requiredForcedRefreshRate ();
1626
144
164
1627
165
	unsigned int getFrameAge ();
1628
166
1629
145
	void updateRenderMode ();
167
	void updateRenderMode ();
1630
168
	void updateFrameProvider ();
1631
146
169
1632
147
	void prepareDrawing ();
170
	void prepareDrawing ();
1633
148
171
1634
149
	bool compositingActive ();
172
	bool compositingActive ();
1635
150
173
1636
174
	void damageCutoff ();
1637
175
1638
151
	void paintBackground (const GLMatrix   &transform,
176
	void paintBackground (const GLMatrix   &transform,
1639
152
	                      const CompRegion &region,
177
	                      const CompRegion &region,
1640
153
			      bool             transformed);
178
			      bool             transformed);
1641
@@ -163,6 +188,8 @@
1642
163
188
1643
164
	bool driverIsBlacklisted (const char *regex) const;
189
	bool driverIsBlacklisted (const char *regex) const;
1644
165
190
1645
191
	bool postprocessRequiredForCurrentFrame ();
1646
192
1647
166
    public:
193
    public:
1648
167
194
1649
168
	GLScreen        *gScreen;
195
	GLScreen        *gScreen;
1650
@@ -197,7 +224,7 @@
1651
197
	GLXDoubleBuffer doubleBuffer;
224
	GLXDoubleBuffer doubleBuffer;
1652
198
	#endif
225
	#endif
1653
199
226
1655
200
	GLFramebufferObject *scratchFbo;
227
	boost::shared_ptr <GLFramebufferObject> scratchFbo;
1656
201
	CompRegion outputRegion;
228
	CompRegion outputRegion;
1657
202
229
1658
203
	XRectangle lastViewport;
230
	XRectangle lastViewport;
1659
@@ -222,8 +249,10 @@
1660
222
	Pixmap rootPixmapCopy;
249
	Pixmap rootPixmapCopy;
1661
223
	CompSize rootPixmapSize;
250
	CompSize rootPixmapSize;
1662
224
251
1663
252
	FrameProvider::Ptr frameProvider;
1664
225
	const char *glVendor, *glRenderer, *glVersion;
253
	const char *glVendor, *glRenderer, *glVersion;
1665
226
254
1666
255
	bool postprocessingRequired;
1667
227
	mutable CompString prevRegex;
256
	mutable CompString prevRegex;
1668
228
	mutable bool       prevBlacklisted;
257
	mutable bool       prevBlacklisted;
1669
229
};
258
};
1670
@@ -284,8 +313,6 @@
1671
284
	GLVertexBuffer::AutoProgram *autoProgram;
313
	GLVertexBuffer::AutoProgram *autoProgram;
1672
285
314
1673
286
	std::list<GLIcon> icons;
315
	std::list<GLIcon> icons;
1674
287
1675
288
	compiz::window::configure_buffers::Releasable::Ptr configureLock;
1676
289
};
316
};
1677
290
317
1678
291
#endif
318
#endif
1679
292
319
1680
=== modified file 'plugins/opengl/src/screen.cpp'
1681
--- plugins/opengl/src/screen.cpp	2013-01-09 10:57:03 +0000
1682
+++ plugins/opengl/src/screen.cpp	2013-04-24 14:57:28 +0000
1683
@@ -186,6 +186,7 @@
1684
186
    bool  vboEnabled = false;
186
    bool  vboEnabled = false;
1685
187
    bool  shaders = false;
187
    bool  shaders = false;
1686
188
    GLint maxTextureUnits = 1;
188
    GLint maxTextureUnits = 1;
1687
189
    bool  bufferAge = false;
1688
189
190
1689
190
    bool canDoSaturated = false;
191
    bool canDoSaturated = false;
1690
191
    bool canDoSlightlySaturated = false;
192
    bool canDoSlightlySaturated = false;
1691
@@ -301,6 +302,52 @@
1692
301
302
1693
302
#ifndef USE_GLES
303
#ifndef USE_GLES
1694
303
304
1695
305
class BufferAgeFrameProvider :
1696
306
    public FrameProvider
1697
307
{
1698
308
    public:
1699
309
1700
310
	BufferAgeFrameProvider (Display     *disp,
1701
311
				GLXDrawable drawable) :
1702
312
	    mDisplay (disp),
1703
313
	    mDrawable (drawable)
1704
314
	{
1705
315
	}
1706
316
1707
317
	unsigned int getCurrentFrame ()
1708
318
	{
1709
319
	    unsigned int age = 0;
1710
320
	    (*GL::queryDrawable) (mDisplay,
1711
321
				  mDrawable,
1712
322
				  GLX_BACK_BUFFER_AGE_EXT,
1713
323
				  &age);
1714
324
	    return age;
1715
325
	}
1716
326
1717
327
	void endFrame ()
1718
328
	{
1719
329
	}
1720
330
1721
331
	void invalidateAll ()
1722
332
	{
1723
333
	}
1724
334
1725
335
	bool providesPersistence ()
1726
336
	{
1727
337
	    return true;
1728
338
	}
1729
339
1730
340
	bool alwaysPostprocess ()
1731
341
	{
1732
342
	    return false;
1733
343
	}
1734
344
1735
345
    private:
1736
346
1737
347
	Display *mDisplay;
1738
348
	GLXDrawable mDrawable;
1739
349
};
1740
350
1741
304
namespace compiz
351
namespace compiz
1742
305
{
352
{
1743
306
namespace opengl
353
namespace opengl
1744
@@ -358,6 +405,137 @@
1745
358
405
1746
359
#endif
406
#endif
1747
360
407
1748
408
class UndefinedFrameProvider :
1749
409
    public FrameProvider
1750
410
{
1751
411
    public:
1752
412
1753
413
	unsigned int getCurrentFrame ()
1754
414
	{
1755
415
	    return 0;
1756
416
	}
1757
417
1758
418
	void endFrame ()
1759
419
	{
1760
420
	}
1761
421
1762
422
	void invalidateAll ()
1763
423
	{
1764
424
	}
1765
425
1766
426
	bool providesPersistence ()
1767
427
	{
1768
428
	    return false;
1769
429
	}
1770
430
1771
431
	bool alwaysPostprocess ()
1772
432
	{
1773
433
	    return false;
1774
434
	}
1775
435
};
1776
436
1777
437
class PostprocessFrameProvider :
1778
438
    public FrameProvider
1779
439
{
1780
440
    public:
1781
441
1782
442
	PostprocessFrameProvider (GLFramebufferObject *object) :
1783
443
	    mObject (object),
1784
444
	    mAge (0)
1785
445
	{
1786
446
	}
1787
447
1788
448
	unsigned int getCurrentFrame ()
1789
449
	{
1790
450
	    /* We are now using this buffer, reset
1791
451
	     * age back to zero */
1792
452
	    unsigned int lastAge = mAge;
1793
453
	    mAge = 0;
1794
454
1795
455
	    return lastAge;
1796
456
	}
1797
457
1798
458
	void endFrame ()
1799
459
	{
1800
460
	    ++mAge;
1801
461
	}
1802
462
1803
463
	void invalidateAll ()
1804
464
	{
1805
465
	    mAge = 0;
1806
466
	}
1807
467
1808
468
	bool providesPersistence ()
1809
469
	{
1810
470
	    return true;
1811
471
	}
1812
472
1813
473
	bool alwaysPostprocess ()
1814
474
	{
1815
475
	    return true;
1816
476
	}
1817
477
1818
478
    private:
1819
479
1820
480
	GLFramebufferObject *mObject;
1821
481
	unsigned int        mAge;
1822
482
};
1823
483
1824
484
class OptionalPostprocessFrameProvider :
1825
485
    public FrameProvider
1826
486
{
1827
487
    public:
1828
488
1829
489
	typedef boost::function <bool ()> PostprocessRequired;
1830
490
1831
491
	OptionalPostprocessFrameProvider (const FrameProvider::Ptr  &backbuffer,
1832
492
					  const FrameProvider::Ptr  &scratchbuffer,
1833
493
					  const PostprocessRequired &ppRequired) :
1834
494
	    mBackbuffer (backbuffer),
1835
495
	    mScratchbuffer (scratchbuffer),
1836
496
	    mPPRequired (ppRequired)
1837
497
	{
1838
498
	}
1839
499
1840
500
	unsigned int getCurrentFrame ()
1841
501
	{
1842
502
	    if (mPPRequired ())
1843
503
		return mScratchbuffer->getCurrentFrame ();
1844
504
	    else
1845
505
		return mBackbuffer->getCurrentFrame ();
1846
506
	}
1847
507
1848
508
	void endFrame ()
1849
509
	{
1850
510
	    mScratchbuffer->endFrame ();
1851
511
	}
1852
512
1853
513
	void invalidateAll ()
1854
514
	{
1855
515
	    mScratchbuffer->invalidateAll ();
1856
516
	}
1857
517
1858
518
	bool providesPersistence ()
1859
519
	{
1860
520
	    /* We are only as good as the backbuffer is */
1861
521
	    return mBackbuffer->providesPersistence ();
1862
522
	}
1863
523
1864
524
	bool alwaysPostprocess ()
1865
525
	{
1866
526
	    if (mPPRequired ())
1867
527
		return mScratchbuffer->alwaysPostprocess ();
1868
528
	    else
1869
529
		return mBackbuffer->alwaysPostprocess ();
1870
530
	}
1871
531
1872
532
    private:
1873
533
1874
534
	FrameProvider::Ptr mBackbuffer;
1875
535
	FrameProvider::Ptr mScratchbuffer;
1876
536
	PostprocessRequired mPPRequired;
1877
537
};
1878
538
1879
361
bool
539
bool
1880
362
GLScreen::glInitContext (XVisualInfo *visinfo)
540
GLScreen::glInitContext (XVisualInfo *visinfo)
1881
363
{
541
{
1882
@@ -593,6 +771,8 @@
1883
593
771
1884
594
    priv->incorrectRefreshRate = false;
772
    priv->incorrectRefreshRate = false;
1885
595
773
1886
774
    priv->frameProvider.reset (new PostprocessFrameProvider ());
1887
775
1888
596
    #else
776
    #else
1889
597
777
1890
598
    Display		 *dpy = screen->dpy ();
778
    Display		 *dpy = screen->dpy ();
1891
@@ -899,12 +1079,17 @@
1892
899
1079
1893
900
    if (GL::fboSupported)
1080
    if (GL::fboSupported)
1894
901
    {
1081
    {
1896
902
	priv->scratchFbo = new GLFramebufferObject;
1082
	priv->scratchFbo.reset (new GLFramebufferObject ());
1897
903
	priv->scratchFbo->allocate (*screen, NULL, GL_BGRA);
1083
	priv->scratchFbo->allocate (*screen, NULL, GL_BGRA);
1898
904
    }
1084
    }
1899
905
1085
1900
906
    GLVertexBuffer::streamingBuffer ()->setAutoProgram (priv->autoProgram);
1086
    GLVertexBuffer::streamingBuffer ()->setAutoProgram (priv->autoProgram);
1901
907
1087
1902
1088
    /* We need scratchFbo to be set before doing this, and it is common
1903
1089
     * to both the GLES and non-GLES codepaths, so using another #ifdef
1904
1090
     */
1905
1091
    priv->updateFrameProvider ();
1906
1092
1907
908
    return true;
1093
    return true;
1908
909
}
1094
}
1909
910
1095
1910
@@ -993,6 +1178,13 @@
1911
993
	return;
1178
	return;
1912
994
    }
1179
    }
1913
995
1180
1914
1181
    if (strstr (glxExtensions, "GLX_EXT_buffer_age"))
1915
1182
    {
1916
1183
	compLogMessage ("opengl", CompLogLevelInfo,
1917
1184
			"GLX_EXT_buffer_age is supported");
1918
1185
	GL::bufferAge = true;
1919
1186
    }
1920
1187
1921
996
    priv->getProcAddress = (GL::GLXGetProcAddressProc)
1188
    priv->getProcAddress = (GL::GLXGetProcAddressProc)
1922
997
	getProcAddress ("glXGetProcAddressARB");
1189
	getProcAddress ("glXGetProcAddressARB");
1923
998
    GL::bindTexImage = (GL::GLXBindTexImageProc)
1190
    GL::bindTexImage = (GL::GLXBindTexImageProc)
1924
@@ -1209,9 +1401,6 @@
1925
1209
	glXDestroyContext (screen->dpy (), priv->ctx);
1401
	glXDestroyContext (screen->dpy (), priv->ctx);
1926
1210
    #endif
1402
    #endif
1927
1211
1403
1928
1212
    if (priv->scratchFbo)
1929
1213
	delete priv->scratchFbo;
1930
1214
1931
1215
    delete priv;
1404
    delete priv;
1932
1216
}
1405
}
1933
1217
1406
1934
@@ -1233,7 +1422,7 @@
1935
1233
    ctx (EGL_NO_CONTEXT),
1422
    ctx (EGL_NO_CONTEXT),
1936
1234
    doubleBuffer (screen->dpy (), *screen, surface),
1423
    doubleBuffer (screen->dpy (), *screen, surface),
1937
1235
    #endif
1424
    #endif
1939
1236
    scratchFbo (NULL),
1425
    scratchFbo (),
1940
1237
    outputRegion (),
1426
    outputRegion (),
1941
1238
    refreshSubBuffer (false),
1427
    refreshSubBuffer (false),
1942
1239
    lastMask (0),
1428
    lastMask (0),
1943
@@ -1246,13 +1435,16 @@
1944
1246
    autoProgram (new GLScreenAutoProgram(gs)),
1435
    autoProgram (new GLScreenAutoProgram(gs)),
1945
1247
    rootPixmapCopy (None),
1436
    rootPixmapCopy (None),
1946
1248
    rootPixmapSize (),
1437
    rootPixmapSize (),
1947
1438
    frameProvider (),
1948
1249
    glVendor (NULL),
1439
    glVendor (NULL),
1949
1250
    glRenderer (NULL),
1440
    glRenderer (NULL),
1950
1251
    glVersion (NULL),
1441
    glVersion (NULL),
1951
1442
    postprocessingRequired (false),
1952
1252
    prevRegex (),
1443
    prevRegex (),
1953
1253
    prevBlacklisted (false)
1444
    prevBlacklisted (false)
1954
1254
{
1445
{
1955
1255
    ScreenInterface::setHandler (screen);
1446
    ScreenInterface::setHandler (screen);
1956
1447
    CompositeScreenInterface::setHandler (cScreen);
1957
1256
}
1448
}
1958
1257
1449
1959
1258
PrivateGLScreen::~PrivateGLScreen ()
1450
PrivateGLScreen::~PrivateGLScreen ()
1960
@@ -1443,8 +1635,11 @@
1961
1443
{
1635
{
1962
1444
    screen->outputChangeNotify ();
1636
    screen->outputChangeNotify ();
1963
1445
1637
1964
1638
    frameProvider->invalidateAll ();
1965
1639
1966
1446
    if (scratchFbo)
1640
    if (scratchFbo)
1967
1447
	scratchFbo->allocate (*screen, NULL, GL_BGRA);
1641
	scratchFbo->allocate (*screen, NULL, GL_BGRA);
1968
1642
1969
1448
    updateView ();
1643
    updateView ();
1970
1449
}
1644
}
1971
1450
1645
1972
@@ -1669,6 +1864,10 @@
1973
1669
GLScreenInterface::projectionMatrix ()
1864
GLScreenInterface::projectionMatrix ()
1974
1670
    WRAPABLE_DEF (projectionMatrix)
1865
    WRAPABLE_DEF (projectionMatrix)
1975
1671
1866
1976
1867
bool
1977
1868
GLScreenInterface::glPaintCompositedOutputRequired ()
1978
1869
    WRAPABLE_DEF (glPaintCompositedOutputRequired)
1979
1870
1980
1672
void
1871
void
1981
1673
GLScreenInterface::glPaintCompositedOutput (const CompRegion    &region,
1872
GLScreenInterface::glPaintCompositedOutput (const CompRegion    &region,
1982
1674
					    GLFramebufferObject *fbo,
1873
					    GLFramebufferObject *fbo,
1983
@@ -1977,18 +2176,6 @@
1984
1977
    glDepthMask (GL_FALSE);
2176
    glDepthMask (GL_FALSE);
1985
1978
    glStencilMask (0);
2177
    glStencilMask (0);
1986
1979
2178
1987
1980
    GLFramebufferObject *oldFbo = NULL;
1988
1981
    bool useFbo = false;
1989
1982
1990
1983
    /* Clear the color buffer where appropriate */
1991
1984
    if (GL::fboEnabled && scratchFbo)
1992
1985
    {
1993
1986
	oldFbo = scratchFbo->bind ();
1994
1987
	useFbo = scratchFbo->checkStatus () && scratchFbo->tex ();
1995
1988
	if (!useFbo)
1996
1989
	    GLFramebufferObject::rebind (oldFbo);
1997
1990
    }
1998
1991
1999
1992
#ifdef UNSAFE_ARM_SGX_FIXME
2179
#ifdef UNSAFE_ARM_SGX_FIXME
2000
1993
    refreshSubBuffer = ((lastMask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK) &&
2180
    refreshSubBuffer = ((lastMask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK) &&
2001
1994
                        !(mask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK) &&
2181
                        !(mask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK) &&
2002
@@ -2006,8 +2193,21 @@
2003
2006
    }
2193
    }
2004
2007
#endif
2194
#endif
2005
2008
2195
2008
2009
    CompRegion tmpRegion = (mask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK) ?
2196
    CompRegion paintRegion ((mask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK) ?
2009
2010
                           screen->region () : region;
2197
			     screen->region () : region);
2010
2198
    bool useFbo = false;
2011
2199
    GLFramebufferObject *oldFbo = NULL;
2012
2200
2013
2201
    postprocessingRequired = gScreen->glPaintCompositedOutputRequired ();
2014
2202
    postprocessingRequired |= frameProvider->alwaysPostprocess ();
2015
2203
2016
2204
    /* Clear the color buffer where appropriate */
2017
2205
    if ((GL::fboEnabled && postprocessRequiredForCurrentFrame ()))
2018
2206
    {
2019
2207
	oldFbo = scratchFbo->bind ();
2020
2208
	if (scratchFbo->checkStatus ())
2021
2209
	    useFbo = true;
2022
2210
    }
2023
2011
2211
2024
2012
    foreach (CompOutput *output, outputs)
2212
    foreach (CompOutput *output, outputs)
2025
2013
    {
2213
    {
2026
@@ -2034,7 +2234,8 @@
2027
2034
2234
2028
2035
	    gScreen->glPaintOutput (defaultScreenPaintAttrib,
2235
	    gScreen->glPaintOutput (defaultScreenPaintAttrib,
2029
2036
				    identity,
2236
				    identity,
2031
2037
				    CompRegion (*output), output,
2237
				    CompRegion (*output),
2032
2238
				    output,
2033
2038
				    PAINT_SCREEN_REGION_MASK |
2239
				    PAINT_SCREEN_REGION_MASK |
2034
2039
				    PAINT_SCREEN_FULL_MASK);
2240
				    PAINT_SCREEN_FULL_MASK);
2035
2040
	}
2241
	}
2036
@@ -2057,7 +2258,9 @@
2037
2057
		tmpRegion = CompRegion (*output);
2258
		tmpRegion = CompRegion (*output);
2038
2058
#endif
2259
#endif
2039
2059
2260
2041
2060
	    outputRegion = tmpRegion & CompRegion (*output);
2261
	    /* Clip current paint region to output extents */
2042
2262
	    CompRegionRef wholeOutput (output->region ());
2043
2263
	    outputRegion = (paintRegion & wholeOutput);
2044
2061
2264
2045
2062
	    if (!gScreen->glPaintOutput (defaultScreenPaintAttrib,
2265
	    if (!gScreen->glPaintOutput (defaultScreenPaintAttrib,
2046
2063
					 identity,
2266
					 identity,
2047
@@ -2068,10 +2271,11 @@
2048
2068
2271
2049
2069
		gScreen->glPaintOutput (defaultScreenPaintAttrib,
2272
		gScreen->glPaintOutput (defaultScreenPaintAttrib,
2050
2070
					identity,
2273
					identity,
2052
2071
					CompRegion (*output), output,
2274
					wholeOutput, output,
2053
2072
					PAINT_SCREEN_FULL_MASK);
2275
					PAINT_SCREEN_FULL_MASK);
2054
2073
2276
2056
2074
		tmpRegion += *output;
2277
		paintRegion += wholeOutput;
2057
2278
		cScreen->addOverdrawDamageRegion (wholeOutput);
2058
2075
	    }
2279
	    }
2059
2076
	}
2280
	}
2060
2077
    }
2281
    }
2061
@@ -2082,13 +2286,18 @@
2062
2082
2286
2063
2083
    if (useFbo)
2287
    if (useFbo)
2064
2084
    {
2288
    {
2065
2085
	GLFramebufferObject::rebind (oldFbo);
2066
2086
2067
2087
	// FIXME: does not work if screen dimensions exceed max texture size
2289
	// FIXME: does not work if screen dimensions exceed max texture size
2068
2088
	//        We should try to use glBlitFramebuffer instead.
2290
	//        We should try to use glBlitFramebuffer instead.
2070
2089
	gScreen->glPaintCompositedOutput (screen->region (), scratchFbo, mask);
2291
	GLFramebufferObject::rebind (oldFbo);
2071
2292
	/* If we must always postprocess, then we don't have any
2072
2293
	 * "real" backbuffer persistence, redraw the whole thing */
2073
2294
	gScreen->glPaintCompositedOutput (frameProvider->alwaysPostprocess () ?
2074
2295
					      screen->region () :
2075
2296
					      paintRegion, scratchFbo.get (), mask);
2076
2090
    }
2297
    }
2077
2091
2298
2078
2299
    frameProvider->endFrame ();
2079
2300
2080
2092
    if (cScreen->outputWindowChanged ())
2301
    if (cScreen->outputWindowChanged ())
2081
2093
    {
2302
    {
2082
2094
	/*
2303
	/*
2083
@@ -2100,20 +2309,27 @@
2084
2100
	return;
2309
	return;
2085
2101
    }
2310
    }
2086
2102
2311
2087
2312
    bool persistence = frameProvider->providesPersistence ();
2088
2103
    bool alwaysSwap = optionGetAlwaysSwapBuffers ();
2313
    bool alwaysSwap = optionGetAlwaysSwapBuffers ();
2090
2104
    bool fullscreen = useFbo ||
2314
    bool fullscreen = persistence ||
2091
2105
                      alwaysSwap ||
2315
                      alwaysSwap ||
2092
2106
                      ((mask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK) &&
2316
                      ((mask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK) &&
2093
2107
                       commonFrontbuffer);
2317
                       commonFrontbuffer);
2094
2108
2318
2095
2109
    doubleBuffer.set (DoubleBuffer::VSYNC, optionGetSyncToVblank ());
2319
    doubleBuffer.set (DoubleBuffer::VSYNC, optionGetSyncToVblank ());
2097
2110
    doubleBuffer.set (DoubleBuffer::HAVE_PERSISTENT_BACK_BUFFER, useFbo);
2320
    doubleBuffer.set (DoubleBuffer::HAVE_PERSISTENT_BACK_BUFFER, persistence);
2098
2111
    doubleBuffer.set (DoubleBuffer::NEED_PERSISTENT_BACK_BUFFER, alwaysSwap);
2321
    doubleBuffer.set (DoubleBuffer::NEED_PERSISTENT_BACK_BUFFER, alwaysSwap);
2100
2112
    doubleBuffer.render (tmpRegion, fullscreen);
2322
    doubleBuffer.render (paintRegion, fullscreen);
2101
2113
2323
2102
2114
    lastMask = mask;
2324
    lastMask = mask;
2103
2115
}
2325
}
2104
2116
2326
2105
2327
unsigned int
2106
2328
PrivateGLScreen::getFrameAge ()
2107
2329
{
2108
2330
    return frameProvider->getCurrentFrame ();
2109
2331
}
2110
2332
2111
2117
bool
2333
bool
2112
2118
PrivateGLScreen::hasVSync ()
2334
PrivateGLScreen::hasVSync ()
2113
2119
{
2335
{
2114
@@ -2138,6 +2354,13 @@
2115
2138
}
2354
}
2116
2139
2355
2117
2140
void
2356
void
2118
2357
PrivateGLScreen::damageCutoff ()
2119
2358
{
2120
2359
    cScreen->applyDamageForFrameAge (frameProvider->getCurrentFrame ());
2121
2360
    cScreen->damageCutoff ();
2122
2361
}
2123
2362
2124
2363
void
2125
2141
PrivateGLScreen::updateRenderMode ()
2364
PrivateGLScreen::updateRenderMode ()
2126
2142
{
2365
{
2127
2143
#ifndef USE_GLES
2366
#ifndef USE_GLES
2128
@@ -2147,12 +2370,54 @@
2129
2147
}
2370
}
2130
2148
2371
2131
2149
void
2372
void
2132
2373
PrivateGLScreen::updateFrameProvider ()
2133
2374
{
2134
2375
#ifndef USE_GLES
2135
2376
    const Window outputWindow = CompositeScreen::get (screen)->output ();
2136
2377
2137
2378
    if (GL::fboEnabled)
2138
2379
    {
2139
2380
	if (GL::bufferAge)
2140
2381
	{
2141
2382
	    FrameProvider::Ptr back (new BufferAgeFrameProvider (screen->dpy (),
2142
2383
								 outputWindow));
2143
2384
	    FrameProvider::Ptr scratch (new PostprocessFrameProvider (scratchFbo.get ()));
2144
2385
	    OptionalPostprocessFrameProvider::PostprocessRequired ppReq
2145
2386
		    (boost::bind (&PrivateGLScreen::postprocessRequiredForCurrentFrame,
2146
2387
				  this));
2147
2388
	    frameProvider.reset (new OptionalPostprocessFrameProvider (back,
2148
2389
								       scratch,
2149
2390
								       ppReq));
2150
2391
	}
2151
2392
	else
2152
2393
	{
2153
2394
	    /* Prefer using FBO's instead of switching between a defined/undefined backbuffer */
2154
2395
	    frameProvider.reset (new PostprocessFrameProvider (scratchFbo.get ()));
2155
2396
	}
2156
2397
    }
2157
2398
    else
2158
2399
    {
2159
2400
	if (GL::bufferAge)
2160
2401
	    frameProvider.reset (new BufferAgeFrameProvider (screen->dpy (),
2161
2402
								   outputWindow));
2162
2403
	else
2163
2404
	    frameProvider.reset (new UndefinedFrameProvider ());
2164
2405
    }
2165
2406
#else
2166
2407
    frameProvider.reset (new PostprocessFrameProvider (scratchFbo.get ()));
2167
2408
#endif
2168
2409
}
2169
2410
2170
2411
void
2171
2150
PrivateGLScreen::prepareDrawing ()
2412
PrivateGLScreen::prepareDrawing ()
2172
2151
{
2413
{
2173
2152
    bool wasFboEnabled = GL::fboEnabled;
2414
    bool wasFboEnabled = GL::fboEnabled;
2174
2153
    updateRenderMode ();
2415
    updateRenderMode ();
2175
2154
    if (wasFboEnabled != GL::fboEnabled)
2416
    if (wasFboEnabled != GL::fboEnabled)
2176
2417
    {
2177
2418
	updateFrameProvider ();
2178
2155
	CompositeScreen::get (screen)->damageScreen ();
2419
	CompositeScreen::get (screen)->damageScreen ();
2179
2420
    }
2180
2156
}
2421
}
2181
2157
2422
2182
2158
bool
2423
bool
2183
@@ -2170,6 +2435,12 @@
2184
2170
    return prevBlacklisted;
2435
    return prevBlacklisted;
2185
2171
}
2436
}
2186
2172
2437
2187
2438
bool
2188
2439
PrivateGLScreen::postprocessRequiredForCurrentFrame ()
2189
2440
{
2190
2441
    return postprocessingRequired;
2191
2442
}
2192
2443
2193
2173
GLTexture::BindPixmapHandle
2444
GLTexture::BindPixmapHandle
2194
2174
GLScreen::registerBindPixmap (GLTexture::BindPixmapProc proc)
2445
GLScreen::registerBindPixmap (GLTexture::BindPixmapProc proc)
2195
2175
{
2446
{
2196
@@ -2198,7 +2469,7 @@
2197
2198
GLFramebufferObject *
2469
GLFramebufferObject *
2198
2199
GLScreen::fbo ()
2470
GLScreen::fbo ()
2199
2200
{
2471
{
2201
2201
    return priv->scratchFbo;
2472
    return priv->scratchFbo.get ();
2202
2202
}
2473
}
2203
2203
2474
2204
2204
GLTexture *
2475
GLTexture *
2205
2205
2476
2206
=== modified file 'plugins/opengl/src/window.cpp'
2207
--- plugins/opengl/src/window.cpp	2013-01-03 16:05:26 +0000
2208
+++ plugins/opengl/src/window.cpp	2013-04-24 14:57:28 +0000
2209
@@ -86,8 +86,7 @@
2210
86
    bindFailed (false),
86
    bindFailed (false),
2211
87
    vertexBuffer (new GLVertexBuffer ()),
87
    vertexBuffer (new GLVertexBuffer ()),
2212
88
    autoProgram(new GLWindowAutoProgram(this)),
88
    autoProgram(new GLWindowAutoProgram(this)),
2215
89
    icons (),
89
    icons ()
2214
90
    configureLock (w->obtainLockOnConfigureRequests ())
2216
91
{
90
{
2217
92
    paint.xScale	= 1.0f;
91
    paint.xScale	= 1.0f;
2218
93
    paint.yScale	= 1.0f;
92
    paint.yScale	= 1.0f;
2219
94
93
2220
=== modified file 'plugins/place/src/place.cpp'
2221
--- plugins/place/src/place.cpp	2013-04-10 12:27:25 +0000
2222
+++ plugins/place/src/place.cpp	2013-04-24 14:57:28 +0000
2223
@@ -565,7 +565,7 @@
2224
565
	}
565
	}
2225
566
566
2226
567
	switch (mode) {
567
	switch (mode) {
2228
568
	    case PlaceOptions::ModeCascade:
568
	case PlaceOptions::ModeCascade:
2229
569
	    placeCascade (workArea, pos);
569
	    placeCascade (workArea, pos);
2230
570
	    break;
570
	    break;
2231
571
	case PlaceOptions::ModeCentered:
571
	case PlaceOptions::ModeCentered:
2232
@@ -1150,7 +1150,6 @@
2233
1150
                                           window->border (),
1150
                                           window->border (),
2234
1151
                                           workArea,
1151
                                           workArea,
2235
1152
                                           staticGravity);
1152
                                           staticGravity);
2236
1153
2237
1154
}
1153
}
2238
1155
1154
2239
1156
bool
1155
bool
2240
1157
1156
2241
=== modified file 'plugins/resize/src/resize.cpp'
2242
--- plugins/resize/src/resize.cpp	2012-10-19 09:23:11 +0000
2243
+++ plugins/resize/src/resize.cpp	2013-04-24 14:57:28 +0000
2244
@@ -257,7 +257,7 @@
2245
257
	float	       xScale, yScale;
257
	float	       xScale, yScale;
2246
258
	int            x, y;
258
	int            x, y;
2247
259
259
2249
260
	if (mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK)
260
	if (mask & PAINT_WINDOW_NO_DRAW_MASKS)
2250
261
	    return false;
261
	    return false;
2251
262
262
2252
263
	status = gWindow->glPaint (attrib, transform, region,
263
	status = gWindow->glPaint (attrib, transform, region,
2253
264
264
2254
=== modified file 'plugins/ring/src/ring.cpp'
2255
--- plugins/ring/src/ring.cpp	2013-01-19 11:47:22 +0000
2256
+++ plugins/ring/src/ring.cpp	2013-04-24 14:57:28 +0000
2257
@@ -264,7 +264,7 @@
2258
264
	    GLWindowPaintAttrib wAttrib (gWindow->lastPaintAttrib ());
264
	    GLWindowPaintAttrib wAttrib (gWindow->lastPaintAttrib ());
2259
265
	    GLMatrix           wTransform = transform;
265
	    GLMatrix           wTransform = transform;
2260
266
266
2262
267
	    if (mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK)
267
	    if (mask & PAINT_WINDOW_NO_DRAW_MASKS)
2263
268
		return false;
268
		return false;
2264
269
269
2265
270
	    if (mSlot)
270
	    if (mSlot)
2266
271
271
2267
=== modified file 'plugins/scale/src/scale.cpp'
2268
--- plugins/scale/src/scale.cpp	2013-01-29 23:16:32 +0000
2269
+++ plugins/scale/src/scale.cpp	2013-04-24 14:57:28 +0000
2270
@@ -384,12 +384,14 @@
2271
384
384
2272
385
	status = gWindow->glPaint (sAttrib, transform, region, mask);
385
	status = gWindow->glPaint (sAttrib, transform, region, mask);
2273
386
386
2274
387
	mask &= ~(PAINT_WINDOW_NO_CORE_INSTANCE_MASK);
2275
388
2276
387
	if (scaled)
389
	if (scaled)
2277
388
	{
390
	{
2278
389
	    GLWindowPaintAttrib lastAttrib (gWindow->lastPaintAttrib ());
391
	    GLWindowPaintAttrib lastAttrib (gWindow->lastPaintAttrib ());
2279
390
	    GLMatrix           wTransform (transform);
392
	    GLMatrix           wTransform (transform);
2280
391
393
2282
392
	    if (mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK)
394
	    if (mask & PAINT_WINDOW_NO_DRAW_MASKS)
2283
393
		return false;
395
		return false;
2284
394
396
2285
395
	    if (window->alpha () || lastAttrib.opacity != OPAQUE)
397
	    if (window->alpha () || lastAttrib.opacity != OPAQUE)
2286
396
398
2287
=== modified file 'plugins/staticswitcher/src/staticswitcher.cpp'
2288
--- plugins/staticswitcher/src/staticswitcher.cpp	2012-12-10 03:28:47 +0000
2289
+++ plugins/staticswitcher/src/staticswitcher.cpp	2013-04-24 14:57:28 +0000
2290
@@ -1246,7 +1246,7 @@
2291
1246
1246
2292
1247
	const CompWindow::Geometry &g = window->geometry ();
1247
	const CompWindow::Geometry &g = window->geometry ();
2293
1248
1248
2295
1249
	if (mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK ||
1249
	if (mask & PAINT_WINDOW_NO_DRAW_MASKS ||
2296
1250
	    sScreen->ignoreSwitcher)
1250
	    sScreen->ignoreSwitcher)
2297
1251
	    return false;
1251
	    return false;
2298
1252
1252
2299
1253
1253
2300
=== modified file 'plugins/switcher/src/switcher.cpp'
2301
--- plugins/switcher/src/switcher.cpp	2012-12-10 03:28:47 +0000
2302
+++ plugins/switcher/src/switcher.cpp	2013-04-24 14:57:28 +0000
2303
@@ -971,7 +971,7 @@
2304
971
971
2305
972
	const CompWindow::Geometry &g = window->geometry ();
972
	const CompWindow::Geometry &g = window->geometry ();
2306
973
973
2308
974
	if (mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK ||
974
	if (mask & PAINT_WINDOW_NO_DRAW_MASKS ||
2309
975
	    sScreen->ignoreSwitcher)
975
	    sScreen->ignoreSwitcher)
2310
976
	    return false;
976
	    return false;
2311
977
977
2312
978
978
2313
=== modified file 'plugins/td/src/3d.cpp'
2314
--- plugins/td/src/3d.cpp	2013-02-03 17:50:59 +0000
2315
+++ plugins/td/src/3d.cpp	2013-04-24 14:57:28 +0000
2316
@@ -163,7 +163,7 @@
2317
163
    glGetIntegerv (GL_CULL_FACE_MODE, &cull);
163
    glGetIntegerv (GL_CULL_FACE_MODE, &cull);
2318
164
    cullInv = (cull == GL_BACK)? GL_FRONT : GL_BACK;
164
    cullInv = (cull == GL_BACK)? GL_FRONT : GL_BACK;
2319
165
165
2321
166
    if (ww && wh && !(mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK) &&
166
    if (ww && wh && !(mask & PAINT_WINDOW_NO_DRAW_MASKS) &&
2322
167
	((cs->paintOrder () == FTB && mFtb) ||
167
	((cs->paintOrder () == FTB && mFtb) ||
2323
168
	(cs->paintOrder () == BTF && !mFtb)))
168
	(cs->paintOrder () == BTF && !mFtb)))
2324
169
    {
169
    {
2325
170
170
2326
=== modified file 'plugins/water/src/water.cpp'
2327
--- plugins/water/src/water.cpp	2013-01-28 19:45:04 +0000
2328
+++ plugins/water/src/water.cpp	2013-04-24 14:57:28 +0000
2329
@@ -317,6 +317,12 @@
2330
317
    }
317
    }
2331
318
}
318
}
2332
319
319
2333
320
bool
2334
321
WaterScreen::glPaintCompositedOutputRequired ()
2335
322
{
2336
323
    return true;
2337
324
}
2338
325
2339
320
void
326
void
2340
321
WaterScreen::glPaintCompositedOutput (const CompRegion    &region,
327
WaterScreen::glPaintCompositedOutput (const CompRegion    &region,
2341
322
                                      GLFramebufferObject *fbo,
328
                                      GLFramebufferObject *fbo,
2342
@@ -467,6 +473,7 @@
2343
467
	cScreen->preparePaintSetEnabled (this, false);
473
	cScreen->preparePaintSetEnabled (this, false);
2344
468
	gScreen->glPaintOutputSetEnabled (this, false);
474
	gScreen->glPaintOutputSetEnabled (this, false);
2345
469
	gScreen->glPaintCompositedOutputSetEnabled (this, false);
475
	gScreen->glPaintCompositedOutputSetEnabled (this, false);
2346
476
	gScreen->glPaintCompositedOutputRequiredSetEnabled (this, false);
2347
470
	cScreen->donePaintSetEnabled (this, false);
477
	cScreen->donePaintSetEnabled (this, false);
2348
471
    }
478
    }
2349
472
479
2350
473
480
2351
=== modified file 'plugins/water/src/water.h'
2352
--- plugins/water/src/water.h	2012-09-07 23:56:21 +0000
2353
+++ plugins/water/src/water.h	2013-04-24 14:57:28 +0000
2354
@@ -64,6 +64,7 @@
2355
64
64
2356
65
	void handleEvent (XEvent *);
65
	void handleEvent (XEvent *);
2357
66
66
2358
67
	bool glPaintCompositedOutputRequired ();
2359
67
	void glPaintCompositedOutput (const CompRegion    &region,
68
	void glPaintCompositedOutput (const CompRegion    &region,
2360
68
				      GLFramebufferObject *fbo,
69
				      GLFramebufferObject *fbo,
2361
69
				      unsigned int         mask);
70
				      unsigned int         mask);
2362
70
71
2363
=== modified file 'src/window.cpp'
2364
--- src/window.cpp	2013-03-27 01:55:26 +0000
2365
+++ src/window.cpp	2013-04-24 14:57:28 +0000
2366
@@ -3222,7 +3222,7 @@
2367
3222
    if (serverFrameGeometry.y () == xwc->y - serverGeometry.border () - serverInput.top)
3222
    if (serverFrameGeometry.y () == xwc->y - serverGeometry.border () - serverInput.top)
2368
3223
	frameValueMask &= ~(CWY);
3223
	frameValueMask &= ~(CWY);
2369
3224
3224
2371
3225
   if (serverFrameGeometry.width () == xwc->width + serverGeometry.border () * 2
3225
    if (serverFrameGeometry.width () == xwc->width + serverGeometry.border () * 2
2372
3226
				      + serverInput.left + serverInput.right)
3226
				      + serverInput.left + serverInput.right)
2373
3227
	frameValueMask &= ~(CWWidth);
3227
	frameValueMask &= ~(CWWidth);
2374
3228
3228
2375
@@ -6922,7 +6922,7 @@
2376
6922
     * but that's all */
6922
     * but that's all */
2377
6923
    XSelectInput (dpy, screen->root (), SubstructureNotifyMask);
6923
    XSelectInput (dpy, screen->root (), SubstructureNotifyMask);
2378
6924
6924
2380
6925
    /* Gravity here is assumed to be SouthEast, clients can update
6925
    /* Gravity here is assumed to be NorthWest, clients can update
2381
6926
     * that if need be */
6926
     * that if need be */
2382
6927
6927
2383
6928
    /* Awaiting a new frame to be given to us */
6928
    /* Awaiting a new frame to be given to us */
Status:	Superseded
Proposed branch:	lp:~compiz-team/compiz/compiz.fix_1024304.1
Merge into:	lp:compiz/0.9.10
Diff against target:	2383 lines (+1494/-88) 27 files modified plugins/animation/src/animation.cpp (+1/-1) plugins/composite/CMakeLists.txt (+6/-1) plugins/composite/include/composite/agedamagequery.h (+53/-0) plugins/composite/include/composite/composite.h (+49/-14) plugins/composite/src/backbuffertracking/CMakeLists.txt (+31/-0) plugins/composite/src/backbuffertracking/include/backbuffertracking.h (+125/-0) plugins/composite/src/backbuffertracking/src/backbuffertracking.cpp (+214/-0) plugins/composite/src/backbuffertracking/tests/CMakeLists.txt (+24/-0) plugins/composite/src/backbuffertracking/tests/test-composite-backbuffertracking.cpp (+450/-0) plugins/composite/src/privates.h (+18/-2) plugins/composite/src/screen.cpp (+138/-11) plugins/kdecompat/src/kdecompat.cpp (+2/-2) plugins/opengl/include/opengl/opengl.h (+18/-3) plugins/opengl/src/paint.cpp (+13/-8) plugins/opengl/src/privates.h (+31/-4) plugins/opengl/src/screen.cpp (+301/-30) plugins/opengl/src/window.cpp (+1/-2) plugins/place/src/place.cpp (+1/-2) plugins/resize/src/resize.cpp (+1/-1) plugins/ring/src/ring.cpp (+1/-1) plugins/scale/src/scale.cpp (+3/-1) plugins/staticswitcher/src/staticswitcher.cpp (+1/-1) plugins/switcher/src/switcher.cpp (+1/-1) plugins/td/src/3d.cpp (+1/-1) plugins/water/src/water.cpp (+7/-0) plugins/water/src/water.h (+1/-0) src/window.cpp (+2/-2)
To merge this branch:	bzr merge lp:~compiz-team/compiz/compiz.fix_1024304.1
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
PS Jenkins bot (community)	continuous-integration	2013-04-02	Approve on 2013-04-13
Andrea Azzarone		2013-04-02	Pending
Esokrates	testing, benchmarking	2013-04-02	Pending
Daniel van Vugt		2013-04-02	Pending
Timo Jyrinki	build&run	2013-04-02	Pending
Review via email: mp+156466@code.launchpad.net