zenilib: zenilib/jni/external/sdl/src/render/software/SDL_blendline.c Source File

zenilib 0.5.3.0

- Main Page
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
SDL_blendline.c
Go to the documentation of this file.
1 /*
2 Simple DirectMedia Layer
3 Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
4
5 This software is provided 'as-is', without any express or implied
6 warranty. In no event will the authors be held liable for any damages
7 arising from the use of this software.
8
9 Permission is granted to anyone to use this software for any purpose,
10 including commercial applications, and to alter it and redistribute it
11 freely, subject to the following restrictions:
12
13 1. The origin of this software must not be misrepresented; you must not
14 claim that you wrote the original software. If you use this software
15 in a product, an acknowledgment in the product documentation would be
16 appreciated but is not required.
17 2. Altered source versions must be plainly marked as such, and must not be
18 misrepresented as being the original software.
19 3. This notice may not be removed or altered from any source distribution.
20 */
21 #include "SDL_config.h"
22
23 #if !SDL_RENDER_DISABLED
24
25 #include "SDL_draw.h"
26 #include "SDL_blendline.h"
27 #include "SDL_blendpoint.h"
28
29
30 static void
31 SDL_BlendLine_RGB2(SDL_Surface * dst, int x1, int y1, int x2, int y2,
32 SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
33 SDL_bool draw_end)
34 {
35 const SDL_PixelFormat *fmt = dst->format;
36 unsigned r, g, b, a, inva;
37
38 if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
39 r = DRAW_MUL(_r, _a);
40 g = DRAW_MUL(_g, _a);
41 b = DRAW_MUL(_b, _a);
42 a = _a;
43 } else {
44 r = _r;
45 g = _g;
46 b = _b;
47 a = _a;
48 }
49 inva = (a ^ 0xff);
50
51 if (y1 == y2) {
52 switch (blendMode) {
53 case SDL_BLENDMODE_BLEND:
54 HLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB, draw_end);
55 break;
56 case SDL_BLENDMODE_ADD:
57 HLINE(Uint16, DRAW_SETPIXEL_ADD_RGB, draw_end);
58 break;
59 case SDL_BLENDMODE_MOD:
60 HLINE(Uint16, DRAW_SETPIXEL_MOD_RGB, draw_end);
61 break;
62 default:
63 HLINE(Uint16, DRAW_SETPIXEL_RGB, draw_end);
64 break;
65 }
66 } else if (x1 == x2) {
67 switch (blendMode) {
68 case SDL_BLENDMODE_BLEND:
69 VLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB, draw_end);
70 break;
71 case SDL_BLENDMODE_ADD:
72 VLINE(Uint16, DRAW_SETPIXEL_ADD_RGB, draw_end);
73 break;
74 case SDL_BLENDMODE_MOD:
75 VLINE(Uint16, DRAW_SETPIXEL_MOD_RGB, draw_end);
76 break;
77 default:
78 VLINE(Uint16, DRAW_SETPIXEL_RGB, draw_end);
79 break;
80 }
81 } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
82 switch (blendMode) {
83 case SDL_BLENDMODE_BLEND:
84 DLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB, draw_end);
85 break;
86 case SDL_BLENDMODE_ADD:
87 DLINE(Uint16, DRAW_SETPIXEL_ADD_RGB, draw_end);
88 break;
89 case SDL_BLENDMODE_MOD:
90 DLINE(Uint16, DRAW_SETPIXEL_MOD_RGB, draw_end);
91 break;
92 default:
93 DLINE(Uint16, DRAW_SETPIXEL_RGB, draw_end);
94 break;
95 }
96 } else {
97 switch (blendMode) {
98 case SDL_BLENDMODE_BLEND:
99 AALINE(x1, y1, x2, y2,
100 DRAW_SETPIXELXY2_BLEND_RGB, DRAW_SETPIXELXY2_BLEND_RGB,
101 draw_end);
102 break;
103 case SDL_BLENDMODE_ADD:
104 AALINE(x1, y1, x2, y2,
105 DRAW_SETPIXELXY2_ADD_RGB, DRAW_SETPIXELXY2_ADD_RGB,
106 draw_end);
107 break;
108 case SDL_BLENDMODE_MOD:
109 AALINE(x1, y1, x2, y2,
110 DRAW_SETPIXELXY2_MOD_RGB, DRAW_SETPIXELXY2_MOD_RGB,
111 draw_end);
112 break;
113 default:
114 AALINE(x1, y1, x2, y2,
115 DRAW_SETPIXELXY2_RGB, DRAW_SETPIXELXY2_BLEND_RGB,
116 draw_end);
117 break;
118 }
119 }
120 }
121
122 static void
123 SDL_BlendLine_RGB555(SDL_Surface * dst, int x1, int y1, int x2, int y2,
124 SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
125 SDL_bool draw_end)
126 {
127 unsigned r, g, b, a, inva;
128
129 if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
130 r = DRAW_MUL(_r, _a);
131 g = DRAW_MUL(_g, _a);
132 b = DRAW_MUL(_b, _a);
133 a = _a;
134 } else {
135 r = _r;
136 g = _g;
137 b = _b;
138 a = _a;
139 }
140 inva = (a ^ 0xff);
141
142 if (y1 == y2) {
143 switch (blendMode) {
144 case SDL_BLENDMODE_BLEND:
145 HLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB555, draw_end);
146 break;
147 case SDL_BLENDMODE_ADD:
148 HLINE(Uint16, DRAW_SETPIXEL_ADD_RGB555, draw_end);
149 break;
150 case SDL_BLENDMODE_MOD:
151 HLINE(Uint16, DRAW_SETPIXEL_MOD_RGB555, draw_end);
152 break;
153 default:
154 HLINE(Uint16, DRAW_SETPIXEL_RGB555, draw_end);
155 break;
156 }
157 } else if (x1 == x2) {
158 switch (blendMode) {
159 case SDL_BLENDMODE_BLEND:
160 VLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB555, draw_end);
161 break;
162 case SDL_BLENDMODE_ADD:
163 VLINE(Uint16, DRAW_SETPIXEL_ADD_RGB555, draw_end);
164 break;
165 case SDL_BLENDMODE_MOD:
166 VLINE(Uint16, DRAW_SETPIXEL_MOD_RGB555, draw_end);
167 break;
168 default:
169 VLINE(Uint16, DRAW_SETPIXEL_RGB555, draw_end);
170 break;
171 }
172 } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
173 switch (blendMode) {
174 case SDL_BLENDMODE_BLEND:
175 DLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB555, draw_end);
176 break;
177 case SDL_BLENDMODE_ADD:
178 DLINE(Uint16, DRAW_SETPIXEL_ADD_RGB555, draw_end);
179 break;
180 case SDL_BLENDMODE_MOD:
181 DLINE(Uint16, DRAW_SETPIXEL_MOD_RGB555, draw_end);
182 break;
183 default:
184 DLINE(Uint16, DRAW_SETPIXEL_RGB555, draw_end);
185 break;
186 }
187 } else {
188 switch (blendMode) {
189 case SDL_BLENDMODE_BLEND:
190 AALINE(x1, y1, x2, y2,
191 DRAW_SETPIXELXY_BLEND_RGB555, DRAW_SETPIXELXY_BLEND_RGB555,
192 draw_end);
193 break;
194 case SDL_BLENDMODE_ADD:
195 AALINE(x1, y1, x2, y2,
196 DRAW_SETPIXELXY_ADD_RGB555, DRAW_SETPIXELXY_ADD_RGB555,
197 draw_end);
198 break;
199 case SDL_BLENDMODE_MOD:
200 AALINE(x1, y1, x2, y2,
201 DRAW_SETPIXELXY_MOD_RGB555, DRAW_SETPIXELXY_MOD_RGB555,
202 draw_end);
203 break;
204 default:
205 AALINE(x1, y1, x2, y2,
206 DRAW_SETPIXELXY_RGB555, DRAW_SETPIXELXY_BLEND_RGB555,
207 draw_end);
208 break;
209 }
210 }
211 }
212
213 static void
214 SDL_BlendLine_RGB565(SDL_Surface * dst, int x1, int y1, int x2, int y2,
215 SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
216 SDL_bool draw_end)
217 {
218 unsigned r, g, b, a, inva;
219
220 if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
221 r = DRAW_MUL(_r, _a);
222 g = DRAW_MUL(_g, _a);
223 b = DRAW_MUL(_b, _a);
224 a = _a;
225 } else {
226 r = _r;
227 g = _g;
228 b = _b;
229 a = _a;
230 }
231 inva = (a ^ 0xff);
232
233 if (y1 == y2) {
234 switch (blendMode) {
235 case SDL_BLENDMODE_BLEND:
236 HLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB565, draw_end);
237 break;
238 case SDL_BLENDMODE_ADD:
239 HLINE(Uint16, DRAW_SETPIXEL_ADD_RGB565, draw_end);
240 break;
241 case SDL_BLENDMODE_MOD:
242 HLINE(Uint16, DRAW_SETPIXEL_MOD_RGB565, draw_end);
243 break;
244 default:
245 HLINE(Uint16, DRAW_SETPIXEL_RGB565, draw_end);
246 break;
247 }
248 } else if (x1 == x2) {
249 switch (blendMode) {
250 case SDL_BLENDMODE_BLEND:
251 VLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB565, draw_end);
252 break;
253 case SDL_BLENDMODE_ADD:
254 VLINE(Uint16, DRAW_SETPIXEL_ADD_RGB565, draw_end);
255 break;
256 case SDL_BLENDMODE_MOD:
257 VLINE(Uint16, DRAW_SETPIXEL_MOD_RGB565, draw_end);
258 break;
259 default:
260 VLINE(Uint16, DRAW_SETPIXEL_RGB565, draw_end);
261 break;
262 }
263 } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
264 switch (blendMode) {
265 case SDL_BLENDMODE_BLEND:
266 DLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB565, draw_end);
267 break;
268 case SDL_BLENDMODE_ADD:
269 DLINE(Uint16, DRAW_SETPIXEL_ADD_RGB565, draw_end);
270 break;
271 case SDL_BLENDMODE_MOD:
272 DLINE(Uint16, DRAW_SETPIXEL_MOD_RGB565, draw_end);
273 break;
274 default:
275 DLINE(Uint16, DRAW_SETPIXEL_RGB565, draw_end);
276 break;
277 }
278 } else {
279 switch (blendMode) {
280 case SDL_BLENDMODE_BLEND:
281 AALINE(x1, y1, x2, y2,
282 DRAW_SETPIXELXY_BLEND_RGB565, DRAW_SETPIXELXY_BLEND_RGB565,
283 draw_end);
284 break;
285 case SDL_BLENDMODE_ADD:
286 AALINE(x1, y1, x2, y2,
287 DRAW_SETPIXELXY_ADD_RGB565, DRAW_SETPIXELXY_ADD_RGB565,
288 draw_end);
289 break;
290 case SDL_BLENDMODE_MOD:
291 AALINE(x1, y1, x2, y2,
292 DRAW_SETPIXELXY_MOD_RGB565, DRAW_SETPIXELXY_MOD_RGB565,
293 draw_end);
294 break;
295 default:
296 AALINE(x1, y1, x2, y2,
297 DRAW_SETPIXELXY_RGB565, DRAW_SETPIXELXY_BLEND_RGB565,
298 draw_end);
299 break;
300 }
301 }
302 }
303
304 static void
305 SDL_BlendLine_RGB4(SDL_Surface * dst, int x1, int y1, int x2, int y2,
306 SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
307 SDL_bool draw_end)
308 {
309 const SDL_PixelFormat *fmt = dst->format;
310 unsigned r, g, b, a, inva;
311
312 if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
313 r = DRAW_MUL(_r, _a);
314 g = DRAW_MUL(_g, _a);
315 b = DRAW_MUL(_b, _a);
316 a = _a;
317 } else {
318 r = _r;
319 g = _g;
320 b = _b;
321 a = _a;
322 }
323 inva = (a ^ 0xff);
324
325 if (y1 == y2) {
326 switch (blendMode) {
327 case SDL_BLENDMODE_BLEND:
328 HLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB, draw_end);
329 break;
330 case SDL_BLENDMODE_ADD:
331 HLINE(Uint32, DRAW_SETPIXEL_ADD_RGB, draw_end);
332 break;
333 case SDL_BLENDMODE_MOD:
334 HLINE(Uint32, DRAW_SETPIXEL_MOD_RGB, draw_end);
335 break;
336 default:
337 HLINE(Uint32, DRAW_SETPIXEL_RGB, draw_end);
338 break;
339 }
340 } else if (x1 == x2) {
341 switch (blendMode) {
342 case SDL_BLENDMODE_BLEND:
343 VLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB, draw_end);
344 break;
345 case SDL_BLENDMODE_ADD:
346 VLINE(Uint32, DRAW_SETPIXEL_ADD_RGB, draw_end);
347 break;
348 case SDL_BLENDMODE_MOD:
349 VLINE(Uint32, DRAW_SETPIXEL_MOD_RGB, draw_end);
350 break;
351 default:
352 VLINE(Uint32, DRAW_SETPIXEL_RGB, draw_end);
353 break;
354 }
355 } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
356 switch (blendMode) {
357 case SDL_BLENDMODE_BLEND:
358 DLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB, draw_end);
359 break;
360 case SDL_BLENDMODE_ADD:
361 DLINE(Uint32, DRAW_SETPIXEL_ADD_RGB, draw_end);
362 break;
363 case SDL_BLENDMODE_MOD:
364 DLINE(Uint32, DRAW_SETPIXEL_MOD_RGB, draw_end);
365 break;
366 default:
367 DLINE(Uint32, DRAW_SETPIXEL_RGB, draw_end);
368 break;
369 }
370 } else {
371 switch (blendMode) {
372 case SDL_BLENDMODE_BLEND:
373 AALINE(x1, y1, x2, y2,
374 DRAW_SETPIXELXY4_BLEND_RGB, DRAW_SETPIXELXY4_BLEND_RGB,
375 draw_end);
376 break;
377 case SDL_BLENDMODE_ADD:
378 AALINE(x1, y1, x2, y2,
379 DRAW_SETPIXELXY4_ADD_RGB, DRAW_SETPIXELXY4_ADD_RGB,
380 draw_end);
381 break;
382 case SDL_BLENDMODE_MOD:
383 AALINE(x1, y1, x2, y2,
384 DRAW_SETPIXELXY4_MOD_RGB, DRAW_SETPIXELXY4_MOD_RGB,
385 draw_end);
386 break;
387 default:
388 AALINE(x1, y1, x2, y2,
389 DRAW_SETPIXELXY4_RGB, DRAW_SETPIXELXY4_BLEND_RGB,
390 draw_end);
391 break;
392 }
393 }
394 }
395
396 static void
397 SDL_BlendLine_RGBA4(SDL_Surface * dst, int x1, int y1, int x2, int y2,
398 SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
399 SDL_bool draw_end)
400 {
401 const SDL_PixelFormat *fmt = dst->format;
402 unsigned r, g, b, a, inva;
403
404 if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
405 r = DRAW_MUL(_r, _a);
406 g = DRAW_MUL(_g, _a);
407 b = DRAW_MUL(_b, _a);
408 a = _a;
409 } else {
410 r = _r;
411 g = _g;
412 b = _b;
413 a = _a;
414 }
415 inva = (a ^ 0xff);
416
417 if (y1 == y2) {
418 switch (blendMode) {
419 case SDL_BLENDMODE_BLEND:
420 HLINE(Uint32, DRAW_SETPIXEL_BLEND_RGBA, draw_end);
421 break;
422 case SDL_BLENDMODE_ADD:
423 HLINE(Uint32, DRAW_SETPIXEL_ADD_RGBA, draw_end);
424 break;
425 case SDL_BLENDMODE_MOD:
426 HLINE(Uint32, DRAW_SETPIXEL_MOD_RGBA, draw_end);
427 break;
428 default:
429 HLINE(Uint32, DRAW_SETPIXEL_RGBA, draw_end);
430 break;
431 }
432 } else if (x1 == x2) {
433 switch (blendMode) {
434 case SDL_BLENDMODE_BLEND:
435 VLINE(Uint32, DRAW_SETPIXEL_BLEND_RGBA, draw_end);
436 break;
437 case SDL_BLENDMODE_ADD:
438 VLINE(Uint32, DRAW_SETPIXEL_ADD_RGBA, draw_end);
439 break;
440 case SDL_BLENDMODE_MOD:
441 VLINE(Uint32, DRAW_SETPIXEL_MOD_RGBA, draw_end);
442 break;
443 default:
444 VLINE(Uint32, DRAW_SETPIXEL_RGBA, draw_end);
445 break;
446 }
447 } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
448 switch (blendMode) {
449 case SDL_BLENDMODE_BLEND:
450 DLINE(Uint32, DRAW_SETPIXEL_BLEND_RGBA, draw_end);
451 break;
452 case SDL_BLENDMODE_ADD:
453 DLINE(Uint32, DRAW_SETPIXEL_ADD_RGBA, draw_end);
454 break;
455 case SDL_BLENDMODE_MOD:
456 DLINE(Uint32, DRAW_SETPIXEL_MOD_RGBA, draw_end);
457 break;
458 default:
459 DLINE(Uint32, DRAW_SETPIXEL_RGBA, draw_end);
460 break;
461 }
462 } else {
463 switch (blendMode) {
464 case SDL_BLENDMODE_BLEND:
465 AALINE(x1, y1, x2, y2,
466 DRAW_SETPIXELXY4_BLEND_RGBA, DRAW_SETPIXELXY4_BLEND_RGBA,
467 draw_end);
468 break;
469 case SDL_BLENDMODE_ADD:
470 AALINE(x1, y1, x2, y2,
471 DRAW_SETPIXELXY4_ADD_RGBA, DRAW_SETPIXELXY4_ADD_RGBA,
472 draw_end);
473 break;
474 case SDL_BLENDMODE_MOD:
475 AALINE(x1, y1, x2, y2,
476 DRAW_SETPIXELXY4_MOD_RGBA, DRAW_SETPIXELXY4_MOD_RGBA,
477 draw_end);
478 break;
479 default:
480 AALINE(x1, y1, x2, y2,
481 DRAW_SETPIXELXY4_RGBA, DRAW_SETPIXELXY4_BLEND_RGBA,
482 draw_end);
483 break;
484 }
485 }
486 }
487
488 static void
489 SDL_BlendLine_RGB888(SDL_Surface * dst, int x1, int y1, int x2, int y2,
490 SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
491 SDL_bool draw_end)
492 {
493 unsigned r, g, b, a, inva;
494
495 if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
496 r = DRAW_MUL(_r, _a);
497 g = DRAW_MUL(_g, _a);
498 b = DRAW_MUL(_b, _a);
499 a = _a;
500 } else {
501 r = _r;
502 g = _g;
503 b = _b;
504 a = _a;
505 }
506 inva = (a ^ 0xff);
507
508 if (y1 == y2) {
509 switch (blendMode) {
510 case SDL_BLENDMODE_BLEND:
511 HLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB888, draw_end);
512 break;
513 case SDL_BLENDMODE_ADD:
514 HLINE(Uint32, DRAW_SETPIXEL_ADD_RGB888, draw_end);
515 break;
516 case SDL_BLENDMODE_MOD:
517 HLINE(Uint32, DRAW_SETPIXEL_MOD_RGB888, draw_end);
518 break;
519 default:
520 HLINE(Uint32, DRAW_SETPIXEL_RGB888, draw_end);
521 break;
522 }
523 } else if (x1 == x2) {
524 switch (blendMode) {
525 case SDL_BLENDMODE_BLEND:
526 VLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB888, draw_end);
527 break;
528 case SDL_BLENDMODE_ADD:
529 VLINE(Uint32, DRAW_SETPIXEL_ADD_RGB888, draw_end);
530 break;
531 case SDL_BLENDMODE_MOD:
532 VLINE(Uint32, DRAW_SETPIXEL_MOD_RGB888, draw_end);
533 break;
534 default:
535 VLINE(Uint32, DRAW_SETPIXEL_RGB888, draw_end);
536 break;
537 }
538 } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
539 switch (blendMode) {
540 case SDL_BLENDMODE_BLEND:
541 DLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB888, draw_end);
542 break;
543 case SDL_BLENDMODE_ADD:
544 DLINE(Uint32, DRAW_SETPIXEL_ADD_RGB888, draw_end);
545 break;
546 case SDL_BLENDMODE_MOD:
547 DLINE(Uint32, DRAW_SETPIXEL_MOD_RGB888, draw_end);
548 break;
549 default:
550 DLINE(Uint32, DRAW_SETPIXEL_RGB888, draw_end);
551 break;
552 }
553 } else {
554 switch (blendMode) {
555 case SDL_BLENDMODE_BLEND:
556 AALINE(x1, y1, x2, y2,
557 DRAW_SETPIXELXY_BLEND_RGB888, DRAW_SETPIXELXY_BLEND_RGB888,
558 draw_end);
559 break;
560 case SDL_BLENDMODE_ADD:
561 AALINE(x1, y1, x2, y2,
562 DRAW_SETPIXELXY_ADD_RGB888, DRAW_SETPIXELXY_ADD_RGB888,
563 draw_end);
564 break;
565 case SDL_BLENDMODE_MOD:
566 AALINE(x1, y1, x2, y2,
567 DRAW_SETPIXELXY_MOD_RGB888, DRAW_SETPIXELXY_MOD_RGB888,
568 draw_end);
569 break;
570 default:
571 AALINE(x1, y1, x2, y2,
572 DRAW_SETPIXELXY_RGB888, DRAW_SETPIXELXY_BLEND_RGB888,
573 draw_end);
574 break;
575 }
576 }
577 }
578
579 static void
580 SDL_BlendLine_ARGB8888(SDL_Surface * dst, int x1, int y1, int x2, int y2,
581 SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
582 SDL_bool draw_end)
583 {
584 unsigned r, g, b, a, inva;
585
586 if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
587 r = DRAW_MUL(_r, _a);
588 g = DRAW_MUL(_g, _a);
589 b = DRAW_MUL(_b, _a);
590 a = _a;
591 } else {
592 r = _r;
593 g = _g;
594 b = _b;
595 a = _a;
596 }
597 inva = (a ^ 0xff);
598
599 if (y1 == y2) {
600 switch (blendMode) {
601 case SDL_BLENDMODE_BLEND:
602 HLINE(Uint32, DRAW_SETPIXEL_BLEND_ARGB8888, draw_end);
603 break;
604 case SDL_BLENDMODE_ADD:
605 HLINE(Uint32, DRAW_SETPIXEL_ADD_ARGB8888, draw_end);
606 break;
607 case SDL_BLENDMODE_MOD:
608 HLINE(Uint32, DRAW_SETPIXEL_MOD_ARGB8888, draw_end);
609 break;
610 default:
611 HLINE(Uint32, DRAW_SETPIXEL_ARGB8888, draw_end);
612 break;
613 }
614 } else if (x1 == x2) {
615 switch (blendMode) {
616 case SDL_BLENDMODE_BLEND:
617 VLINE(Uint32, DRAW_SETPIXEL_BLEND_ARGB8888, draw_end);
618 break;
619 case SDL_BLENDMODE_ADD:
620 VLINE(Uint32, DRAW_SETPIXEL_ADD_ARGB8888, draw_end);
621 break;
622 case SDL_BLENDMODE_MOD:
623 VLINE(Uint32, DRAW_SETPIXEL_MOD_ARGB8888, draw_end);
624 break;
625 default:
626 VLINE(Uint32, DRAW_SETPIXEL_ARGB8888, draw_end);
627 break;
628 }
629 } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
630 switch (blendMode) {
631 case SDL_BLENDMODE_BLEND:
632 DLINE(Uint32, DRAW_SETPIXEL_BLEND_ARGB8888, draw_end);
633 break;
634 case SDL_BLENDMODE_ADD:
635 DLINE(Uint32, DRAW_SETPIXEL_ADD_ARGB8888, draw_end);
636 break;
637 case SDL_BLENDMODE_MOD:
638 DLINE(Uint32, DRAW_SETPIXEL_MOD_ARGB8888, draw_end);
639 break;
640 default:
641 DLINE(Uint32, DRAW_SETPIXEL_ARGB8888, draw_end);
642 break;
643 }
644 } else {
645 switch (blendMode) {
646 case SDL_BLENDMODE_BLEND:
647 AALINE(x1, y1, x2, y2,
648 DRAW_SETPIXELXY_BLEND_ARGB8888, DRAW_SETPIXELXY_BLEND_ARGB8888,
649 draw_end);
650 break;
651 case SDL_BLENDMODE_ADD:
652 AALINE(x1, y1, x2, y2,
653 DRAW_SETPIXELXY_ADD_ARGB8888, DRAW_SETPIXELXY_ADD_ARGB8888,
654 draw_end);
655 break;
656 case SDL_BLENDMODE_MOD:
657 AALINE(x1, y1, x2, y2,
658 DRAW_SETPIXELXY_MOD_ARGB8888, DRAW_SETPIXELXY_MOD_ARGB8888,
659 draw_end);
660 break;
661 default:
662 AALINE(x1, y1, x2, y2,
663 DRAW_SETPIXELXY_ARGB8888, DRAW_SETPIXELXY_BLEND_ARGB8888,
664 draw_end);
665 break;
666 }
667 }
668 }
669
670 typedef void (*BlendLineFunc) (SDL_Surface * dst,
671 int x1, int y1, int x2, int y2,
672 SDL_BlendMode blendMode,
673 Uint8 r, Uint8 g, Uint8 b, Uint8 a,
674 SDL_bool draw_end);
675
676 static BlendLineFunc
677 SDL_CalculateBlendLineFunc(const SDL_PixelFormat * fmt)
678 {
679 switch (fmt->BytesPerPixel) {
680 case 2:
681 if (fmt->Rmask == 0x7C00) {
682 return SDL_BlendLine_RGB555;
683 } else if (fmt->Rmask == 0xF800) {
684 return SDL_BlendLine_RGB565;
685 } else {
686 return SDL_BlendLine_RGB2;
687 }
688 break;
689 case 4:
690 if (fmt->Rmask == 0x00FF0000) {
691 if (fmt->Amask) {
692 return SDL_BlendLine_ARGB8888;
693 } else {
694 return SDL_BlendLine_RGB888;
695 }
696 } else {
697 if (fmt->Amask) {
698 return SDL_BlendLine_RGBA4;
699 } else {
700 return SDL_BlendLine_RGB4;
701 }
702 }
703 }
704 return NULL;
705 }
706
707 int
708 SDL_BlendLine(SDL_Surface * dst, int x1, int y1, int x2, int y2,
709 SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
710 {
711 BlendLineFunc func;
712
713 if (!dst) {
714 return SDL_SetError("SDL_BlendLine(): Passed NULL destination surface");
715 }
716
717 func = SDL_CalculateBlendLineFunc(dst->format);
718 if (!func) {
719 return SDL_SetError("SDL_BlendLine(): Unsupported surface format");
720 }
721
722 /* Perform clipping */
723 /* FIXME: We don't actually want to clip, as it may change line slope */
724 if (!SDL_IntersectRectAndLine(&dst->clip_rect, &x1, &y1, &x2, &y2)) {
725 return 0;
726 }
727
728 func(dst, x1, y1, x2, y2, blendMode, r, g, b, a, SDL_TRUE);
729 return 0;
730 }
731
732 int
733 SDL_BlendLines(SDL_Surface * dst, const SDL_Point * points, int count,
734 SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
735 {
736 int i;
737 int x1, y1;
738 int x2, y2;
739 SDL_bool draw_end;
740 BlendLineFunc func;
741
742 if (!dst) {
743 return SDL_SetError("SDL_BlendLines(): Passed NULL destination surface");
744 }
745
746 func = SDL_CalculateBlendLineFunc(dst->format);
747 if (!func) {
748 return SDL_SetError("SDL_BlendLines(): Unsupported surface format");
749 }
750
751 for (i = 1; i < count; ++i) {
752 x1 = points[i-1].x;
753 y1 = points[i-1].y;
754 x2 = points[i].x;
755 y2 = points[i].y;
756
757 /* Perform clipping */
758 /* FIXME: We don't actually want to clip, as it may change line slope */
759 if (!SDL_IntersectRectAndLine(&dst->clip_rect, &x1, &y1, &x2, &y2)) {
760 continue;
761 }
762
763 /* Draw the end if it was clipped */
764 draw_end = (x2 != points[i].x || y2 != points[i].y);
765
766 func(dst, x1, y1, x2, y2, blendMode, r, g, b, a, draw_end);
767 }
768 if (points[0].x != points[count-1].x || points[0].y != points[count-1].y) {
769 SDL_BlendPoint(dst, points[count-1].x, points[count-1].y,
770 blendMode, r, g, b, a);
771 }
772 return 0;
773 }
774
775 #endif /* !SDL_RENDER_DISABLED */
776
777 /* vi: set ts=4 sw=4 expandtab: */
DRAW_SETPIXELXY2_RGB
#define DRAW_SETPIXELXY2_RGB(x, y)
Definition: SDL_draw.h:232
DRAW_SETPIXELXY4_MOD_RGB
#define DRAW_SETPIXELXY4_MOD_RGB(x, y)
Definition: SDL_draw.h:253
DRAW_SETPIXEL_BLEND_ARGB8888
#define DRAW_SETPIXEL_BLEND_ARGB8888
Definition: SDL_draw.h:189
SDL_IntersectRectAndLine
DECLSPEC SDL_bool SDLCALL SDL_IntersectRectAndLine(const SDL_Rect *rect, int *X1, int *Y1, int *X2, int *Y2)
Calculate the intersection of a rectangle and line segment.
Definition: SDL_rect.c:316
DRAW_SETPIXEL_MOD_ARGB8888
#define DRAW_SETPIXEL_MOD_ARGB8888
Definition: SDL_draw.h:197
DRAW_SETPIXELXY_RGB565
#define DRAW_SETPIXELXY_RGB565(x, y)
Definition: SDL_draw.h:139
BlendLineFunc
void(* BlendLineFunc)(SDL_Surface *dst, int x1, int y1, int x2, int y2, SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a, SDL_bool draw_end)
Definition: SDL_blendline.c:670
DRAW_SETPIXELXY_ADD_RGB888
#define DRAW_SETPIXELXY_ADD_RGB888(x, y)
Definition: SDL_draw.h:176
void
GLvoid **typedef void(GLAPIENTRY *PFNGLGETVERTEXATTRIBDVPROC)(GLuint
Definition: glew.h:1824
SDL_CalculateBlendLineFunc
static BlendLineFunc SDL_CalculateBlendLineFunc(const SDL_PixelFormat *fmt)
Definition: SDL_blendline.c:677
SDL_BlendMode
SDL_BlendMode
The blend mode used in SDL_RenderCopy() and drawing operations.
Definition: SDL_blendmode.h:40
DRAW_SETPIXEL_MOD_RGB565
#define DRAW_SETPIXEL_MOD_RGB565
Definition: SDL_draw.h:135
g
GLboolean GLboolean g
Definition: glew.h:8736
NULL
#define NULL
Definition: ftobjs.h:61
DRAW_SETPIXEL_RGBA
#define DRAW_SETPIXEL_RGBA
Definition: SDL_draw.h:261
SDL_BlendLine_RGBA4
static void SDL_BlendLine_RGBA4(SDL_Surface *dst, int x1, int y1, int x2, int y2, SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a, SDL_bool draw_end)
Definition: SDL_blendline.c:397
SDL_PixelFormat::BytesPerPixel
Uint8 BytesPerPixel
Definition: SDL_pixels.h:277
SDL_bool
SDL_bool
Definition: SDL_stdinc.h:116
DRAW_SETPIXELXY4_RGBA
#define DRAW_SETPIXELXY4_RGBA(x, y)
Definition: SDL_draw.h:276
DRAW_SETPIXEL_ADD_RGB565
#define DRAW_SETPIXEL_ADD_RGB565
Definition: SDL_draw.h:131
SDL_TRUE
Definition: SDL_stdinc.h:119
DRAW_SETPIXELXY2_BLEND_RGB
#define DRAW_SETPIXELXY2_BLEND_RGB(x, y)
Definition: SDL_draw.h:238
VLINE
#define VLINE(type, op, draw_end)
Definition: SDL_draw.h:317
x
EGLSurface EGLint x
Definition: eglext.h:293
SDL_Point
The structure that defines a point.
Definition: SDL_rect.h:47
DRAW_SETPIXEL_MOD_RGB
#define DRAW_SETPIXEL_MOD_RGB
Definition: SDL_draw.h:228
SDL_Surface
A collection of pixels used in software blitting.
Definition: SDL_surface.h:69
SDL_BlendLine_RGB555
static void SDL_BlendLine_RGB555(SDL_Surface *dst, int x1, int y1, int x2, int y2, SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a, SDL_bool draw_end)
Definition: SDL_blendline.c:123
DRAW_SETPIXELXY4_ADD_RGBA
#define DRAW_SETPIXELXY4_ADD_RGBA(x, y)
Definition: SDL_draw.h:282
DRAW_SETPIXEL_ADD_RGB888
#define DRAW_SETPIXEL_ADD_RGB888
Definition: SDL_draw.h:162
a
GLboolean GLboolean GLboolean GLboolean a
Definition: glew.h:8736
DRAW_SETPIXELXY_MOD_ARGB8888
#define DRAW_SETPIXELXY_MOD_ARGB8888(x, y)
Definition: SDL_draw.h:210
ABS
#define ABS(_x)
Definition: SDL_gamecontroller.c:34
DLINE
#define DLINE(type, op, draw_end)
Definition: SDL_draw.h:339
HLINE
#define HLINE(type, op, draw_end)
Definition: SDL_draw.h:295
DRAW_SETPIXELXY4_MOD_RGBA
#define DRAW_SETPIXELXY4_MOD_RGBA(x, y)
Definition: SDL_draw.h:285
func
GLenum func
Definition: SDL_opengl.h:5654
y1
GLuint GLfloat GLfloat GLfloat GLfloat y1
Definition: glew.h:11582
y2
GLfixed GLfixed GLfixed y2
Definition: glext.h:4559
SDL_config.h
DRAW_SETPIXEL_BLEND_RGB888
#define DRAW_SETPIXEL_BLEND_RGB888
Definition: SDL_draw.h:158
SDL_BlendLine_RGB4
static void SDL_BlendLine_RGB4(SDL_Surface *dst, int x1, int y1, int x2, int y2, SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a, SDL_bool draw_end)
Definition: SDL_blendline.c:305
DRAW_SETPIXEL_RGB
#define DRAW_SETPIXEL_RGB
Definition: SDL_draw.h:217
SDL_blendpoint.h
Uint32
uint32_t Uint32
An unsigned 32-bit integer type.
Definition: SDL_stdinc.h:145
SDL_Point::x
int x
Definition: SDL_rect.h:49
DRAW_SETPIXEL_BLEND_RGB555
#define DRAW_SETPIXEL_BLEND_RGB555
Definition: SDL_draw.h:96
DRAW_SETPIXEL_ADD_RGB555
#define DRAW_SETPIXEL_ADD_RGB555
Definition: SDL_draw.h:100
SDL_BlendLine_RGB888
static void SDL_BlendLine_RGB888(SDL_Surface *dst, int x1, int y1, int x2, int y2, SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a, SDL_bool draw_end)
Definition: SDL_blendline.c:489
dst
GLenum GLenum dst
Definition: glew.h:2396
SDL_Point::y
int y
Definition: SDL_rect.h:50
SDL_BlendLine
int SDL_BlendLine(SDL_Surface *dst, int x1, int y1, int x2, int y2, SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
Definition: SDL_blendline.c:708
DRAW_SETPIXELXY_BLEND_RGB888
#define DRAW_SETPIXELXY_BLEND_RGB888(x, y)
Definition: SDL_draw.h:173
count
GLint GLsizei count
Definition: gl2ext.h:1011
DRAW_SETPIXELXY_BLEND_RGB555
#define DRAW_SETPIXELXY_BLEND_RGB555(x, y)
Definition: SDL_draw.h:111
DRAW_SETPIXELXY_ARGB8888
#define DRAW_SETPIXELXY_ARGB8888(x, y)
Definition: SDL_draw.h:201
DRAW_SETPIXELXY_MOD_RGB555
#define DRAW_SETPIXELXY_MOD_RGB555(x, y)
Definition: SDL_draw.h:117
SDL_SetError
DECLSPEC int SDLCALL SDL_SetError(const char *fmt,...)
Definition: SDL_error.c:53
SDL_BlendLines
int SDL_BlendLines(SDL_Surface *dst, const SDL_Point *points, int count, SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
Definition: SDL_blendline.c:733
DRAW_SETPIXEL_ARGB8888
#define DRAW_SETPIXEL_ARGB8888
Definition: SDL_draw.h:186
DRAW_SETPIXELXY4_BLEND_RGB
#define DRAW_SETPIXELXY4_BLEND_RGB(x, y)
Definition: SDL_draw.h:241
DRAW_SETPIXEL_RGB888
#define DRAW_SETPIXEL_RGB888
Definition: SDL_draw.h:155
DRAW_SETPIXELXY_ADD_RGB555
#define DRAW_SETPIXELXY_ADD_RGB555(x, y)
Definition: SDL_draw.h:114
SDL_Surface::clip_rect
SDL_Rect clip_rect
Definition: SDL_surface.h:85
x1
GLuint GLfloat GLfloat GLfloat x1
Definition: glew.h:11582
SDL_BLENDMODE_MOD
Definition: SDL_blendmode.h:50
y
EGLSurface EGLint EGLint y
Definition: eglext.h:293
DRAW_SETPIXEL_ADD_RGB
#define DRAW_SETPIXEL_ADD_RGB
Definition: SDL_draw.h:224
DRAW_SETPIXEL_BLEND_RGB565
#define DRAW_SETPIXEL_BLEND_RGB565
Definition: SDL_draw.h:127
SDL_Surface::format
SDL_PixelFormat * format
Definition: SDL_surface.h:72
SDL_BlendLine_ARGB8888
static void SDL_BlendLine_ARGB8888(SDL_Surface *dst, int x1, int y1, int x2, int y2, SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a, SDL_bool draw_end)
Definition: SDL_blendline.c:580
SDL_PixelFormat::Rmask
Uint32 Rmask
Definition: SDL_pixels.h:279
SDL_BlendLine_RGB2
static void SDL_BlendLine_RGB2(SDL_Surface *dst, int x1, int y1, int x2, int y2, SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a, SDL_bool draw_end)
Definition: SDL_blendline.c:31
AALINE
#define AALINE(x1, y1, x2, y2, opaque_op, blend_op, draw_end)
Definition: SDL_draw.h:546
DRAW_SETPIXELXY_MOD_RGB888
#define DRAW_SETPIXELXY_MOD_RGB888(x, y)
Definition: SDL_draw.h:179
DRAW_SETPIXEL_RGB565
#define DRAW_SETPIXEL_RGB565
Definition: SDL_draw.h:124
Uint8
uint8_t Uint8
An unsigned 8-bit integer type.
Definition: SDL_stdinc.h:129
DRAW_SETPIXEL_BLEND_RGB
#define DRAW_SETPIXEL_BLEND_RGB
Definition: SDL_draw.h:220
SDL_PixelFormat
Definition: SDL_pixels.h:272
x2
GLfixed GLfixed x2
Definition: glext.h:4559
DRAW_SETPIXELXY_MOD_RGB565
#define DRAW_SETPIXELXY_MOD_RGB565(x, y)
Definition: SDL_draw.h:148
SDL_BlendPoint
int SDL_BlendPoint(SDL_Surface *dst, int x, int y, SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
Definition: SDL_blendpoint.c:196
r
GLdouble GLdouble GLdouble r
Definition: glew.h:1392
DRAW_SETPIXEL_MOD_RGB555
#define DRAW_SETPIXEL_MOD_RGB555
Definition: SDL_draw.h:104
DRAW_SETPIXEL_RGB555
#define DRAW_SETPIXEL_RGB555
Definition: SDL_draw.h:93
b
GLdouble GLdouble GLdouble b
Definition: glew.h:8383
DRAW_SETPIXEL_ADD_RGBA
#define DRAW_SETPIXEL_ADD_RGBA
Definition: SDL_draw.h:268
SDL_BlendLine_RGB565
static void SDL_BlendLine_RGB565(SDL_Surface *dst, int x1, int y1, int x2, int y2, SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a, SDL_bool draw_end)
Definition: SDL_blendline.c:214
SDL_blendline.h
Uint16
uint16_t Uint16
An unsigned 16-bit integer type.
Definition: SDL_stdinc.h:137
DRAW_SETPIXELXY2_ADD_RGB
#define DRAW_SETPIXELXY2_ADD_RGB(x, y)
Definition: SDL_draw.h:244
points
GLuint GLdouble GLdouble GLint GLint const GLdouble * points
Definition: glew.h:3337
DRAW_SETPIXELXY_RGB555
#define DRAW_SETPIXELXY_RGB555(x, y)
Definition: SDL_draw.h:108
SDL_PixelFormat::Amask
Uint32 Amask
Definition: SDL_pixels.h:282
DRAW_SETPIXELXY_BLEND_RGB565
#define DRAW_SETPIXELXY_BLEND_RGB565(x, y)
Definition: SDL_draw.h:142
DRAW_SETPIXELXY4_ADD_RGB
#define DRAW_SETPIXELXY4_ADD_RGB(x, y)
Definition: SDL_draw.h:247
DRAW_SETPIXELXY_RGB888
#define DRAW_SETPIXELXY_RGB888(x, y)
Definition: SDL_draw.h:170
i
int i
Definition: pngrutil.c:1377
SDL_BLENDMODE_ADD
Definition: SDL_blendmode.h:47
DRAW_SETPIXELXY4_BLEND_RGBA
#define DRAW_SETPIXELXY4_BLEND_RGBA(x, y)
Definition: SDL_draw.h:279
SDL_draw.h
SDL_BLENDMODE_BLEND
Definition: SDL_blendmode.h:44
DRAW_SETPIXELXY_BLEND_ARGB8888
#define DRAW_SETPIXELXY_BLEND_ARGB8888(x, y)
Definition: SDL_draw.h:204
DRAW_SETPIXELXY_ADD_ARGB8888
#define DRAW_SETPIXELXY_ADD_ARGB8888(x, y)
Definition: SDL_draw.h:207
DRAW_SETPIXELXY4_RGB
#define DRAW_SETPIXELXY4_RGB(x, y)
Definition: SDL_draw.h:235
DRAW_SETPIXEL_ADD_ARGB8888
#define DRAW_SETPIXEL_ADD_ARGB8888
Definition: SDL_draw.h:193
DRAW_SETPIXEL_MOD_RGBA
#define DRAW_SETPIXEL_MOD_RGBA
Definition: SDL_draw.h:272
DRAW_SETPIXEL_MOD_RGB888
#define DRAW_SETPIXEL_MOD_RGB888
Definition: SDL_draw.h:166
DRAW_SETPIXEL_BLEND_RGBA
#define DRAW_SETPIXEL_BLEND_RGBA
Definition: SDL_draw.h:264
DRAW_MUL
#define DRAW_MUL(_a, _b)
Definition: SDL_draw.h:29
DRAW_SETPIXELXY_ADD_RGB565
#define DRAW_SETPIXELXY_ADD_RGB565(x, y)
Definition: SDL_draw.h:145
DRAW_SETPIXELXY2_MOD_RGB
#define DRAW_SETPIXELXY2_MOD_RGB(x, y)
Definition: SDL_draw.h:250