1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_canvas.hxx"
26 
27 #include <canvas/debug.hxx>
28 #include <canvas/verbosetrace.hxx>
29 #include <canvas/canvastools.hxx>
30 #include <tools/diagnose_ex.h>
31 
32 #include <comphelper/scopeguard.hxx>
33 
34 #include <basegfx/range/b2drectangle.hxx>
35 #include <basegfx/tools/canvastools.hxx>
36 
37 #include <boost/cast.hpp>
38 
39 #include "dx_spritecanvashelper.hxx"
40 #include "dx_canvascustomsprite.hxx"
41 
42 #if defined(DX_DEBUG_IMAGES)
43 # if OSL_DEBUG_LEVEL > 0
44 #  include <imdebug.h>
45 #  undef min
46 #  undef max
47 # endif
48 #endif
49 
50 using namespace ::com::sun::star;
51 
52 namespace dxcanvas
53 {
54     namespace
55     {
56         void repaintBackground( const ::basegfx::B2DRange&		rUpdateArea,
57                                 const ::basegfx::B2IRange&		rOutputArea,
58                                 const DXSurfaceBitmapSharedPtr&	rBackBuffer )
59         {
60             // TODO(E1): Use numeric_cast to catch overflow here
61             ::basegfx::B2IRange aActualArea( 0, 0,
62                                              static_cast<sal_Int32>(rOutputArea.getWidth()),
63                                              static_cast<sal_Int32>(rOutputArea.getHeight()) );
64             aActualArea.intersect( fround( rUpdateArea ) );
65 
66 			// repaint the given area of the screen with background content
67 			rBackBuffer->draw(aActualArea);
68         }
69 
70         void spriteRedraw( const ::canvas::Sprite::Reference& rSprite )
71         {
72             // downcast to derived dxcanvas::Sprite interface, which
73             // provides the actual redraw methods.
74             ::boost::polymorphic_downcast< Sprite* >(
75                 rSprite.get() )->redraw();
76         }
77 
78         void spriteRedrawStub( const ::canvas::Sprite::Reference& rSprite )
79         {
80             if( rSprite.is() )
81             {
82                 // downcast to derived dxcanvas::Sprite interface, which
83                 // provides the actual redraw methods.
84                 ::boost::polymorphic_downcast< Sprite* >(
85                     rSprite.get() )->redraw();
86             }
87         }
88 
89         void spriteRedrawStub2( const ::canvas::SpriteRedrawManager::AreaComponent& rComponent )
90         {
91             if( rComponent.second.getSprite().is() )
92             {
93                 // downcast to derived dxcanvas::Sprite interface, which
94                 // provides the actual redraw methods.
95                 ::boost::polymorphic_downcast< Sprite* >(
96                     rComponent.second.getSprite().get() )->redraw();
97             }
98         }
99     }
100 
101     SpriteCanvasHelper::SpriteCanvasHelper() :
102         mpSpriteSurface( NULL ),
103         mpRedrawManager( NULL ),
104         mpRenderModule(),
105         mpSurfaceProxy(),
106         mpBackBuffer(),
107         maUpdateRect(),
108         maScrapRect(),
109         mbShowSpriteBounds( false )
110     {
111 #if defined(VERBOSE) && defined(DBG_UTIL)
112         // inverse default for verbose debug mode
113         mbShowSpriteBounds = true;
114 #endif
115     }
116 
117     void SpriteCanvasHelper::init( SpriteCanvas&                                    rParent,
118                                    ::canvas::SpriteRedrawManager&					rManager,
119                                    const IDXRenderModuleSharedPtr&					rRenderModule,
120 								   const ::canvas::ISurfaceProxyManagerSharedPtr&	rSurfaceProxy,
121                                    const DXSurfaceBitmapSharedPtr&					rBackBuffer,
122                                    const ::basegfx::B2ISize&						rOutputOffset )
123     {
124         // init base
125         setDevice( rParent );
126         setTarget( rBackBuffer, rOutputOffset );
127 
128         mpSpriteSurface = &rParent;
129         mpRedrawManager = &rManager;
130         mpRenderModule  = rRenderModule;
131 		mpSurfaceProxy  = rSurfaceProxy;
132         mpBackBuffer    = rBackBuffer;
133     }
134 
135     void SpriteCanvasHelper::disposing()
136     {
137 		if(mpRenderModule)
138 			mpRenderModule->disposing();
139 
140         mpBackBuffer.reset();
141         mpRenderModule.reset();
142         mpRedrawManager = NULL;
143         mpSpriteSurface = NULL;
144 
145         // forward to base
146         CanvasHelper::disposing();
147     }
148 
149     uno::Reference< rendering::XAnimatedSprite > SpriteCanvasHelper::createSpriteFromAnimation(
150         const uno::Reference< rendering::XAnimation >& /*animation*/ )
151     {
152         return uno::Reference< rendering::XAnimatedSprite >();
153     }
154 
155     uno::Reference< rendering::XAnimatedSprite > SpriteCanvasHelper::createSpriteFromBitmaps(
156         const uno::Sequence< uno::Reference< rendering::XBitmap > >& /*animationBitmaps*/,
157         sal_Int8                                                     /*interpolationMode*/ )
158     {
159         return uno::Reference< rendering::XAnimatedSprite >();
160     }
161 
162     uno::Reference< rendering::XCustomSprite > SpriteCanvasHelper::createCustomSprite( const geometry::RealSize2D& spriteSize )
163     {
164         if( !mpRedrawManager )
165             return uno::Reference< rendering::XCustomSprite >(); // we're disposed
166 
167         return uno::Reference< rendering::XCustomSprite >(
168             new CanvasCustomSprite( spriteSize,
169                                     mpSpriteSurface,
170                                     mpRenderModule,
171 									mpSurfaceProxy,
172                                     mbShowSpriteBounds ) );
173     }
174 
175     uno::Reference< rendering::XSprite > SpriteCanvasHelper::createClonedSprite( const uno::Reference< rendering::XSprite >& /*original*/ )
176     {
177         return uno::Reference< rendering::XSprite >();
178     }
179 
180     sal_Bool SpriteCanvasHelper::updateScreen( const ::basegfx::B2IRectangle& rCurrArea,
181                                                sal_Bool                       bUpdateAll,
182                                                bool&                          io_bSurfaceDirty )
183     {
184         if( !mpRedrawManager ||
185             !mpRenderModule ||
186             !mpBackBuffer )
187         {
188             return sal_False; // disposed, or otherwise dysfunctional
189         }
190 
191 #if defined(DX_DEBUG_IMAGES)
192 # if OSL_DEBUG_LEVEL > 0
193         mpBackBuffer->imageDebugger();
194 # endif
195 #endif
196 
197         // store current output area (need to tunnel that to the
198         // background, scroll, opaque and general sprite repaint
199         // routines)
200         maScrapRect = rCurrArea;
201 
202         // clear area that needs to be blitted to screen beforehand
203         maUpdateRect.reset();
204 
205 		// TODO(P1): Might be worthwile to track areas of background
206         // changes, too.
207 
208         // TODO(P2): Might be worthwhile to use page-flipping only if
209         // a certain percentage of screen area has changed - and
210         // compose directly to the front buffer otherwise.
211         if( !bUpdateAll && !io_bSurfaceDirty )
212         {
213             // background has not changed, so we're free to optimize
214             // repaint to areas where a sprite has changed
215 
216             // process each independent area of overlapping sprites
217             // separately.
218             mpRedrawManager->forEachSpriteArea( *this );
219 
220             // flip primary surface to screen
221             // ==============================
222 
223             // perform buffer flipping
224             mpRenderModule->flip( maUpdateRect,
225                                   rCurrArea );
226         }
227         else
228         {
229             // limit update to parent window area (ignored for fullscreen)
230             // TODO(E1): Use numeric_cast to catch overflow here
231             const ::basegfx::B2IRectangle aUpdateArea( 0,0,
232                                                        static_cast<sal_Int32>(rCurrArea.getWidth()),
233                                                        static_cast<sal_Int32>(rCurrArea.getHeight()) );
234 
235             // background has changed, or called requested full
236             // update, or we're performing double buffering via page
237             // flipping, so we currently have no choice but repaint
238             // everything
239 
240             // repaint the whole screen with background content
241             mpBackBuffer->draw(aUpdateArea);
242 
243 			// redraw sprites
244 			mpRedrawManager->forEachSprite(::std::ptr_fun( &spriteRedraw ) );
245 
246             // flip primary surface to screen
247             // ==============================
248 
249             // perform buffer flipping
250             mpRenderModule->flip( aUpdateArea,
251                                   rCurrArea );
252         }
253 
254         // change record vector must be cleared, for the next turn of
255         // rendering and sprite changing
256         mpRedrawManager->clearChangeRecords();
257 
258         io_bSurfaceDirty = false;
259 
260         return sal_True;
261     }
262 
263     void SpriteCanvasHelper::backgroundPaint( const ::basegfx::B2DRange& rUpdateRect )
264     {
265         ENSURE_OR_THROW( mpRenderModule &&
266                           mpBackBuffer,
267                           "SpriteCanvasHelper::backgroundPaint(): NULL device pointer " );
268 
269         repaintBackground( rUpdateRect,
270                            maScrapRect,
271                            mpBackBuffer );
272     }
273 
274     void SpriteCanvasHelper::scrollUpdate( const ::basegfx::B2DRange& 						/*rMoveStart*/,
275                                            const ::basegfx::B2DRange& 						rMoveEnd,
276                                            const ::canvas::SpriteRedrawManager::UpdateArea& rUpdateArea )
277     {
278         ENSURE_OR_THROW( mpRenderModule &&
279                           mpBackBuffer,
280                           "SpriteCanvasHelper::scrollUpdate(): NULL device pointer " );
281 
282         // round rectangles to integer pixel. Note: have to be
283         // extremely careful here, to avoid off-by-one errors for
284         // the destination area: otherwise, the next scroll update
285         // would copy pixel that are not supposed to be part of
286         // the sprite.
287         const ::basegfx::B2IRange& rDestRect(
288             ::canvas::tools::spritePixelAreaFromB2DRange( rMoveEnd ) );
289 
290         // not much sense in really implementing scrollUpdate here,
291         // since outputting a sprite only partially would result in
292         // expensive clipping. Furthermore, we cannot currently render
293         // 3D directly to the front buffer, thus, would have to blit
294         // the full sprite area, anyway. But at least optimized in the
295         // sense that unnecessary background paints behind the sprites
296         // are avoided.
297         ::std::for_each( rUpdateArea.maComponentList.begin(),
298                          rUpdateArea.maComponentList.end(),
299                          ::std::ptr_fun( &spriteRedrawStub2 ) );
300 
301         // repaint uncovered areas from backbuffer - take the
302         // _rounded_ rectangles from above, to have the update
303         // consistent with the scroll above.
304         ::std::vector< ::basegfx::B2DRange > aUncoveredAreas;
305         ::basegfx::computeSetDifference( aUncoveredAreas,
306                                          rUpdateArea.maTotalBounds,
307                                          ::basegfx::B2DRange( rDestRect ) );
308         ::std::for_each( aUncoveredAreas.begin(),
309                          aUncoveredAreas.end(),
310                          ::boost::bind( &repaintBackground,
311                                         _1,
312                                         ::boost::cref(maScrapRect),
313                                         ::boost::cref(mpBackBuffer) ) );
314 
315         // TODO(E1): Use numeric_cast to catch overflow here
316         ::basegfx::B2IRange aActualArea( 0, 0,
317                                          static_cast<sal_Int32>(maScrapRect.getWidth()),
318                                          static_cast<sal_Int32>(maScrapRect.getHeight()) );
319         aActualArea.intersect( fround( rUpdateArea.maTotalBounds ) );
320 
321         // add given update area to the 'blit to foreground' rect
322         maUpdateRect.expand( aActualArea );
323     }
324 
325     void SpriteCanvasHelper::opaqueUpdate( const ::basegfx::B2DRange&                          rTotalArea,
326                                            const ::std::vector< ::canvas::Sprite::Reference >& rSortedUpdateSprites )
327     {
328         ENSURE_OR_THROW( mpRenderModule &&
329                           mpBackBuffer,
330                           "SpriteCanvasHelper::opaqueUpdate(): NULL device pointer " );
331 
332         // TODO(P2): optimize this by truly rendering to the front
333         // buffer. Currently, we've the 3D device only for the back
334         // buffer.
335         ::std::for_each( rSortedUpdateSprites.begin(),
336                          rSortedUpdateSprites.end(),
337                          ::std::ptr_fun( &spriteRedrawStub ) );
338 
339         // TODO(E1): Use numeric_cast to catch overflow here
340         ::basegfx::B2IRange aActualArea( 0, 0,
341                                          static_cast<sal_Int32>(maScrapRect.getWidth()),
342                                          static_cast<sal_Int32>(maScrapRect.getHeight()) );
343         aActualArea.intersect( fround( rTotalArea ) );
344 
345         // add given update area to the 'blit to foreground' rect
346         maUpdateRect.expand( aActualArea );
347     }
348 
349     void SpriteCanvasHelper::genericUpdate( const ::basegfx::B2DRange&                          rTotalArea,
350                                             const ::std::vector< ::canvas::Sprite::Reference >& rSortedUpdateSprites )
351     {
352 		ENSURE_OR_THROW( mpRenderModule &&
353                           mpBackBuffer,
354                           "SpriteCanvasHelper::genericUpdate(): NULL device pointer " );
355 
356         // paint background
357         // ================
358 
359         // TODO(E1): Use numeric_cast to catch overflow here
360         ::basegfx::B2IRange aActualArea( 0, 0,
361                                          static_cast<sal_Int32>(maScrapRect.getWidth()),
362                                          static_cast<sal_Int32>(maScrapRect.getHeight()) );
363         aActualArea.intersect( fround( rTotalArea ) );
364 
365 		// repaint the given area of the screen with background content
366 		mpBackBuffer->draw(aActualArea);
367 
368         // paint sprite
369         // ============
370 
371         ::std::for_each( rSortedUpdateSprites.begin(),
372                          rSortedUpdateSprites.end(),
373                          ::std::ptr_fun( &spriteRedrawStub ) );
374 
375         // add given update area to the 'blit to foreground' rect
376         maUpdateRect.expand( aActualArea );
377     }
378 }
379