aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/libraries/irrlicht-1.8/source/Irrlicht/CBlit.h
diff options
context:
space:
mode:
authorDavid Walter Seikel2013-01-13 18:54:10 +1000
committerDavid Walter Seikel2013-01-13 18:54:10 +1000
commit959831f4ef5a3e797f576c3de08cd65032c997ad (patch)
treee7351908be5995f0b325b2ebeaa02d5a34b82583 /libraries/irrlicht-1.8/source/Irrlicht/CBlit.h
parentAdd info about changes to Irrlicht. (diff)
downloadSledjHamr-959831f4ef5a3e797f576c3de08cd65032c997ad.zip
SledjHamr-959831f4ef5a3e797f576c3de08cd65032c997ad.tar.gz
SledjHamr-959831f4ef5a3e797f576c3de08cd65032c997ad.tar.bz2
SledjHamr-959831f4ef5a3e797f576c3de08cd65032c997ad.tar.xz
Remove damned ancient DOS line endings from Irrlicht. Hopefully I did not go overboard.
Diffstat (limited to '')
-rw-r--r--libraries/irrlicht-1.8/source/Irrlicht/CBlit.h2546
1 files changed, 1273 insertions, 1273 deletions
diff --git a/libraries/irrlicht-1.8/source/Irrlicht/CBlit.h b/libraries/irrlicht-1.8/source/Irrlicht/CBlit.h
index a8572e9..64ae719 100644
--- a/libraries/irrlicht-1.8/source/Irrlicht/CBlit.h
+++ b/libraries/irrlicht-1.8/source/Irrlicht/CBlit.h
@@ -1,1273 +1,1273 @@
1// Copyright (C) 2002-2012 Nikolaus Gebhardt / Thomas Alten 1// Copyright (C) 2002-2012 Nikolaus Gebhardt / Thomas Alten
2// This file is part of the "Irrlicht Engine". 2// This file is part of the "Irrlicht Engine".
3// For conditions of distribution and use, see copyright notice in irrlicht.h 3// For conditions of distribution and use, see copyright notice in irrlicht.h
4 4
5#ifndef _C_BLIT_H_INCLUDED_ 5#ifndef _C_BLIT_H_INCLUDED_
6#define _C_BLIT_H_INCLUDED_ 6#define _C_BLIT_H_INCLUDED_
7 7
8#include "SoftwareDriver2_helper.h" 8#include "SoftwareDriver2_helper.h"
9 9
10namespace irr 10namespace irr
11{ 11{
12 12
13 struct SBlitJob 13 struct SBlitJob
14 { 14 {
15 AbsRectangle Dest; 15 AbsRectangle Dest;
16 AbsRectangle Source; 16 AbsRectangle Source;
17 17
18 u32 argb; 18 u32 argb;
19 19
20 void * src; 20 void * src;
21 void * dst; 21 void * dst;
22 22
23 s32 width; 23 s32 width;
24 s32 height; 24 s32 height;
25 25
26 u32 srcPitch; 26 u32 srcPitch;
27 u32 dstPitch; 27 u32 dstPitch;
28 28
29 u32 srcPixelMul; 29 u32 srcPixelMul;
30 u32 dstPixelMul; 30 u32 dstPixelMul;
31 31
32 bool stretch; 32 bool stretch;
33 float x_stretch; 33 float x_stretch;
34 float y_stretch; 34 float y_stretch;
35 35
36 SBlitJob() : stretch(false) {} 36 SBlitJob() : stretch(false) {}
37 }; 37 };
38 38
39 // Bitfields Cohen Sutherland 39 // Bitfields Cohen Sutherland
40 enum eClipCode 40 enum eClipCode
41 { 41 {
42 CLIPCODE_EMPTY = 0, 42 CLIPCODE_EMPTY = 0,
43 CLIPCODE_BOTTOM = 1, 43 CLIPCODE_BOTTOM = 1,
44 CLIPCODE_TOP = 2, 44 CLIPCODE_TOP = 2,
45 CLIPCODE_LEFT = 4, 45 CLIPCODE_LEFT = 4,
46 CLIPCODE_RIGHT = 8 46 CLIPCODE_RIGHT = 8
47 }; 47 };
48 48
49inline u32 GetClipCode( const AbsRectangle &r, const core::position2d<s32> &p ) 49inline u32 GetClipCode( const AbsRectangle &r, const core::position2d<s32> &p )
50{ 50{
51 u32 code = CLIPCODE_EMPTY; 51 u32 code = CLIPCODE_EMPTY;
52 52
53 if ( p.X < r.x0 ) 53 if ( p.X < r.x0 )
54 code = CLIPCODE_LEFT; 54 code = CLIPCODE_LEFT;
55 else 55 else
56 if ( p.X > r.x1 ) 56 if ( p.X > r.x1 )
57 code = CLIPCODE_RIGHT; 57 code = CLIPCODE_RIGHT;
58 58
59 if ( p.Y < r.y0 ) 59 if ( p.Y < r.y0 )
60 code |= CLIPCODE_TOP; 60 code |= CLIPCODE_TOP;
61 else 61 else
62 if ( p.Y > r.y1 ) 62 if ( p.Y > r.y1 )
63 code |= CLIPCODE_BOTTOM; 63 code |= CLIPCODE_BOTTOM;
64 64
65 return code; 65 return code;
66} 66}
67 67
68 68
69/*! 69/*!
70 Cohen Sutherland clipping 70 Cohen Sutherland clipping
71 @return: 1 if valid 71 @return: 1 if valid
72*/ 72*/
73 73
74static int ClipLine(const AbsRectangle &clipping, 74static int ClipLine(const AbsRectangle &clipping,
75 core::position2d<s32> &p0, 75 core::position2d<s32> &p0,
76 core::position2d<s32> &p1, 76 core::position2d<s32> &p1,
77 const core::position2d<s32>& p0_in, 77 const core::position2d<s32>& p0_in,
78 const core::position2d<s32>& p1_in) 78 const core::position2d<s32>& p1_in)
79{ 79{
80 u32 code0; 80 u32 code0;
81 u32 code1; 81 u32 code1;
82 u32 code; 82 u32 code;
83 83
84 p0 = p0_in; 84 p0 = p0_in;
85 p1 = p1_in; 85 p1 = p1_in;
86 86
87 code0 = GetClipCode( clipping, p0 ); 87 code0 = GetClipCode( clipping, p0 );
88 code1 = GetClipCode( clipping, p1 ); 88 code1 = GetClipCode( clipping, p1 );
89 89
90 // trivial accepted 90 // trivial accepted
91 while ( code0 | code1 ) 91 while ( code0 | code1 )
92 { 92 {
93 s32 x=0; 93 s32 x=0;
94 s32 y=0; 94 s32 y=0;
95 95
96 // trivial reject 96 // trivial reject
97 if ( code0 & code1 ) 97 if ( code0 & code1 )
98 return 0; 98 return 0;
99 99
100 if ( code0 ) 100 if ( code0 )
101 { 101 {
102 // clip first point 102 // clip first point
103 code = code0; 103 code = code0;
104 } 104 }
105 else 105 else
106 { 106 {
107 // clip last point 107 // clip last point
108 code = code1; 108 code = code1;
109 } 109 }
110 110
111 if ( (code & CLIPCODE_BOTTOM) == CLIPCODE_BOTTOM ) 111 if ( (code & CLIPCODE_BOTTOM) == CLIPCODE_BOTTOM )
112 { 112 {
113 // clip bottom viewport 113 // clip bottom viewport
114 y = clipping.y1; 114 y = clipping.y1;
115 x = p0.X + ( p1.X - p0.X ) * ( y - p0.Y ) / ( p1.Y - p0.Y ); 115 x = p0.X + ( p1.X - p0.X ) * ( y - p0.Y ) / ( p1.Y - p0.Y );
116 } 116 }
117 else 117 else
118 if ( (code & CLIPCODE_TOP) == CLIPCODE_TOP ) 118 if ( (code & CLIPCODE_TOP) == CLIPCODE_TOP )
119 { 119 {
120 // clip to viewport 120 // clip to viewport
121 y = clipping.y0; 121 y = clipping.y0;
122 x = p0.X + ( p1.X - p0.X ) * ( y - p0.Y ) / ( p1.Y - p0.Y ); 122 x = p0.X + ( p1.X - p0.X ) * ( y - p0.Y ) / ( p1.Y - p0.Y );
123 } 123 }
124 else 124 else
125 if ( (code & CLIPCODE_RIGHT) == CLIPCODE_RIGHT ) 125 if ( (code & CLIPCODE_RIGHT) == CLIPCODE_RIGHT )
126 { 126 {
127 // clip right viewport 127 // clip right viewport
128 x = clipping.x1; 128 x = clipping.x1;
129 y = p0.Y + ( p1.Y - p0.Y ) * ( x - p0.X ) / ( p1.X - p0.X ); 129 y = p0.Y + ( p1.Y - p0.Y ) * ( x - p0.X ) / ( p1.X - p0.X );
130 } 130 }
131 else 131 else
132 if ( (code & CLIPCODE_LEFT) == CLIPCODE_LEFT ) 132 if ( (code & CLIPCODE_LEFT) == CLIPCODE_LEFT )
133 { 133 {
134 // clip left viewport 134 // clip left viewport
135 x = clipping.x0; 135 x = clipping.x0;
136 y = p0.Y + ( p1.Y - p0.Y ) * ( x - p0.X ) / ( p1.X - p0.X ); 136 y = p0.Y + ( p1.Y - p0.Y ) * ( x - p0.X ) / ( p1.X - p0.X );
137 } 137 }
138 138
139 if ( code == code0 ) 139 if ( code == code0 )
140 { 140 {
141 // modify first point 141 // modify first point
142 p0.X = x; 142 p0.X = x;
143 p0.Y = y; 143 p0.Y = y;
144 code0 = GetClipCode( clipping, p0 ); 144 code0 = GetClipCode( clipping, p0 );
145 } 145 }
146 else 146 else
147 { 147 {
148 // modify second point 148 // modify second point
149 p1.X = x; 149 p1.X = x;
150 p1.Y = y; 150 p1.Y = y;
151 code1 = GetClipCode( clipping, p1 ); 151 code1 = GetClipCode( clipping, p1 );
152 } 152 }
153 } 153 }
154 154
155 return 1; 155 return 1;
156} 156}
157 157
158/* 158/*
159*/ 159*/
160inline void GetClip(AbsRectangle &clipping, video::IImage * t) 160inline void GetClip(AbsRectangle &clipping, video::IImage * t)
161{ 161{
162 clipping.x0 = 0; 162 clipping.x0 = 0;
163 clipping.y0 = 0; 163 clipping.y0 = 0;
164 clipping.x1 = t->getDimension().Width - 1; 164 clipping.x1 = t->getDimension().Width - 1;
165 clipping.y1 = t->getDimension().Height - 1; 165 clipping.y1 = t->getDimension().Height - 1;
166} 166}
167 167
168/* 168/*
169 return alpha in [0;256] Granularity from 32-Bit ARGB 169 return alpha in [0;256] Granularity from 32-Bit ARGB
170 add highbit alpha ( alpha > 127 ? + 1 ) 170 add highbit alpha ( alpha > 127 ? + 1 )
171*/ 171*/
172static inline u32 extractAlpha(const u32 c) 172static inline u32 extractAlpha(const u32 c)
173{ 173{
174 return ( c >> 24 ) + ( c >> 31 ); 174 return ( c >> 24 ) + ( c >> 31 );
175} 175}
176 176
177/* 177/*
178 return alpha in [0;255] Granularity and 32-Bit ARGB 178 return alpha in [0;255] Granularity and 32-Bit ARGB
179 add highbit alpha ( alpha > 127 ? + 1 ) 179 add highbit alpha ( alpha > 127 ? + 1 )
180*/ 180*/
181static inline u32 packAlpha(const u32 c) 181static inline u32 packAlpha(const u32 c)
182{ 182{
183 return (c > 127 ? c - 1 : c) << 24; 183 return (c > 127 ? c - 1 : c) << 24;
184} 184}
185 185
186 186
187/*! 187/*!
188 Scale Color by (1/value) 188 Scale Color by (1/value)
189 value 0 - 256 ( alpha ) 189 value 0 - 256 ( alpha )
190*/ 190*/
191inline u32 PixelLerp32(const u32 source, const u32 value) 191inline u32 PixelLerp32(const u32 source, const u32 value)
192{ 192{
193 u32 srcRB = source & 0x00FF00FF; 193 u32 srcRB = source & 0x00FF00FF;
194 u32 srcXG = (source & 0xFF00FF00) >> 8; 194 u32 srcXG = (source & 0xFF00FF00) >> 8;
195 195
196 srcRB *= value; 196 srcRB *= value;
197 srcXG *= value; 197 srcXG *= value;
198 198
199 srcRB >>= 8; 199 srcRB >>= 8;
200 //srcXG >>= 8; 200 //srcXG >>= 8;
201 201
202 srcXG &= 0xFF00FF00; 202 srcXG &= 0xFF00FF00;
203 srcRB &= 0x00FF00FF; 203 srcRB &= 0x00FF00FF;
204 204
205 return srcRB | srcXG; 205 return srcRB | srcXG;
206} 206}
207 207
208 208
209/* 209/*
210*/ 210*/
211static void RenderLine32_Decal(video::IImage *t, 211static void RenderLine32_Decal(video::IImage *t,
212 const core::position2d<s32> &p0, 212 const core::position2d<s32> &p0,
213 const core::position2d<s32> &p1, 213 const core::position2d<s32> &p1,
214 u32 argb ) 214 u32 argb )
215{ 215{
216 s32 dx = p1.X - p0.X; 216 s32 dx = p1.X - p0.X;
217 s32 dy = p1.Y - p0.Y; 217 s32 dy = p1.Y - p0.Y;
218 218
219 s32 c; 219 s32 c;
220 s32 m; 220 s32 m;
221 s32 d = 0; 221 s32 d = 0;
222 s32 run; 222 s32 run;
223 223
224 s32 xInc = 4; 224 s32 xInc = 4;
225 s32 yInc = (s32) t->getPitch(); 225 s32 yInc = (s32) t->getPitch();
226 226
227 if ( dx < 0 ) 227 if ( dx < 0 )
228 { 228 {
229 xInc = -xInc; 229 xInc = -xInc;
230 dx = -dx; 230 dx = -dx;
231 } 231 }
232 232
233 if ( dy < 0 ) 233 if ( dy < 0 )
234 { 234 {
235 yInc = -yInc; 235 yInc = -yInc;
236 dy = -dy; 236 dy = -dy;
237 } 237 }
238 238
239 u32 *dst; 239 u32 *dst;
240 dst = (u32*) ( (u8*) t->lock() + ( p0.Y * t->getPitch() ) + ( p0.X << 2 ) ); 240 dst = (u32*) ( (u8*) t->lock() + ( p0.Y * t->getPitch() ) + ( p0.X << 2 ) );
241 241
242 if ( dy > dx ) 242 if ( dy > dx )
243 { 243 {
244 s32 tmp; 244 s32 tmp;
245 tmp = dx; 245 tmp = dx;
246 dx = dy; 246 dx = dy;
247 dy = tmp; 247 dy = tmp;
248 tmp = xInc; 248 tmp = xInc;
249 xInc = yInc; 249 xInc = yInc;
250 yInc = tmp; 250 yInc = tmp;
251 } 251 }
252 252
253 c = dx << 1; 253 c = dx << 1;
254 m = dy << 1; 254 m = dy << 1;
255 255
256 run = dx; 256 run = dx;
257 do 257 do
258 { 258 {
259 *dst = argb; 259 *dst = argb;
260 260
261 dst = (u32*) ( (u8*) dst + xInc ); // x += xInc 261 dst = (u32*) ( (u8*) dst + xInc ); // x += xInc
262 d += m; 262 d += m;
263 if ( d > dx ) 263 if ( d > dx )
264 { 264 {
265 dst = (u32*) ( (u8*) dst + yInc ); // y += yInc 265 dst = (u32*) ( (u8*) dst + yInc ); // y += yInc
266 d -= c; 266 d -= c;
267 } 267 }
268 run -= 1; 268 run -= 1;
269 } while (run>=0); 269 } while (run>=0);
270 270
271 t->unlock(); 271 t->unlock();
272} 272}
273 273
274 274
275/* 275/*
276*/ 276*/
277static void RenderLine32_Blend(video::IImage *t, 277static void RenderLine32_Blend(video::IImage *t,
278 const core::position2d<s32> &p0, 278 const core::position2d<s32> &p0,
279 const core::position2d<s32> &p1, 279 const core::position2d<s32> &p1,
280 u32 argb, u32 alpha) 280 u32 argb, u32 alpha)
281{ 281{
282 s32 dx = p1.X - p0.X; 282 s32 dx = p1.X - p0.X;
283 s32 dy = p1.Y - p0.Y; 283 s32 dy = p1.Y - p0.Y;
284 284
285 s32 c; 285 s32 c;
286 s32 m; 286 s32 m;
287 s32 d = 0; 287 s32 d = 0;
288 s32 run; 288 s32 run;
289 289
290 s32 xInc = 4; 290 s32 xInc = 4;
291 s32 yInc = (s32) t->getPitch(); 291 s32 yInc = (s32) t->getPitch();
292 292
293 if ( dx < 0 ) 293 if ( dx < 0 )
294 { 294 {
295 xInc = -xInc; 295 xInc = -xInc;
296 dx = -dx; 296 dx = -dx;
297 } 297 }
298 298
299 if ( dy < 0 ) 299 if ( dy < 0 )
300 { 300 {
301 yInc = -yInc; 301 yInc = -yInc;
302 dy = -dy; 302 dy = -dy;
303 } 303 }
304 304
305 u32 *dst; 305 u32 *dst;
306 dst = (u32*) ( (u8*) t->lock() + ( p0.Y * t->getPitch() ) + ( p0.X << 2 ) ); 306 dst = (u32*) ( (u8*) t->lock() + ( p0.Y * t->getPitch() ) + ( p0.X << 2 ) );
307 307
308 if ( dy > dx ) 308 if ( dy > dx )
309 { 309 {
310 s32 tmp; 310 s32 tmp;
311 tmp = dx; 311 tmp = dx;
312 dx = dy; 312 dx = dy;
313 dy = tmp; 313 dy = tmp;
314 tmp = xInc; 314 tmp = xInc;
315 xInc = yInc; 315 xInc = yInc;
316 yInc = tmp; 316 yInc = tmp;
317 } 317 }
318 318
319 c = dx << 1; 319 c = dx << 1;
320 m = dy << 1; 320 m = dy << 1;
321 321
322 run = dx; 322 run = dx;
323 const u32 packA = packAlpha ( alpha ); 323 const u32 packA = packAlpha ( alpha );
324 do 324 do
325 { 325 {
326 *dst = packA | PixelBlend32( *dst, argb, alpha ); 326 *dst = packA | PixelBlend32( *dst, argb, alpha );
327 327
328 dst = (u32*) ( (u8*) dst + xInc ); // x += xInc 328 dst = (u32*) ( (u8*) dst + xInc ); // x += xInc
329 d += m; 329 d += m;
330 if ( d > dx ) 330 if ( d > dx )
331 { 331 {
332 dst = (u32*) ( (u8*) dst + yInc ); // y += yInc 332 dst = (u32*) ( (u8*) dst + yInc ); // y += yInc
333 d -= c; 333 d -= c;
334 } 334 }
335 run -= 1; 335 run -= 1;
336 } while (run>=0); 336 } while (run>=0);
337 337
338 t->unlock(); 338 t->unlock();
339} 339}
340 340
341/* 341/*
342*/ 342*/
343static void RenderLine16_Decal(video::IImage *t, 343static void RenderLine16_Decal(video::IImage *t,
344 const core::position2d<s32> &p0, 344 const core::position2d<s32> &p0,
345 const core::position2d<s32> &p1, 345 const core::position2d<s32> &p1,
346 u32 argb ) 346 u32 argb )
347{ 347{
348 s32 dx = p1.X - p0.X; 348 s32 dx = p1.X - p0.X;
349 s32 dy = p1.Y - p0.Y; 349 s32 dy = p1.Y - p0.Y;
350 350
351 s32 c; 351 s32 c;
352 s32 m; 352 s32 m;
353 s32 d = 0; 353 s32 d = 0;
354 s32 run; 354 s32 run;
355 355
356 s32 xInc = 2; 356 s32 xInc = 2;
357 s32 yInc = (s32) t->getPitch(); 357 s32 yInc = (s32) t->getPitch();
358 358
359 if ( dx < 0 ) 359 if ( dx < 0 )
360 { 360 {
361 xInc = -xInc; 361 xInc = -xInc;
362 dx = -dx; 362 dx = -dx;
363 } 363 }
364 364
365 if ( dy < 0 ) 365 if ( dy < 0 )
366 { 366 {
367 yInc = -yInc; 367 yInc = -yInc;
368 dy = -dy; 368 dy = -dy;
369 } 369 }
370 370
371 u16 *dst; 371 u16 *dst;
372 dst = (u16*) ( (u8*) t->lock() + ( p0.Y * t->getPitch() ) + ( p0.X << 1 ) ); 372 dst = (u16*) ( (u8*) t->lock() + ( p0.Y * t->getPitch() ) + ( p0.X << 1 ) );
373 373
374 if ( dy > dx ) 374 if ( dy > dx )
375 { 375 {
376 s32 tmp; 376 s32 tmp;
377 tmp = dx; 377 tmp = dx;
378 dx = dy; 378 dx = dy;
379 dy = tmp; 379 dy = tmp;
380 tmp = xInc; 380 tmp = xInc;
381 xInc = yInc; 381 xInc = yInc;
382 yInc = tmp; 382 yInc = tmp;
383 } 383 }
384 384
385 c = dx << 1; 385 c = dx << 1;
386 m = dy << 1; 386 m = dy << 1;
387 387
388 run = dx; 388 run = dx;
389 do 389 do
390 { 390 {
391 *dst = (u16)argb; 391 *dst = (u16)argb;
392 392
393 dst = (u16*) ( (u8*) dst + xInc ); // x += xInc 393 dst = (u16*) ( (u8*) dst + xInc ); // x += xInc
394 d += m; 394 d += m;
395 if ( d > dx ) 395 if ( d > dx )
396 { 396 {
397 dst = (u16*) ( (u8*) dst + yInc ); // y += yInc 397 dst = (u16*) ( (u8*) dst + yInc ); // y += yInc
398 d -= c; 398 d -= c;
399 } 399 }
400 run -= 1; 400 run -= 1;
401 } while (run>=0); 401 } while (run>=0);
402 402
403 t->unlock(); 403 t->unlock();
404} 404}
405 405
406/* 406/*
407*/ 407*/
408static void RenderLine16_Blend(video::IImage *t, 408static void RenderLine16_Blend(video::IImage *t,
409 const core::position2d<s32> &p0, 409 const core::position2d<s32> &p0,
410 const core::position2d<s32> &p1, 410 const core::position2d<s32> &p1,
411 u16 argb, 411 u16 argb,
412 u16 alpha) 412 u16 alpha)
413{ 413{
414 s32 dx = p1.X - p0.X; 414 s32 dx = p1.X - p0.X;
415 s32 dy = p1.Y - p0.Y; 415 s32 dy = p1.Y - p0.Y;
416 416
417 s32 c; 417 s32 c;
418 s32 m; 418 s32 m;
419 s32 d = 0; 419 s32 d = 0;
420 s32 run; 420 s32 run;
421 421
422 s32 xInc = 2; 422 s32 xInc = 2;
423 s32 yInc = (s32) t->getPitch(); 423 s32 yInc = (s32) t->getPitch();
424 424
425 if ( dx < 0 ) 425 if ( dx < 0 )
426 { 426 {
427 xInc = -xInc; 427 xInc = -xInc;
428 dx = -dx; 428 dx = -dx;
429 } 429 }
430 430
431 if ( dy < 0 ) 431 if ( dy < 0 )
432 { 432 {
433 yInc = -yInc; 433 yInc = -yInc;
434 dy = -dy; 434 dy = -dy;
435 } 435 }
436 436
437 u16 *dst; 437 u16 *dst;
438 dst = (u16*) ( (u8*) t->lock() + ( p0.Y * t->getPitch() ) + ( p0.X << 1 ) ); 438 dst = (u16*) ( (u8*) t->lock() + ( p0.Y * t->getPitch() ) + ( p0.X << 1 ) );
439 439
440 if ( dy > dx ) 440 if ( dy > dx )
441 { 441 {
442 s32 tmp; 442 s32 tmp;
443 tmp = dx; 443 tmp = dx;
444 dx = dy; 444 dx = dy;
445 dy = tmp; 445 dy = tmp;
446 tmp = xInc; 446 tmp = xInc;
447 xInc = yInc; 447 xInc = yInc;
448 yInc = tmp; 448 yInc = tmp;
449 } 449 }
450 450
451 c = dx << 1; 451 c = dx << 1;
452 m = dy << 1; 452 m = dy << 1;
453 453
454 run = dx; 454 run = dx;
455 const u16 packA = alpha ? 0x8000 : 0; 455 const u16 packA = alpha ? 0x8000 : 0;
456 do 456 do
457 { 457 {
458 *dst = packA | PixelBlend16( *dst, argb, alpha ); 458 *dst = packA | PixelBlend16( *dst, argb, alpha );
459 459
460 dst = (u16*) ( (u8*) dst + xInc ); // x += xInc 460 dst = (u16*) ( (u8*) dst + xInc ); // x += xInc
461 d += m; 461 d += m;
462 if ( d > dx ) 462 if ( d > dx )
463 { 463 {
464 dst = (u16*) ( (u8*) dst + yInc ); // y += yInc 464 dst = (u16*) ( (u8*) dst + yInc ); // y += yInc
465 d -= c; 465 d -= c;
466 } 466 }
467 run -= 1; 467 run -= 1;
468 } while (run>=0); 468 } while (run>=0);
469 469
470 t->unlock(); 470 t->unlock();
471} 471}
472 472
473 473
474/*! 474/*!
475*/ 475*/
476static void executeBlit_TextureCopy_x_to_x( const SBlitJob * job ) 476static void executeBlit_TextureCopy_x_to_x( const SBlitJob * job )
477{ 477{
478 const u32 w = job->width; 478 const u32 w = job->width;
479 const u32 h = job->height; 479 const u32 h = job->height;
480 if (job->stretch) 480 if (job->stretch)
481 { 481 {
482 const u32 *src = static_cast<const u32*>(job->src); 482 const u32 *src = static_cast<const u32*>(job->src);
483 u32 *dst = static_cast<u32*>(job->dst); 483 u32 *dst = static_cast<u32*>(job->dst);
484 const float wscale = 1.f/job->x_stretch; 484 const float wscale = 1.f/job->x_stretch;
485 const float hscale = 1.f/job->y_stretch; 485 const float hscale = 1.f/job->y_stretch;
486 486
487 for ( u32 dy = 0; dy < h; ++dy ) 487 for ( u32 dy = 0; dy < h; ++dy )
488 { 488 {
489 const u32 src_y = (u32)(dy*hscale); 489 const u32 src_y = (u32)(dy*hscale);
490 src = (u32*) ( (u8*) (job->src) + job->srcPitch*src_y ); 490 src = (u32*) ( (u8*) (job->src) + job->srcPitch*src_y );
491 491
492 for ( u32 dx = 0; dx < w; ++dx ) 492 for ( u32 dx = 0; dx < w; ++dx )
493 { 493 {
494 const u32 src_x = (u32)(dx*wscale); 494 const u32 src_x = (u32)(dx*wscale);
495 dst[dx] = src[src_x]; 495 dst[dx] = src[src_x];
496 } 496 }
497 dst = (u32*) ( (u8*) (dst) + job->dstPitch ); 497 dst = (u32*) ( (u8*) (dst) + job->dstPitch );
498 } 498 }
499 } 499 }
500 else 500 else
501 { 501 {
502 const u32 widthPitch = job->width * job->dstPixelMul; 502 const u32 widthPitch = job->width * job->dstPixelMul;
503 const void *src = (void*) job->src; 503 const void *src = (void*) job->src;
504 void *dst = (void*) job->dst; 504 void *dst = (void*) job->dst;
505 505
506 for ( u32 dy = 0; dy != h; ++dy ) 506 for ( u32 dy = 0; dy != h; ++dy )
507 { 507 {
508 memcpy( dst, src, widthPitch ); 508 memcpy( dst, src, widthPitch );
509 509
510 src = (void*) ( (u8*) (src) + job->srcPitch ); 510 src = (void*) ( (u8*) (src) + job->srcPitch );
511 dst = (void*) ( (u8*) (dst) + job->dstPitch ); 511 dst = (void*) ( (u8*) (dst) + job->dstPitch );
512 } 512 }
513 } 513 }
514} 514}
515 515
516/*! 516/*!
517*/ 517*/
518static void executeBlit_TextureCopy_32_to_16( const SBlitJob * job ) 518static void executeBlit_TextureCopy_32_to_16( const SBlitJob * job )
519{ 519{
520 const u32 w = job->width; 520 const u32 w = job->width;
521 const u32 h = job->height; 521 const u32 h = job->height;
522 const u32 *src = static_cast<const u32*>(job->src); 522 const u32 *src = static_cast<const u32*>(job->src);
523 u16 *dst = static_cast<u16*>(job->dst); 523 u16 *dst = static_cast<u16*>(job->dst);
524 524
525 if (job->stretch) 525 if (job->stretch)
526 { 526 {
527 const float wscale = 1.f/job->x_stretch; 527 const float wscale = 1.f/job->x_stretch;
528 const float hscale = 1.f/job->y_stretch; 528 const float hscale = 1.f/job->y_stretch;
529 529
530 for ( u32 dy = 0; dy < h; ++dy ) 530 for ( u32 dy = 0; dy < h; ++dy )
531 { 531 {
532 const u32 src_y = (u32)(dy*hscale); 532 const u32 src_y = (u32)(dy*hscale);
533 src = (u32*) ( (u8*) (job->src) + job->srcPitch*src_y ); 533 src = (u32*) ( (u8*) (job->src) + job->srcPitch*src_y );
534 534
535 for ( u32 dx = 0; dx < w; ++dx ) 535 for ( u32 dx = 0; dx < w; ++dx )
536 { 536 {
537 const u32 src_x = (u32)(dx*wscale); 537 const u32 src_x = (u32)(dx*wscale);
538 //16 bit Blitter depends on pre-multiplied color 538 //16 bit Blitter depends on pre-multiplied color
539 const u32 s = PixelLerp32( src[src_x] | 0xFF000000, extractAlpha( src[src_x] ) ); 539 const u32 s = PixelLerp32( src[src_x] | 0xFF000000, extractAlpha( src[src_x] ) );
540 dst[dx] = video::A8R8G8B8toA1R5G5B5( s ); 540 dst[dx] = video::A8R8G8B8toA1R5G5B5( s );
541 } 541 }
542 dst = (u16*) ( (u8*) (dst) + job->dstPitch ); 542 dst = (u16*) ( (u8*) (dst) + job->dstPitch );
543 } 543 }
544 } 544 }
545 else 545 else
546 { 546 {
547 for ( u32 dy = 0; dy != h; ++dy ) 547 for ( u32 dy = 0; dy != h; ++dy )
548 { 548 {
549 for ( u32 dx = 0; dx != w; ++dx ) 549 for ( u32 dx = 0; dx != w; ++dx )
550 { 550 {
551 //16 bit Blitter depends on pre-multiplied color 551 //16 bit Blitter depends on pre-multiplied color
552 const u32 s = PixelLerp32( src[dx] | 0xFF000000, extractAlpha( src[dx] ) ); 552 const u32 s = PixelLerp32( src[dx] | 0xFF000000, extractAlpha( src[dx] ) );
553 dst[dx] = video::A8R8G8B8toA1R5G5B5( s ); 553 dst[dx] = video::A8R8G8B8toA1R5G5B5( s );
554 } 554 }
555 555
556 src = (u32*) ( (u8*) (src) + job->srcPitch ); 556 src = (u32*) ( (u8*) (src) + job->srcPitch );
557 dst = (u16*) ( (u8*) (dst) + job->dstPitch ); 557 dst = (u16*) ( (u8*) (dst) + job->dstPitch );
558 } 558 }
559 } 559 }
560} 560}
561 561
562/*! 562/*!
563*/ 563*/
564static void executeBlit_TextureCopy_24_to_16( const SBlitJob * job ) 564static void executeBlit_TextureCopy_24_to_16( const SBlitJob * job )
565{ 565{
566 const u32 w = job->width; 566 const u32 w = job->width;
567 const u32 h = job->height; 567 const u32 h = job->height;
568 const u8 *src = static_cast<const u8*>(job->src); 568 const u8 *src = static_cast<const u8*>(job->src);
569 u16 *dst = static_cast<u16*>(job->dst); 569 u16 *dst = static_cast<u16*>(job->dst);
570 570
571 if (job->stretch) 571 if (job->stretch)
572 { 572 {
573 const float wscale = 3.f/job->x_stretch; 573 const float wscale = 3.f/job->x_stretch;
574 const float hscale = 1.f/job->y_stretch; 574 const float hscale = 1.f/job->y_stretch;
575 575
576 for ( u32 dy = 0; dy < h; ++dy ) 576 for ( u32 dy = 0; dy < h; ++dy )
577 { 577 {
578 const u32 src_y = (u32)(dy*hscale); 578 const u32 src_y = (u32)(dy*hscale);
579 src = (u8*)(job->src) + job->srcPitch*src_y; 579 src = (u8*)(job->src) + job->srcPitch*src_y;
580 580
581 for ( u32 dx = 0; dx < w; ++dx ) 581 for ( u32 dx = 0; dx < w; ++dx )
582 { 582 {
583 const u8* src_x = src+(u32)(dx*wscale); 583 const u8* src_x = src+(u32)(dx*wscale);
584 dst[dx] = video::RGBA16(src_x[0], src_x[1], src_x[2]); 584 dst[dx] = video::RGBA16(src_x[0], src_x[1], src_x[2]);
585 } 585 }
586 dst = (u16*) ( (u8*) (dst) + job->dstPitch ); 586 dst = (u16*) ( (u8*) (dst) + job->dstPitch );
587 } 587 }
588 } 588 }
589 else 589 else
590 { 590 {
591 for ( u32 dy = 0; dy != h; ++dy ) 591 for ( u32 dy = 0; dy != h; ++dy )
592 { 592 {
593 const u8* s = src; 593 const u8* s = src;
594 for ( u32 dx = 0; dx != w; ++dx ) 594 for ( u32 dx = 0; dx != w; ++dx )
595 { 595 {
596 dst[dx] = video::RGBA16(s[0], s[1], s[2]); 596 dst[dx] = video::RGBA16(s[0], s[1], s[2]);
597 s += 3; 597 s += 3;
598 } 598 }
599 599
600 src = src+job->srcPitch; 600 src = src+job->srcPitch;
601 dst = (u16*) ( (u8*) (dst) + job->dstPitch ); 601 dst = (u16*) ( (u8*) (dst) + job->dstPitch );
602 } 602 }
603 } 603 }
604} 604}
605 605
606 606
607/*! 607/*!
608*/ 608*/
609static void executeBlit_TextureCopy_16_to_32( const SBlitJob * job ) 609static void executeBlit_TextureCopy_16_to_32( const SBlitJob * job )
610{ 610{
611 const u32 w = job->width; 611 const u32 w = job->width;
612 const u32 h = job->height; 612 const u32 h = job->height;
613 const u16 *src = static_cast<const u16*>(job->src); 613 const u16 *src = static_cast<const u16*>(job->src);
614 u32 *dst = static_cast<u32*>(job->dst); 614 u32 *dst = static_cast<u32*>(job->dst);
615 615
616 if (job->stretch) 616 if (job->stretch)
617 { 617 {
618 const float wscale = 1.f/job->x_stretch; 618 const float wscale = 1.f/job->x_stretch;
619 const float hscale = 1.f/job->y_stretch; 619 const float hscale = 1.f/job->y_stretch;
620 620
621 for ( u32 dy = 0; dy < h; ++dy ) 621 for ( u32 dy = 0; dy < h; ++dy )
622 { 622 {
623 const u32 src_y = (u32)(dy*hscale); 623 const u32 src_y = (u32)(dy*hscale);
624 src = (u16*) ( (u8*) (job->src) + job->srcPitch*src_y ); 624 src = (u16*) ( (u8*) (job->src) + job->srcPitch*src_y );
625 625
626 for ( u32 dx = 0; dx < w; ++dx ) 626 for ( u32 dx = 0; dx < w; ++dx )
627 { 627 {
628 const u32 src_x = (u32)(dx*wscale); 628 const u32 src_x = (u32)(dx*wscale);
629 dst[dx] = video::A1R5G5B5toA8R8G8B8(src[src_x]); 629 dst[dx] = video::A1R5G5B5toA8R8G8B8(src[src_x]);
630 } 630 }
631 dst = (u32*) ( (u8*) (dst) + job->dstPitch ); 631 dst = (u32*) ( (u8*) (dst) + job->dstPitch );
632 } 632 }
633 } 633 }
634 else 634 else
635 { 635 {
636 for ( u32 dy = 0; dy != h; ++dy ) 636 for ( u32 dy = 0; dy != h; ++dy )
637 { 637 {
638 for ( u32 dx = 0; dx != w; ++dx ) 638 for ( u32 dx = 0; dx != w; ++dx )
639 { 639 {
640 dst[dx] = video::A1R5G5B5toA8R8G8B8( src[dx] ); 640 dst[dx] = video::A1R5G5B5toA8R8G8B8( src[dx] );
641 } 641 }
642 642
643 src = (u16*) ( (u8*) (src) + job->srcPitch ); 643 src = (u16*) ( (u8*) (src) + job->srcPitch );
644 dst = (u32*) ( (u8*) (dst) + job->dstPitch ); 644 dst = (u32*) ( (u8*) (dst) + job->dstPitch );
645 } 645 }
646 } 646 }
647} 647}
648 648
649static void executeBlit_TextureCopy_16_to_24( const SBlitJob * job ) 649static void executeBlit_TextureCopy_16_to_24( const SBlitJob * job )
650{ 650{
651 const u32 w = job->width; 651 const u32 w = job->width;
652 const u32 h = job->height; 652 const u32 h = job->height;
653 const u16 *src = static_cast<const u16*>(job->src); 653 const u16 *src = static_cast<const u16*>(job->src);
654 u8 *dst = static_cast<u8*>(job->dst); 654 u8 *dst = static_cast<u8*>(job->dst);
655 655
656 if (job->stretch) 656 if (job->stretch)
657 { 657 {
658 const float wscale = 1.f/job->x_stretch; 658 const float wscale = 1.f/job->x_stretch;
659 const float hscale = 1.f/job->y_stretch; 659 const float hscale = 1.f/job->y_stretch;
660 660
661 for ( u32 dy = 0; dy < h; ++dy ) 661 for ( u32 dy = 0; dy < h; ++dy )
662 { 662 {
663 const u32 src_y = (u32)(dy*hscale); 663 const u32 src_y = (u32)(dy*hscale);
664 src = (u16*) ( (u8*) (job->src) + job->srcPitch*src_y ); 664 src = (u16*) ( (u8*) (job->src) + job->srcPitch*src_y );
665 665
666 for ( u32 dx = 0; dx < w; ++dx ) 666 for ( u32 dx = 0; dx < w; ++dx )
667 { 667 {
668 const u32 src_x = (u32)(dx*wscale); 668 const u32 src_x = (u32)(dx*wscale);
669 u32 color = video::A1R5G5B5toA8R8G8B8(src[src_x]); 669 u32 color = video::A1R5G5B5toA8R8G8B8(src[src_x]);
670 u8 * writeTo = &dst[dx * 3]; 670 u8 * writeTo = &dst[dx * 3];
671 *writeTo++ = (color >> 16)& 0xFF; 671 *writeTo++ = (color >> 16)& 0xFF;
672 *writeTo++ = (color >> 8) & 0xFF; 672 *writeTo++ = (color >> 8) & 0xFF;
673 *writeTo++ = color & 0xFF; 673 *writeTo++ = color & 0xFF;
674 } 674 }
675 dst += job->dstPitch; 675 dst += job->dstPitch;
676 } 676 }
677 } 677 }
678 else 678 else
679 { 679 {
680 for ( u32 dy = 0; dy != h; ++dy ) 680 for ( u32 dy = 0; dy != h; ++dy )
681 { 681 {
682 for ( u32 dx = 0; dx != w; ++dx ) 682 for ( u32 dx = 0; dx != w; ++dx )
683 { 683 {
684 u32 color = video::A1R5G5B5toA8R8G8B8(src[dx]); 684 u32 color = video::A1R5G5B5toA8R8G8B8(src[dx]);
685 u8 * writeTo = &dst[dx * 3]; 685 u8 * writeTo = &dst[dx * 3];
686 *writeTo++ = (color >> 16)& 0xFF; 686 *writeTo++ = (color >> 16)& 0xFF;
687 *writeTo++ = (color >> 8) & 0xFF; 687 *writeTo++ = (color >> 8) & 0xFF;
688 *writeTo++ = color & 0xFF; 688 *writeTo++ = color & 0xFF;
689 } 689 }
690 690
691 src = (u16*) ( (u8*) (src) + job->srcPitch ); 691 src = (u16*) ( (u8*) (src) + job->srcPitch );
692 dst += job->dstPitch; 692 dst += job->dstPitch;
693 } 693 }
694 } 694 }
695} 695}
696 696
697/*! 697/*!
698*/ 698*/
699static void executeBlit_TextureCopy_24_to_32( const SBlitJob * job ) 699static void executeBlit_TextureCopy_24_to_32( const SBlitJob * job )
700{ 700{
701 const u32 w = job->width; 701 const u32 w = job->width;
702 const u32 h = job->height; 702 const u32 h = job->height;
703 const u8 *src = static_cast<const u8*>(job->src); 703 const u8 *src = static_cast<const u8*>(job->src);
704 u32 *dst = static_cast<u32*>(job->dst); 704 u32 *dst = static_cast<u32*>(job->dst);
705 705
706 if (job->stretch) 706 if (job->stretch)
707 { 707 {
708 const float wscale = 3.f/job->x_stretch; 708 const float wscale = 3.f/job->x_stretch;
709 const float hscale = 1.f/job->y_stretch; 709 const float hscale = 1.f/job->y_stretch;
710 710
711 for ( u32 dy = 0; dy < h; ++dy ) 711 for ( u32 dy = 0; dy < h; ++dy )
712 { 712 {
713 const u32 src_y = (u32)(dy*hscale); 713 const u32 src_y = (u32)(dy*hscale);
714 src = (const u8*)job->src+(job->srcPitch*src_y); 714 src = (const u8*)job->src+(job->srcPitch*src_y);
715 715
716 for ( u32 dx = 0; dx < w; ++dx ) 716 for ( u32 dx = 0; dx < w; ++dx )
717 { 717 {
718 const u8* s = src+(u32)(dx*wscale); 718 const u8* s = src+(u32)(dx*wscale);
719 dst[dx] = 0xFF000000 | s[0] << 16 | s[1] << 8 | s[2]; 719 dst[dx] = 0xFF000000 | s[0] << 16 | s[1] << 8 | s[2];
720 } 720 }
721 dst = (u32*) ( (u8*) (dst) + job->dstPitch ); 721 dst = (u32*) ( (u8*) (dst) + job->dstPitch );
722 } 722 }
723 } 723 }
724 else 724 else
725 { 725 {
726 for ( s32 dy = 0; dy != job->height; ++dy ) 726 for ( s32 dy = 0; dy != job->height; ++dy )
727 { 727 {
728 const u8* s = src; 728 const u8* s = src;
729 729
730 for ( s32 dx = 0; dx != job->width; ++dx ) 730 for ( s32 dx = 0; dx != job->width; ++dx )
731 { 731 {
732 dst[dx] = 0xFF000000 | s[0] << 16 | s[1] << 8 | s[2]; 732 dst[dx] = 0xFF000000 | s[0] << 16 | s[1] << 8 | s[2];
733 s += 3; 733 s += 3;
734 } 734 }
735 735
736 src = src + job->srcPitch; 736 src = src + job->srcPitch;
737 dst = (u32*) ( (u8*) (dst) + job->dstPitch ); 737 dst = (u32*) ( (u8*) (dst) + job->dstPitch );
738 } 738 }
739 } 739 }
740} 740}
741 741
742static void executeBlit_TextureCopy_32_to_24( const SBlitJob * job ) 742static void executeBlit_TextureCopy_32_to_24( const SBlitJob * job )
743{ 743{
744 const u32 w = job->width; 744 const u32 w = job->width;
745 const u32 h = job->height; 745 const u32 h = job->height;
746 const u32 *src = static_cast<const u32*>(job->src); 746 const u32 *src = static_cast<const u32*>(job->src);
747 u8 *dst = static_cast<u8*>(job->dst); 747 u8 *dst = static_cast<u8*>(job->dst);
748 748
749 if (job->stretch) 749 if (job->stretch)
750 { 750 {
751 const float wscale = 1.f/job->x_stretch; 751 const float wscale = 1.f/job->x_stretch;
752 const float hscale = 1.f/job->y_stretch; 752 const float hscale = 1.f/job->y_stretch;
753 753
754 for ( u32 dy = 0; dy < h; ++dy ) 754 for ( u32 dy = 0; dy < h; ++dy )
755 { 755 {
756 const u32 src_y = (u32)(dy*hscale); 756 const u32 src_y = (u32)(dy*hscale);
757 src = (u32*) ( (u8*) (job->src) + job->srcPitch*src_y); 757 src = (u32*) ( (u8*) (job->src) + job->srcPitch*src_y);
758 758
759 for ( u32 dx = 0; dx < w; ++dx ) 759 for ( u32 dx = 0; dx < w; ++dx )
760 { 760 {
761 const u32 src_x = src[(u32)(dx*wscale)]; 761 const u32 src_x = src[(u32)(dx*wscale)];
762 u8 * writeTo = &dst[dx * 3]; 762 u8 * writeTo = &dst[dx * 3];
763 *writeTo++ = (src_x >> 16)& 0xFF; 763 *writeTo++ = (src_x >> 16)& 0xFF;
764 *writeTo++ = (src_x >> 8) & 0xFF; 764 *writeTo++ = (src_x >> 8) & 0xFF;
765 *writeTo++ = src_x & 0xFF; 765 *writeTo++ = src_x & 0xFF;
766 } 766 }
767 dst += job->dstPitch; 767 dst += job->dstPitch;
768 } 768 }
769 } 769 }
770 else 770 else
771 { 771 {
772 for ( u32 dy = 0; dy != h; ++dy ) 772 for ( u32 dy = 0; dy != h; ++dy )
773 { 773 {
774 for ( u32 dx = 0; dx != w; ++dx ) 774 for ( u32 dx = 0; dx != w; ++dx )
775 { 775 {
776 u8 * writeTo = &dst[dx * 3]; 776 u8 * writeTo = &dst[dx * 3];
777 *writeTo++ = (src[dx] >> 16)& 0xFF; 777 *writeTo++ = (src[dx] >> 16)& 0xFF;
778 *writeTo++ = (src[dx] >> 8) & 0xFF; 778 *writeTo++ = (src[dx] >> 8) & 0xFF;
779 *writeTo++ = src[dx] & 0xFF; 779 *writeTo++ = src[dx] & 0xFF;
780 } 780 }
781 781
782 src = (u32*) ( (u8*) (src) + job->srcPitch ); 782 src = (u32*) ( (u8*) (src) + job->srcPitch );
783 dst += job->dstPitch; 783 dst += job->dstPitch;
784 } 784 }
785 } 785 }
786} 786}
787 787
788/*! 788/*!
789*/ 789*/
790static void executeBlit_TextureBlend_16_to_16( const SBlitJob * job ) 790static void executeBlit_TextureBlend_16_to_16( const SBlitJob * job )
791{ 791{
792 const u32 w = job->width; 792 const u32 w = job->width;
793 const u32 h = job->height; 793 const u32 h = job->height;
794 const u32 rdx = w>>1; 794 const u32 rdx = w>>1;
795 795
796 const u32 *src = (u32*) job->src; 796 const u32 *src = (u32*) job->src;
797 u32 *dst = (u32*) job->dst; 797 u32 *dst = (u32*) job->dst;
798 798
799 if (job->stretch) 799 if (job->stretch)
800 { 800 {
801 const float wscale = 1.f/job->x_stretch; 801 const float wscale = 1.f/job->x_stretch;
802 const float hscale = 1.f/job->y_stretch; 802 const float hscale = 1.f/job->y_stretch;
803 const u32 off = core::if_c_a_else_b(w&1, (u32)((w-1)*wscale), 0); 803 const u32 off = core::if_c_a_else_b(w&1, (u32)((w-1)*wscale), 0);
804 for ( u32 dy = 0; dy < h; ++dy ) 804 for ( u32 dy = 0; dy < h; ++dy )
805 { 805 {
806 const u32 src_y = (u32)(dy*hscale); 806 const u32 src_y = (u32)(dy*hscale);
807 src = (u32*) ( (u8*) (job->src) + job->srcPitch*src_y ); 807 src = (u32*) ( (u8*) (job->src) + job->srcPitch*src_y );
808 808
809 for ( u32 dx = 0; dx < rdx; ++dx ) 809 for ( u32 dx = 0; dx < rdx; ++dx )
810 { 810 {
811 const u32 src_x = (u32)(dx*wscale); 811 const u32 src_x = (u32)(dx*wscale);
812 dst[dx] = PixelBlend16_simd( dst[dx], src[src_x] ); 812 dst[dx] = PixelBlend16_simd( dst[dx], src[src_x] );
813 } 813 }
814 if ( off ) 814 if ( off )
815 { 815 {
816 ((u16*) dst)[off] = PixelBlend16( ((u16*) dst)[off], ((u16*) src)[off] ); 816 ((u16*) dst)[off] = PixelBlend16( ((u16*) dst)[off], ((u16*) src)[off] );
817 } 817 }
818 818
819 dst = (u32*) ( (u8*) (dst) + job->dstPitch ); 819 dst = (u32*) ( (u8*) (dst) + job->dstPitch );
820 } 820 }
821 } 821 }
822 else 822 else
823 { 823 {
824 const u32 off = core::if_c_a_else_b(w&1, w-1, 0); 824 const u32 off = core::if_c_a_else_b(w&1, w-1, 0);
825 for (u32 dy = 0; dy != h; ++dy ) 825 for (u32 dy = 0; dy != h; ++dy )
826 { 826 {
827 for (u32 dx = 0; dx != rdx; ++dx ) 827 for (u32 dx = 0; dx != rdx; ++dx )
828 { 828 {
829 dst[dx] = PixelBlend16_simd( dst[dx], src[dx] ); 829 dst[dx] = PixelBlend16_simd( dst[dx], src[dx] );
830 } 830 }
831 831
832 if ( off ) 832 if ( off )
833 { 833 {
834 ((u16*) dst)[off] = PixelBlend16( ((u16*) dst)[off], ((u16*) src)[off] ); 834 ((u16*) dst)[off] = PixelBlend16( ((u16*) dst)[off], ((u16*) src)[off] );
835 } 835 }
836 836
837 src = (u32*) ( (u8*) (src) + job->srcPitch ); 837 src = (u32*) ( (u8*) (src) + job->srcPitch );
838 dst = (u32*) ( (u8*) (dst) + job->dstPitch ); 838 dst = (u32*) ( (u8*) (dst) + job->dstPitch );
839 } 839 }
840 } 840 }
841} 841}
842 842
843/*! 843/*!
844*/ 844*/
845static void executeBlit_TextureBlend_32_to_32( const SBlitJob * job ) 845static void executeBlit_TextureBlend_32_to_32( const SBlitJob * job )
846{ 846{
847 const u32 w = job->width; 847 const u32 w = job->width;
848 const u32 h = job->height; 848 const u32 h = job->height;
849 const u32 *src = (u32*) job->src; 849 const u32 *src = (u32*) job->src;
850 u32 *dst = (u32*) job->dst; 850 u32 *dst = (u32*) job->dst;
851 851
852 if (job->stretch) 852 if (job->stretch)
853 { 853 {
854 const float wscale = 1.f/job->x_stretch; 854 const float wscale = 1.f/job->x_stretch;
855 const float hscale = 1.f/job->y_stretch; 855 const float hscale = 1.f/job->y_stretch;
856 for ( u32 dy = 0; dy < h; ++dy ) 856 for ( u32 dy = 0; dy < h; ++dy )
857 { 857 {
858 const u32 src_y = (u32)(dy*hscale); 858 const u32 src_y = (u32)(dy*hscale);
859 src = (u32*) ( (u8*) (job->src) + job->srcPitch*src_y ); 859 src = (u32*) ( (u8*) (job->src) + job->srcPitch*src_y );
860 860
861 for ( u32 dx = 0; dx < w; ++dx ) 861 for ( u32 dx = 0; dx < w; ++dx )
862 { 862 {
863 const u32 src_x = (u32)(dx*wscale); 863 const u32 src_x = (u32)(dx*wscale);
864 dst[dx] = PixelBlend32( dst[dx], src[src_x] ); 864 dst[dx] = PixelBlend32( dst[dx], src[src_x] );
865 } 865 }
866 866
867 dst = (u32*) ( (u8*) (dst) + job->dstPitch ); 867 dst = (u32*) ( (u8*) (dst) + job->dstPitch );
868 } 868 }
869 } 869 }
870 else 870 else
871 { 871 {
872 for ( u32 dy = 0; dy != h; ++dy ) 872 for ( u32 dy = 0; dy != h; ++dy )
873 { 873 {
874 for ( u32 dx = 0; dx != w; ++dx ) 874 for ( u32 dx = 0; dx != w; ++dx )
875 { 875 {
876 dst[dx] = PixelBlend32( dst[dx], src[dx] ); 876 dst[dx] = PixelBlend32( dst[dx], src[dx] );
877 } 877 }
878 src = (u32*) ( (u8*) (src) + job->srcPitch ); 878 src = (u32*) ( (u8*) (src) + job->srcPitch );
879 dst = (u32*) ( (u8*) (dst) + job->dstPitch ); 879 dst = (u32*) ( (u8*) (dst) + job->dstPitch );
880 } 880 }
881 } 881 }
882} 882}
883 883
884/*! 884/*!
885*/ 885*/
886static void executeBlit_TextureBlendColor_16_to_16( const SBlitJob * job ) 886static void executeBlit_TextureBlendColor_16_to_16( const SBlitJob * job )
887{ 887{
888 u16 *src = (u16*) job->src; 888 u16 *src = (u16*) job->src;
889 u16 *dst = (u16*) job->dst; 889 u16 *dst = (u16*) job->dst;
890 890
891 u16 blend = video::A8R8G8B8toA1R5G5B5 ( job->argb ); 891 u16 blend = video::A8R8G8B8toA1R5G5B5 ( job->argb );
892 for ( s32 dy = 0; dy != job->height; ++dy ) 892 for ( s32 dy = 0; dy != job->height; ++dy )
893 { 893 {
894 for ( s32 dx = 0; dx != job->width; ++dx ) 894 for ( s32 dx = 0; dx != job->width; ++dx )
895 { 895 {
896 if ( 0 == (src[dx] & 0x8000) ) 896 if ( 0 == (src[dx] & 0x8000) )
897 continue; 897 continue;
898 898
899 dst[dx] = PixelMul16_2( src[dx], blend ); 899 dst[dx] = PixelMul16_2( src[dx], blend );
900 } 900 }
901 src = (u16*) ( (u8*) (src) + job->srcPitch ); 901 src = (u16*) ( (u8*) (src) + job->srcPitch );
902 dst = (u16*) ( (u8*) (dst) + job->dstPitch ); 902 dst = (u16*) ( (u8*) (dst) + job->dstPitch );
903 } 903 }
904} 904}
905 905
906 906
907/*! 907/*!
908*/ 908*/
909static void executeBlit_TextureBlendColor_32_to_32( const SBlitJob * job ) 909static void executeBlit_TextureBlendColor_32_to_32( const SBlitJob * job )
910{ 910{
911 u32 *src = (u32*) job->src; 911 u32 *src = (u32*) job->src;
912 u32 *dst = (u32*) job->dst; 912 u32 *dst = (u32*) job->dst;
913 913
914 for ( s32 dy = 0; dy != job->height; ++dy ) 914 for ( s32 dy = 0; dy != job->height; ++dy )
915 { 915 {
916 for ( s32 dx = 0; dx != job->width; ++dx ) 916 for ( s32 dx = 0; dx != job->width; ++dx )
917 { 917 {
918 dst[dx] = PixelBlend32( dst[dx], PixelMul32_2( src[dx], job->argb ) ); 918 dst[dx] = PixelBlend32( dst[dx], PixelMul32_2( src[dx], job->argb ) );
919 } 919 }
920 src = (u32*) ( (u8*) (src) + job->srcPitch ); 920 src = (u32*) ( (u8*) (src) + job->srcPitch );
921 dst = (u32*) ( (u8*) (dst) + job->dstPitch ); 921 dst = (u32*) ( (u8*) (dst) + job->dstPitch );
922 } 922 }
923} 923}
924 924
925/*! 925/*!
926*/ 926*/
927static void executeBlit_Color_16_to_16( const SBlitJob * job ) 927static void executeBlit_Color_16_to_16( const SBlitJob * job )
928{ 928{
929 const u16 c = video::A8R8G8B8toA1R5G5B5(job->argb); 929 const u16 c = video::A8R8G8B8toA1R5G5B5(job->argb);
930 u16 *dst = (u16*) job->dst; 930 u16 *dst = (u16*) job->dst;
931 931
932 for ( s32 dy = 0; dy != job->height; ++dy ) 932 for ( s32 dy = 0; dy != job->height; ++dy )
933 { 933 {
934 memset16(dst, c, job->srcPitch); 934 memset16(dst, c, job->srcPitch);
935 dst = (u16*) ( (u8*) (dst) + job->dstPitch ); 935 dst = (u16*) ( (u8*) (dst) + job->dstPitch );
936 } 936 }
937} 937}
938 938
939/*! 939/*!
940*/ 940*/
941static void executeBlit_Color_32_to_32( const SBlitJob * job ) 941static void executeBlit_Color_32_to_32( const SBlitJob * job )
942{ 942{
943 u32 *dst = (u32*) job->dst; 943 u32 *dst = (u32*) job->dst;
944 944
945 for ( s32 dy = 0; dy != job->height; ++dy ) 945 for ( s32 dy = 0; dy != job->height; ++dy )
946 { 946 {
947 memset32( dst, job->argb, job->srcPitch ); 947 memset32( dst, job->argb, job->srcPitch );
948 dst = (u32*) ( (u8*) (dst) + job->dstPitch ); 948 dst = (u32*) ( (u8*) (dst) + job->dstPitch );
949 } 949 }
950} 950}
951 951
952/*! 952/*!
953*/ 953*/
954static void executeBlit_ColorAlpha_16_to_16( const SBlitJob * job ) 954static void executeBlit_ColorAlpha_16_to_16( const SBlitJob * job )
955{ 955{
956 u16 *dst = (u16*) job->dst; 956 u16 *dst = (u16*) job->dst;
957 957
958 const u16 alpha = extractAlpha( job->argb ) >> 3; 958 const u16 alpha = extractAlpha( job->argb ) >> 3;
959 if ( 0 == alpha ) 959 if ( 0 == alpha )
960 return; 960 return;
961 const u32 src = video::A8R8G8B8toA1R5G5B5( job->argb ); 961 const u32 src = video::A8R8G8B8toA1R5G5B5( job->argb );
962 962
963 for ( s32 dy = 0; dy != job->height; ++dy ) 963 for ( s32 dy = 0; dy != job->height; ++dy )
964 { 964 {
965 for ( s32 dx = 0; dx != job->width; ++dx ) 965 for ( s32 dx = 0; dx != job->width; ++dx )
966 { 966 {
967 dst[dx] = 0x8000 | PixelBlend16( dst[dx], src, alpha ); 967 dst[dx] = 0x8000 | PixelBlend16( dst[dx], src, alpha );
968 } 968 }
969 dst = (u16*) ( (u8*) (dst) + job->dstPitch ); 969 dst = (u16*) ( (u8*) (dst) + job->dstPitch );
970 } 970 }
971} 971}
972 972
973/*! 973/*!
974*/ 974*/
975static void executeBlit_ColorAlpha_32_to_32( const SBlitJob * job ) 975static void executeBlit_ColorAlpha_32_to_32( const SBlitJob * job )
976{ 976{
977 u32 *dst = (u32*) job->dst; 977 u32 *dst = (u32*) job->dst;
978 978
979 const u32 alpha = extractAlpha( job->argb ); 979 const u32 alpha = extractAlpha( job->argb );
980 const u32 src = job->argb; 980 const u32 src = job->argb;
981 981
982 for ( s32 dy = 0; dy != job->height; ++dy ) 982 for ( s32 dy = 0; dy != job->height; ++dy )
983 { 983 {
984 for ( s32 dx = 0; dx != job->width; ++dx ) 984 for ( s32 dx = 0; dx != job->width; ++dx )
985 { 985 {
986 dst[dx] = (job->argb & 0xFF000000 ) | PixelBlend32( dst[dx], src, alpha ); 986 dst[dx] = (job->argb & 0xFF000000 ) | PixelBlend32( dst[dx], src, alpha );
987 } 987 }
988 dst = (u32*) ( (u8*) (dst) + job->dstPitch ); 988 dst = (u32*) ( (u8*) (dst) + job->dstPitch );
989 } 989 }
990} 990}
991 991
992// Blitter Operation 992// Blitter Operation
993enum eBlitter 993enum eBlitter
994{ 994{
995 BLITTER_INVALID = 0, 995 BLITTER_INVALID = 0,
996 BLITTER_COLOR, 996 BLITTER_COLOR,
997 BLITTER_COLOR_ALPHA, 997 BLITTER_COLOR_ALPHA,
998 BLITTER_TEXTURE, 998 BLITTER_TEXTURE,
999 BLITTER_TEXTURE_ALPHA_BLEND, 999 BLITTER_TEXTURE_ALPHA_BLEND,
1000 BLITTER_TEXTURE_ALPHA_COLOR_BLEND 1000 BLITTER_TEXTURE_ALPHA_COLOR_BLEND
1001}; 1001};
1002 1002
1003typedef void (*tExecuteBlit) ( const SBlitJob * job ); 1003typedef void (*tExecuteBlit) ( const SBlitJob * job );
1004 1004
1005 1005
1006/*! 1006/*!
1007*/ 1007*/
1008struct blitterTable 1008struct blitterTable
1009{ 1009{
1010 eBlitter operation; 1010 eBlitter operation;
1011 s32 destFormat; 1011 s32 destFormat;
1012 s32 sourceFormat; 1012 s32 sourceFormat;
1013 tExecuteBlit func; 1013 tExecuteBlit func;
1014}; 1014};
1015 1015
1016static const blitterTable blitTable[] = 1016static const blitterTable blitTable[] =
1017{ 1017{
1018 { BLITTER_TEXTURE, -2, -2, executeBlit_TextureCopy_x_to_x }, 1018 { BLITTER_TEXTURE, -2, -2, executeBlit_TextureCopy_x_to_x },
1019 { BLITTER_TEXTURE, video::ECF_A1R5G5B5, video::ECF_A8R8G8B8, executeBlit_TextureCopy_32_to_16 }, 1019 { BLITTER_TEXTURE, video::ECF_A1R5G5B5, video::ECF_A8R8G8B8, executeBlit_TextureCopy_32_to_16 },
1020 { BLITTER_TEXTURE, video::ECF_A1R5G5B5, video::ECF_R8G8B8, executeBlit_TextureCopy_24_to_16 }, 1020 { BLITTER_TEXTURE, video::ECF_A1R5G5B5, video::ECF_R8G8B8, executeBlit_TextureCopy_24_to_16 },
1021 { BLITTER_TEXTURE, video::ECF_A8R8G8B8, video::ECF_A1R5G5B5, executeBlit_TextureCopy_16_to_32 }, 1021 { BLITTER_TEXTURE, video::ECF_A8R8G8B8, video::ECF_A1R5G5B5, executeBlit_TextureCopy_16_to_32 },
1022 { BLITTER_TEXTURE, video::ECF_A8R8G8B8, video::ECF_R8G8B8, executeBlit_TextureCopy_24_to_32 }, 1022 { BLITTER_TEXTURE, video::ECF_A8R8G8B8, video::ECF_R8G8B8, executeBlit_TextureCopy_24_to_32 },
1023 { BLITTER_TEXTURE, video::ECF_R8G8B8, video::ECF_A1R5G5B5, executeBlit_TextureCopy_16_to_24 }, 1023 { BLITTER_TEXTURE, video::ECF_R8G8B8, video::ECF_A1R5G5B5, executeBlit_TextureCopy_16_to_24 },
1024 { BLITTER_TEXTURE, video::ECF_R8G8B8, video::ECF_A8R8G8B8, executeBlit_TextureCopy_32_to_24 }, 1024 { BLITTER_TEXTURE, video::ECF_R8G8B8, video::ECF_A8R8G8B8, executeBlit_TextureCopy_32_to_24 },
1025 { BLITTER_TEXTURE_ALPHA_BLEND, video::ECF_A1R5G5B5, video::ECF_A1R5G5B5, executeBlit_TextureBlend_16_to_16 }, 1025 { BLITTER_TEXTURE_ALPHA_BLEND, video::ECF_A1R5G5B5, video::ECF_A1R5G5B5, executeBlit_TextureBlend_16_to_16 },
1026 { BLITTER_TEXTURE_ALPHA_BLEND, video::ECF_A8R8G8B8, video::ECF_A8R8G8B8, executeBlit_TextureBlend_32_to_32 }, 1026 { BLITTER_TEXTURE_ALPHA_BLEND, video::ECF_A8R8G8B8, video::ECF_A8R8G8B8, executeBlit_TextureBlend_32_to_32 },
1027 { BLITTER_TEXTURE_ALPHA_COLOR_BLEND, video::ECF_A1R5G5B5, video::ECF_A1R5G5B5, executeBlit_TextureBlendColor_16_to_16 }, 1027 { BLITTER_TEXTURE_ALPHA_COLOR_BLEND, video::ECF_A1R5G5B5, video::ECF_A1R5G5B5, executeBlit_TextureBlendColor_16_to_16 },
1028 { BLITTER_TEXTURE_ALPHA_COLOR_BLEND, video::ECF_A8R8G8B8, video::ECF_A8R8G8B8, executeBlit_TextureBlendColor_32_to_32 }, 1028 { BLITTER_TEXTURE_ALPHA_COLOR_BLEND, video::ECF_A8R8G8B8, video::ECF_A8R8G8B8, executeBlit_TextureBlendColor_32_to_32 },
1029 { BLITTER_COLOR, video::ECF_A1R5G5B5, -1, executeBlit_Color_16_to_16 }, 1029 { BLITTER_COLOR, video::ECF_A1R5G5B5, -1, executeBlit_Color_16_to_16 },
1030 { BLITTER_COLOR, video::ECF_A8R8G8B8, -1, executeBlit_Color_32_to_32 }, 1030 { BLITTER_COLOR, video::ECF_A8R8G8B8, -1, executeBlit_Color_32_to_32 },
1031 { BLITTER_COLOR_ALPHA, video::ECF_A1R5G5B5, -1, executeBlit_ColorAlpha_16_to_16 }, 1031 { BLITTER_COLOR_ALPHA, video::ECF_A1R5G5B5, -1, executeBlit_ColorAlpha_16_to_16 },
1032 { BLITTER_COLOR_ALPHA, video::ECF_A8R8G8B8, -1, executeBlit_ColorAlpha_32_to_32 }, 1032 { BLITTER_COLOR_ALPHA, video::ECF_A8R8G8B8, -1, executeBlit_ColorAlpha_32_to_32 },
1033 { BLITTER_INVALID, -1, -1, 0 } 1033 { BLITTER_INVALID, -1, -1, 0 }
1034}; 1034};
1035 1035
1036 1036
1037static inline tExecuteBlit getBlitter2( eBlitter operation,const video::IImage * dest,const video::IImage * source ) 1037static inline tExecuteBlit getBlitter2( eBlitter operation,const video::IImage * dest,const video::IImage * source )
1038{ 1038{
1039 video::ECOLOR_FORMAT sourceFormat = (video::ECOLOR_FORMAT) ( source ? source->getColorFormat() : -1 ); 1039 video::ECOLOR_FORMAT sourceFormat = (video::ECOLOR_FORMAT) ( source ? source->getColorFormat() : -1 );
1040 video::ECOLOR_FORMAT destFormat = (video::ECOLOR_FORMAT) ( dest ? dest->getColorFormat() : -1 ); 1040 video::ECOLOR_FORMAT destFormat = (video::ECOLOR_FORMAT) ( dest ? dest->getColorFormat() : -1 );
1041 1041
1042 const blitterTable * b = blitTable; 1042 const blitterTable * b = blitTable;
1043 1043
1044 while ( b->operation != BLITTER_INVALID ) 1044 while ( b->operation != BLITTER_INVALID )
1045 { 1045 {
1046 if ( b->operation == operation ) 1046 if ( b->operation == operation )
1047 { 1047 {
1048 if (( b->destFormat == -1 || b->destFormat == destFormat ) && 1048 if (( b->destFormat == -1 || b->destFormat == destFormat ) &&
1049 ( b->sourceFormat == -1 || b->sourceFormat == sourceFormat ) ) 1049 ( b->sourceFormat == -1 || b->sourceFormat == sourceFormat ) )
1050 return b->func; 1050 return b->func;
1051 else 1051 else
1052 if ( b->destFormat == -2 && ( sourceFormat == destFormat ) ) 1052 if ( b->destFormat == -2 && ( sourceFormat == destFormat ) )
1053 return b->func; 1053 return b->func;
1054 } 1054 }
1055 b += 1; 1055 b += 1;
1056 } 1056 }
1057 return 0; 1057 return 0;
1058} 1058}
1059 1059
1060 1060
1061// bounce clipping to texture 1061// bounce clipping to texture
1062inline void setClip ( AbsRectangle &out, const core::rect<s32> *clip, 1062inline void setClip ( AbsRectangle &out, const core::rect<s32> *clip,
1063 const video::IImage * tex, s32 passnative ) 1063 const video::IImage * tex, s32 passnative )
1064{ 1064{
1065 if ( clip && 0 == tex && passnative ) 1065 if ( clip && 0 == tex && passnative )
1066 { 1066 {
1067 out.x0 = clip->UpperLeftCorner.X; 1067 out.x0 = clip->UpperLeftCorner.X;
1068 out.x1 = clip->LowerRightCorner.X; 1068 out.x1 = clip->LowerRightCorner.X;
1069 out.y0 = clip->UpperLeftCorner.Y; 1069 out.y0 = clip->UpperLeftCorner.Y;
1070 out.y1 = clip->LowerRightCorner.Y; 1070 out.y1 = clip->LowerRightCorner.Y;
1071 return; 1071 return;
1072 } 1072 }
1073 1073
1074 const s32 w = tex ? tex->getDimension().Width : 0; 1074 const s32 w = tex ? tex->getDimension().Width : 0;
1075 const s32 h = tex ? tex->getDimension().Height : 0; 1075 const s32 h = tex ? tex->getDimension().Height : 0;
1076 if ( clip ) 1076 if ( clip )
1077 { 1077 {
1078 out.x0 = core::s32_clamp ( clip->UpperLeftCorner.X, 0, w ); 1078 out.x0 = core::s32_clamp ( clip->UpperLeftCorner.X, 0, w );
1079 out.x1 = core::s32_clamp ( clip->LowerRightCorner.X, out.x0, w ); 1079 out.x1 = core::s32_clamp ( clip->LowerRightCorner.X, out.x0, w );
1080 out.y0 = core::s32_clamp ( clip->UpperLeftCorner.Y, 0, h ); 1080 out.y0 = core::s32_clamp ( clip->UpperLeftCorner.Y, 0, h );
1081 out.y1 = core::s32_clamp ( clip->LowerRightCorner.Y, out.y0, h ); 1081 out.y1 = core::s32_clamp ( clip->LowerRightCorner.Y, out.y0, h );
1082 } 1082 }
1083 else 1083 else
1084 { 1084 {
1085 out.x0 = 0; 1085 out.x0 = 0;
1086 out.y0 = 0; 1086 out.y0 = 0;
1087 out.x1 = w; 1087 out.x1 = w;
1088 out.y1 = h; 1088 out.y1 = h;
1089 } 1089 }
1090 1090
1091} 1091}
1092 1092
1093/*! 1093/*!
1094 a generic 2D Blitter 1094 a generic 2D Blitter
1095*/ 1095*/
1096static s32 Blit(eBlitter operation, 1096static s32 Blit(eBlitter operation,
1097 video::IImage * dest, 1097 video::IImage * dest,
1098 const core::rect<s32> *destClipping, 1098 const core::rect<s32> *destClipping,
1099 const core::position2d<s32> *destPos, 1099 const core::position2d<s32> *destPos,
1100 video::IImage * const source, 1100 video::IImage * const source,
1101 const core::rect<s32> *sourceClipping, 1101 const core::rect<s32> *sourceClipping,
1102 u32 argb) 1102 u32 argb)
1103{ 1103{
1104 tExecuteBlit blitter = getBlitter2( operation, dest, source ); 1104 tExecuteBlit blitter = getBlitter2( operation, dest, source );
1105 if ( 0 == blitter ) 1105 if ( 0 == blitter )
1106 { 1106 {
1107 return 0; 1107 return 0;
1108 } 1108 }
1109 1109
1110 // Clipping 1110 // Clipping
1111 AbsRectangle sourceClip; 1111 AbsRectangle sourceClip;
1112 AbsRectangle destClip; 1112 AbsRectangle destClip;
1113 AbsRectangle v; 1113 AbsRectangle v;
1114 1114
1115 SBlitJob job; 1115 SBlitJob job;
1116 1116
1117 setClip ( sourceClip, sourceClipping, source, 1 ); 1117 setClip ( sourceClip, sourceClipping, source, 1 );
1118 setClip ( destClip, destClipping, dest, 0 ); 1118 setClip ( destClip, destClipping, dest, 0 );
1119 1119
1120 v.x0 = destPos ? destPos->X : 0; 1120 v.x0 = destPos ? destPos->X : 0;
1121 v.y0 = destPos ? destPos->Y : 0; 1121 v.y0 = destPos ? destPos->Y : 0;
1122 v.x1 = v.x0 + ( sourceClip.x1 - sourceClip.x0 ); 1122 v.x1 = v.x0 + ( sourceClip.x1 - sourceClip.x0 );
1123 v.y1 = v.y0 + ( sourceClip.y1 - sourceClip.y0 ); 1123 v.y1 = v.y0 + ( sourceClip.y1 - sourceClip.y0 );
1124 1124
1125 if ( !intersect( job.Dest, destClip, v ) ) 1125 if ( !intersect( job.Dest, destClip, v ) )
1126 return 0; 1126 return 0;
1127 1127
1128 job.width = job.Dest.x1 - job.Dest.x0; 1128 job.width = job.Dest.x1 - job.Dest.x0;
1129 job.height = job.Dest.y1 - job.Dest.y0; 1129 job.height = job.Dest.y1 - job.Dest.y0;
1130 1130
1131 job.Source.x0 = sourceClip.x0 + ( job.Dest.x0 - v.x0 ); 1131 job.Source.x0 = sourceClip.x0 + ( job.Dest.x0 - v.x0 );
1132 job.Source.x1 = job.Source.x0 + job.width; 1132 job.Source.x1 = job.Source.x0 + job.width;
1133 job.Source.y0 = sourceClip.y0 + ( job.Dest.y0 - v.y0 ); 1133 job.Source.y0 = sourceClip.y0 + ( job.Dest.y0 - v.y0 );
1134 job.Source.y1 = job.Source.y0 + job.height; 1134 job.Source.y1 = job.Source.y0 + job.height;
1135 1135
1136 job.argb = argb; 1136 job.argb = argb;
1137 1137
1138 if ( source ) 1138 if ( source )
1139 { 1139 {
1140 job.srcPitch = source->getPitch(); 1140 job.srcPitch = source->getPitch();
1141 job.srcPixelMul = source->getBytesPerPixel(); 1141 job.srcPixelMul = source->getBytesPerPixel();
1142 job.src = (void*) ( (u8*) source->lock() + ( job.Source.y0 * job.srcPitch ) + ( job.Source.x0 * job.srcPixelMul ) ); 1142 job.src = (void*) ( (u8*) source->lock() + ( job.Source.y0 * job.srcPitch ) + ( job.Source.x0 * job.srcPixelMul ) );
1143 } 1143 }
1144 else 1144 else
1145 { 1145 {
1146 // use srcPitch for color operation on dest 1146 // use srcPitch for color operation on dest
1147 job.srcPitch = job.width * dest->getBytesPerPixel(); 1147 job.srcPitch = job.width * dest->getBytesPerPixel();
1148 } 1148 }
1149 1149
1150 job.dstPitch = dest->getPitch(); 1150 job.dstPitch = dest->getPitch();
1151 job.dstPixelMul = dest->getBytesPerPixel(); 1151 job.dstPixelMul = dest->getBytesPerPixel();
1152 job.dst = (void*) ( (u8*) dest->lock() + ( job.Dest.y0 * job.dstPitch ) + ( job.Dest.x0 * job.dstPixelMul ) ); 1152 job.dst = (void*) ( (u8*) dest->lock() + ( job.Dest.y0 * job.dstPitch ) + ( job.Dest.x0 * job.dstPixelMul ) );
1153 1153
1154 blitter( &job ); 1154 blitter( &job );
1155 1155
1156 if ( source ) 1156 if ( source )
1157 source->unlock(); 1157 source->unlock();
1158 1158
1159 if ( dest ) 1159 if ( dest )
1160 dest->unlock(); 1160 dest->unlock();
1161 1161
1162 return 1; 1162 return 1;
1163} 1163}
1164 1164
1165static s32 StretchBlit(eBlitter operation, 1165static s32 StretchBlit(eBlitter operation,
1166 video::IImage* dest, const core::rect<s32> *destRect, 1166 video::IImage* dest, const core::rect<s32> *destRect,
1167 const core::rect<s32> *srcRect, video::IImage* const source, 1167 const core::rect<s32> *srcRect, video::IImage* const source,
1168 u32 argb) 1168 u32 argb)
1169{ 1169{
1170 tExecuteBlit blitter = getBlitter2( operation, dest, source ); 1170 tExecuteBlit blitter = getBlitter2( operation, dest, source );
1171 if ( 0 == blitter ) 1171 if ( 0 == blitter )
1172 { 1172 {
1173 return 0; 1173 return 0;
1174 } 1174 }
1175 1175
1176 SBlitJob job; 1176 SBlitJob job;
1177 1177
1178 // Clipping 1178 // Clipping
1179 setClip ( job.Source, srcRect, source, 1 ); 1179 setClip ( job.Source, srcRect, source, 1 );
1180 setClip ( job.Dest, destRect, dest, 0 ); 1180 setClip ( job.Dest, destRect, dest, 0 );
1181 1181
1182 job.width = job.Dest.x1-job.Dest.x0; 1182 job.width = job.Dest.x1-job.Dest.x0;
1183 job.height = job.Dest.y1-job.Dest.y0; 1183 job.height = job.Dest.y1-job.Dest.y0;
1184 1184
1185 job.argb = argb; 1185 job.argb = argb;
1186 1186
1187 // use original dest size, despite any clipping 1187 // use original dest size, despite any clipping
1188 job.x_stretch = (float)destRect->getWidth() / (float)(job.Source.x1-job.Source.x0); 1188 job.x_stretch = (float)destRect->getWidth() / (float)(job.Source.x1-job.Source.x0);
1189 job.y_stretch = (float)destRect->getHeight() / (float)(job.Source.y1-job.Source.y0); 1189 job.y_stretch = (float)destRect->getHeight() / (float)(job.Source.y1-job.Source.y0);
1190 job.stretch = (job.x_stretch != 1.f) || (job.y_stretch != 1.f); 1190 job.stretch = (job.x_stretch != 1.f) || (job.y_stretch != 1.f);
1191 1191
1192 if ( source ) 1192 if ( source )
1193 { 1193 {
1194 job.srcPitch = source->getPitch(); 1194 job.srcPitch = source->getPitch();
1195 job.srcPixelMul = source->getBytesPerPixel(); 1195 job.srcPixelMul = source->getBytesPerPixel();
1196 job.src = (void*) ( (u8*) source->lock() + ( job.Source.y0 * job.srcPitch ) + ( job.Source.x0 * job.srcPixelMul ) ); 1196 job.src = (void*) ( (u8*) source->lock() + ( job.Source.y0 * job.srcPitch ) + ( job.Source.x0 * job.srcPixelMul ) );
1197 } 1197 }
1198 else 1198 else
1199 { 1199 {
1200 // use srcPitch for color operation on dest 1200 // use srcPitch for color operation on dest
1201 job.srcPitch = job.width * dest->getBytesPerPixel(); 1201 job.srcPitch = job.width * dest->getBytesPerPixel();
1202 } 1202 }
1203 1203
1204 job.dstPitch = dest->getPitch(); 1204 job.dstPitch = dest->getPitch();
1205 job.dstPixelMul = dest->getBytesPerPixel(); 1205 job.dstPixelMul = dest->getBytesPerPixel();
1206 job.dst = (void*) ( (u8*) dest->lock() + ( job.Dest.y0 * job.dstPitch ) + ( job.Dest.x0 * job.dstPixelMul ) ); 1206 job.dst = (void*) ( (u8*) dest->lock() + ( job.Dest.y0 * job.dstPitch ) + ( job.Dest.x0 * job.dstPixelMul ) );
1207 1207
1208 blitter( &job ); 1208 blitter( &job );
1209 1209
1210 if ( source ) 1210 if ( source )
1211 source->unlock(); 1211 source->unlock();
1212 1212
1213 if ( dest ) 1213 if ( dest )
1214 dest->unlock(); 1214 dest->unlock();
1215 1215
1216 return 1; 1216 return 1;
1217} 1217}
1218 1218
1219 1219
1220// Methods for Software drivers 1220// Methods for Software drivers
1221//! draws a rectangle 1221//! draws a rectangle
1222static void drawRectangle(video::IImage* img, const core::rect<s32>& rect, const video::SColor &color) 1222static void drawRectangle(video::IImage* img, const core::rect<s32>& rect, const video::SColor &color)
1223{ 1223{
1224 Blit(color.getAlpha() == 0xFF ? BLITTER_COLOR : BLITTER_COLOR_ALPHA, 1224 Blit(color.getAlpha() == 0xFF ? BLITTER_COLOR : BLITTER_COLOR_ALPHA,
1225 img, 0, &rect.UpperLeftCorner, 0, &rect, color.color); 1225 img, 0, &rect.UpperLeftCorner, 0, &rect, color.color);
1226} 1226}
1227 1227
1228 1228
1229//! draws a line from to with color 1229//! draws a line from to with color
1230static void drawLine(video::IImage* img, const core::position2d<s32>& from, 1230static void drawLine(video::IImage* img, const core::position2d<s32>& from,
1231 const core::position2d<s32>& to, const video::SColor &color) 1231 const core::position2d<s32>& to, const video::SColor &color)
1232{ 1232{
1233 AbsRectangle clip; 1233 AbsRectangle clip;
1234 GetClip(clip, img); 1234 GetClip(clip, img);
1235 1235
1236 core::position2d<s32> p[2]; 1236 core::position2d<s32> p[2];
1237 if (ClipLine( clip, p[0], p[1], from, to)) 1237 if (ClipLine( clip, p[0], p[1], from, to))
1238 { 1238 {
1239 u32 alpha = extractAlpha(color.color); 1239 u32 alpha = extractAlpha(color.color);
1240 1240
1241 switch(img->getColorFormat()) 1241 switch(img->getColorFormat())
1242 { 1242 {
1243 case video::ECF_A1R5G5B5: 1243 case video::ECF_A1R5G5B5:
1244 if (alpha == 256) 1244 if (alpha == 256)
1245 { 1245 {
1246 RenderLine16_Decal(img, p[0], p[1], video::A8R8G8B8toA1R5G5B5(color.color)); 1246 RenderLine16_Decal(img, p[0], p[1], video::A8R8G8B8toA1R5G5B5(color.color));
1247 } 1247 }
1248 else 1248 else
1249 { 1249 {
1250 RenderLine16_Blend(img, p[0], p[1], video::A8R8G8B8toA1R5G5B5(color.color), alpha >> 3); 1250 RenderLine16_Blend(img, p[0], p[1], video::A8R8G8B8toA1R5G5B5(color.color), alpha >> 3);
1251 } 1251 }
1252 break; 1252 break;
1253 case video::ECF_A8R8G8B8: 1253 case video::ECF_A8R8G8B8:
1254 if (alpha == 256) 1254 if (alpha == 256)
1255 { 1255 {
1256 RenderLine32_Decal(img, p[0], p[1], color.color); 1256 RenderLine32_Decal(img, p[0], p[1], color.color);
1257 } 1257 }
1258 else 1258 else
1259 { 1259 {
1260 RenderLine32_Blend(img, p[0], p[1], color.color, alpha); 1260 RenderLine32_Blend(img, p[0], p[1], color.color, alpha);
1261 } 1261 }
1262 break; 1262 break;
1263 default: 1263 default:
1264 break; 1264 break;
1265 } 1265 }
1266 } 1266 }
1267} 1267}
1268 1268
1269 1269
1270} 1270}
1271 1271
1272#endif 1272#endif
1273 1273
generated by cgit v1.1 at 2024-07-06 16:02:05 +0000