[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Stratagus-CVS] stratagus/src include/video.h video/sprite.c
|
From: |
address@hidden |
|
Subject: |
[Stratagus-CVS] stratagus/src include/video.h video/sprite.c |
|
Date: |
16 Dec 2003 22:02:23 +1100 |
CVSROOT: /home/strat
Module name: stratagus
Changes by: <address@hidden> 03/12/16 22:02:23
Modified files:
src/include : video.h
src/video : sprite.c
Log message:
Added support for 50 % translucide functions
Patches:
Index: stratagus/src/include/video.h
diff -u stratagus/src/include/video.h:1.103 stratagus/src/include/video.h:1.104
--- stratagus/src/include/video.h:1.103 Sun Dec 14 07:54:16 2003
+++ stratagus/src/include/video.h Tue Dec 16 22:02:22 2003
@@ -26,7 +26,7 @@
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
// 02111-1307, USA.
//
-// $Id: video.h,v 1.103 2003/12/13 20:54:16 jsalmon3 Exp $
+// $Id: video.h,v 1.104 2003/12/16 11:02:22 mohydine Exp $
#ifndef __VIDEO_H__
#define __VIDEO_H__
@@ -106,6 +106,17 @@
void (*DrawClip)(const Graphic* o, unsigned f, int x, int y);
/// Draw the object clipped and flipped in X direction.
void (*DrawClipX)(const Graphic* o, unsigned f, int x, int y);
+
+ ///50% Translucide functions
+ /// Draw the object unclipped.
+ void (*DrawTrans50)(const Graphic* o, unsigned f, int x, int y);
+ /// Draw the object unclipped and flipped in X direction.
+ void (*DrawXTrans50)(const Graphic* o, unsigned f, int x, int y);
+ /// Draw the object clipped to the current clipping.
+ void (*DrawClipTrans50)(const Graphic* o, unsigned f, int x, int y);
+ /// Draw the object clipped and flipped in X direction.
+ void (*DrawClipXTrans50)(const Graphic* o, unsigned f, int x, int y);
+
/// Draw the shadow object clipped to the current clipping.
void (*DrawShadowClip)(const Graphic* o, unsigned f, int x, int y);
/// Draw the shadow object clipped and flipped in X direction.
@@ -676,6 +687,16 @@
void (*DrawClip)(const Graphic* o, unsigned f, int x, int y);
/// Draw the object clipped and flipped in X direction.
void (*DrawClipX)(const Graphic* o, unsigned f, int x, int y);
+
+ ///50% Translucide functions
+ void (*DrawTrans50)(const Graphic* o, unsigned f, int x, int y);
+ /// Draw the object unclipped and flipped in X direction.
+ void (*DrawXTrans50)(const Graphic* o, unsigned f, int x, int y);
+ /// Draw the object clipped to the current clipping.
+ void (*DrawClipTrans50)(const Graphic* o, unsigned f, int x, int y);
+ /// Draw the object clipped and flipped in X direction.
+ void (*DrawClipXTrans50)(const Graphic* o, unsigned f, int x, int y);
+
/// Draw the shadow object clipped to the current clipping.
void (*DrawShadowClip)(const Graphic* o, unsigned f, int x, int y);
/// Draw the shadow object clipped and flipped in X direction.
@@ -1117,6 +1138,18 @@
/// Draw a graphic object clipped and flipped in X direction.
#define VideoDrawClipX(o, f, x, y) ((o)->Type->DrawClipX)((o), (f), (x),
(y))
/// Draw a shadow graphic object clipped to the current clipping.
+
+ ///Translucide Functions
+ /// Draw a graphic object unclipped.
+#define VideoDrawTrans50(o, f, x, y) ((o)->Type->DrawTrans50)((o), (f), (x),
(y))
+ /// Draw a graphic object unclipped and flipped in X direction.
+#define VideoDrawXTrans50(o, f, x, y) ((o)->Type->DrawXTrans50)((o), (f),
(x), (y))
+ /// Draw a graphic object clipped to the current clipping.
+#define VideoDrawClipTrans50(o, f, x, y)
((o)->Type->DrawClipTrans50)((o), (f), (x), (y))
+ /// Draw a graphic object clipped and flipped in X direction.
+#define VideoDrawClipXTrans50(o, f, x, y)
((o)->Type->DrawClipXTrans50)((o), (f), (x), (y))
+ /// Draw a shadow graphic object clipped to the current clipping.
+
#define VideoDrawShadowClip(o, f, x, y)
((o)->Type->DrawShadowClip)((o),(f),(x),(y))
/// Draw a shadow graphic object clipped and flipped in X direction.
#define VideoDrawShadowClipX(o, f, x, y)
((o)->Type->DrawShadowClipX)((o),(f),(x),(y))
Index: stratagus/src/video/sprite.c
diff -u stratagus/src/video/sprite.c:1.55 stratagus/src/video/sprite.c:1.56
--- stratagus/src/video/sprite.c:1.55 Sun Dec 14 07:54:18 2003
+++ stratagus/src/video/sprite.c Tue Dec 16 22:02:22 2003
@@ -27,7 +27,7 @@
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
// 02111-1307, USA.
//
-// $Id: sprite.c,v 1.55 2003/12/13 20:54:18 jsalmon3 Exp $
+// $Id: sprite.c,v 1.56 2003/12/16 11:02:22 mohydine Exp $
//@{
@@ -1734,6 +1734,1291 @@
}
}
}
+///
*******************************************************************************************
+/// Begining of 50% Transparent functions
+///
*******************************************************************************************
+/**
+** Draw 8bit graphic object unclipped and flipped in X direction
+** into 8 bit framebuffer.
+**
+** @param sprite pointer to object
+** @param frame number of frame (object index)
+** @param x x coordinate on the screen
+** @param y y coordinate on the screen
+*/
+local void VideoDraw8to8XTrans50(const Graphic* sprite, unsigned frame, int x,
int y)
+{
+ const unsigned char* sp;
+ unsigned w;
+ VMemType8* dp;
+ const VMemType8* lp;
+ const VMemType8* ep;
+ const VMemType8* pp;
+ const VMemType8* pixels;
+ unsigned da;
+
+ pixels = (VMemType8*)sprite->Pixels;
+ sp = ((unsigned char**)sprite->Frames)[frame];
+ w = sprite->Width;
+ dp = VideoMemory8 + x + y * VideoWidth + w - 1;
+ da = VideoWidth + w;
+ ep = dp + VideoWidth * sprite->Height;
+ do {
+ lp = dp - w;
+ do { // 1 line
+ dp -= *sp++; // transparent
+ pp = dp + 1 - *sp++; // opaque
+ while (dp > pp) { // unrolled
+ *dp-- = pixels[*sp++];
+ *dp-- = pixels[*sp++];
+ }
+ if (dp >= pp) {
+ *dp-- = pixels[*sp++];
+ }
+ } while (dp > lp);
+ dp += da;
+ } while (dp < ep); // all lines
+}
+
+/**
+** Draw 8bit graphic object unclipped and flipped in X direction
+** into 16 bit framebuffer.
+**
+** @param sprite pointer to object
+** @param frame number of frame (object index)
+** @param x x coordinate on the screen
+** @param y y coordinate on the screen
+*/
+local void VideoDraw8to16XTrans50(const Graphic* sprite, unsigned frame, int
x, int y)
+{
+ const unsigned char* sp;
+ unsigned w;
+ VMemType16* dp;
+ const VMemType16* lp;
+ const VMemType16* ep;
+ const VMemType16* pp;
+ const VMemType16* pixels;
+ unsigned da;
+
+ pixels = (VMemType16*)sprite->Pixels;
+ sp = ((unsigned char**)sprite->Frames)[frame];
+ w = sprite->Width;
+ dp = VideoMemory16 + x + y * VideoWidth + w - 1;
+ da = VideoWidth + w;
+ ep = dp + VideoWidth * sprite->Height;
+
+ do {
+ lp = dp - w;
+ do { // 1 line
+ dp -= *sp++; // transparent
+ pp = dp + 1 - *sp++; // opaque
+ while (dp > pp) { // unrolled
+ *dp-- = pixels[*sp++];
+ *dp-- = pixels[*sp++];
+ }
+ if (dp >= pp) {
+ *dp-- = pixels[*sp++];
+ }
+ } while (dp > lp);
+ dp += da;
+ } while (dp < ep); // all lines
+}
+
+/**
+** Draw 8bit graphic object unclipped and flipped in X direction
+** into 24 bit framebuffer.
+**
+** @param sprite pointer to object
+** @param frame number of frame (object index)
+** @param x x coordinate on the screen
+** @param y y coordinate on the screen
+*/
+local void VideoDraw8to24XTrans50(const Graphic* sprite, unsigned frame, int
x, int y)
+{
+ const unsigned char* sp;
+ unsigned w;
+ VMemType24* dp;
+ const VMemType24* lp;
+ const VMemType24* ep;
+ const VMemType24* pp;
+ const VMemType24* pixels;
+ unsigned da;
+
+ pixels = (VMemType24*)sprite->Pixels;
+ sp = ((unsigned char**)sprite->Frames)[frame];
+ w = sprite->Width;
+ dp = VideoMemory24 + x + y * VideoWidth + w - 1;
+ da = VideoWidth + w;
+ ep = dp + VideoWidth * sprite->Height;
+
+ do {
+ lp = dp - w;
+ do { // 1 line
+ dp -= *sp++; // transparent
+ pp = dp + 1 - *sp++; // opaque
+ while (dp > pp) { // unrolled
+ *dp-- = pixels[*sp++];
+ *dp-- = pixels[*sp++];
+ }
+ if (dp >= pp) {
+ *dp-- = pixels[*sp++];
+ }
+ } while (dp > lp);
+ dp += da;
+ } while (dp < ep); // all lines
+}
+
+/**
+** Draw 8bit graphic object unclipped and flipped in X direction
+** into 32 bit framebuffer.
+**
+** @param sprite pointer to object
+** @param frame number of frame (object index)
+** @param x x coordinate on the screen
+** @param y y coordinate on the screen
+*/
+local void VideoDraw8to32XTrans50(const Graphic* sprite, unsigned frame, int
x, int y)
+{
+ const unsigned char* sp;
+ unsigned w;
+ VMemType32* dp;
+ const VMemType32* lp;
+ const VMemType32* ep;
+ const VMemType32* pp;
+ const VMemType32* pixels;
+ unsigned da;
+
+ pixels = (VMemType32*)sprite->Pixels;
+ sp = ((unsigned char**)sprite->Frames)[frame];
+ w = sprite->Width;
+ dp = VideoMemory32 + x + y * VideoWidth + w - 1;
+ da = VideoWidth + w;
+ ep = dp + VideoWidth * sprite->Height;
+
+ do {
+ lp = dp - w;
+ do { // 1 line
+ dp -= *sp++; // transparent
+ pp = dp + 1 - *sp++; // opaque
+ while (dp > pp) { // unrolled
+ *dp-- = pixels[*sp++];
+ *dp-- = pixels[*sp++];
+ }
+ if (dp >= pp) {
+ *dp-- = pixels[*sp++];
+ }
+ } while (dp > lp);
+ dp += da;
+ } while (dp < ep); // all lines
+}
+
+
+/**
+** Draw 8bit graphic object clipped into 8 bit framebuffer.
+**
+** @param sprite pointer to object
+** @param frame number of frame (object index)
+** @param x x coordinate on the screen
+** @param y y coordinate on the screen
+*/
+local void VideoDraw8to8ClipTrans50(const Graphic* sprite, unsigned frame, int
x, int y)
+{
+ int ox;
+ int ex;
+ int oy;
+ int w;
+ int h;
+ const unsigned char* sp;
+ int sw;
+ VMemType8* dp;
+ const VMemType8* lp;
+ const VMemType8* ep;
+ VMemType8* pp;
+ const VMemType8* pixels;
+ int da;
+
+
+ //
+ // reduce to visible range
+ //
+ sw = w = sprite->Width;
+ h = sprite->Height;
+ CLIP_RECTANGLE_OFS(x, y, w, h, ox, oy, ex);
+
+ //
+ // Draw the clipped sprite
+ //
+ pixels = (VMemType8*)sprite->Pixels;
+ sp = ((unsigned char**)sprite->Frames)[frame];
+
+ //
+ // Skip top lines, if needed.
+ //
+ while (oy--) {
+ da = 0;
+ do {
+ da += *sp++; // transparent
+ da += *sp; // opaque
+ sp += *sp + 1;
+ } while (da < sw);
+ }
+
+ da = VideoWidth - sw;
+ dp = VideoMemory8 + x + y * VideoWidth;
+ ep = dp + VideoWidth * h;
+
+ if (w == sw) { // Unclipped horizontal
+
+ do {
+ lp = dp + sw;
+ do { // 1 line
+ dp += *sp++; // transparent
+ pp = dp - 1 + *sp++; // opaque
+ while (dp < pp) { // unroll
+ *dp++ = pixels[*sp++];
+ *dp++ = pixels[*sp++];
+ }
+ if (dp <= pp) {
+ *dp++ = pixels[*sp++];
+ }
+ } while (dp < lp);
+ dp += da;
+ } while (dp < ep); // all lines
+
+ } else { // Clip horizontal
+
+ da += ox;
+ do {
+ lp = dp + w;
+ //
+ // Clip left
+ //
+ pp = dp - ox;
+ for (;;) {
+ pp += *sp++; // transparent
+ if (pp >= dp) {
+ dp = pp;
+ goto middle_trans;
+ }
+ pp += *sp; // opaque
+ if (pp >= dp) {
+ sp += *sp - (pp - dp) + 1;
+ goto middle_pixel;
+ }
+ sp += *sp + 1;
+ }
+
+ //
+ // Draw middle
+ //
+ for (;;) {
+ dp += *sp++; // transparent
+middle_trans:
+ if (dp >= lp) {
+ lp += sw - w - ox;
+ goto right_trans;
+ }
+ pp = dp + *sp++; // opaque
+middle_pixel:
+ if (pp < lp) {
+ while (dp < pp) {
+ *dp++ = pixels[*sp++];
+ }
+ continue;
+ }
+ while (dp < lp) {
+ *dp++ = pixels[*sp++];
+ }
+ sp += pp - dp;
+ dp = pp;
+ break;
+ }
+
+ //
+ // Clip right
+ //
+ lp += sw - w - ox;
+ while (dp < lp) {
+ dp += *sp++; // transparent
+right_trans:
+ dp += *sp; // opaque
+ sp += *sp + 1;
+ }
+ dp += da;
+ } while (dp < ep); // all lines
+
+ }
+}
+
+/**
+** Draw 8bit graphic object clipped into 16 bit framebuffer.
+**
+** @param sprite pointer to object
+** @param frame number of frame (object index)
+** @param x x coordinate on the screen
+** @param y y coordinate on the screen
+*/
+local void VideoDraw8to16ClipTrans50(const Graphic* sprite, unsigned frame,
int x, int y)
+{
+ int ox;
+ int ex;
+ int oy;
+ int w;
+ int h;
+ const unsigned char* sp;
+ int sw;
+ VMemType16* dp;
+ const VMemType16* lp;
+ const VMemType16* ep;
+ VMemType16* pp;
+ const VMemType16* pixels;
+ int da;
+
+//Added by Mohydine
+
+ VMemType16* p;
+ p = VideoMemory16 + y * VideoWidth + x;
+
+//Added by Mohydine
+ //
+ // reduce to visible range
+ //
+ sw = w = sprite->Width;
+ h = sprite->Height;
+ CLIP_RECTANGLE_OFS(x, y, w, h, ox, oy, ex);
+
+
+ //
+ // Draw the clipped sprite
+ //
+ pixels = (VMemType16*)sprite->Pixels;
+ sp = ((unsigned char**)sprite->Frames)[frame];
+
+ //
+ // Skip top lines, if needed.
+ //
+ while (oy--) {
+ da = 0;
+ do {
+ da += *sp++; // transparent
+ da += *sp; // opaque
+ sp += *sp + 1;
+ } while (da < sw);
+ }
+
+ da = VideoWidth - sw;
+ dp = VideoMemory16 + x + y * VideoWidth;
+ ep = dp + VideoWidth * h;
+
+ if (w == sw) { // Unclipped horizontal
+
+ do {
+ lp = dp + sw;
+ do { // 1 line
+ dp += *sp++; // transparent
+ pp = dp - 1 + *sp++; // opaque
+ while (dp < pp) { // unroll
+ *dp++ = ((*dp >> 1) & 0x7BEF) +((pixels[*sp++] >> 1) &
0x7BEF);
+ *dp++ = ((*dp >> 1) & 0x7BEF) +((pixels[*sp++] >> 1) &
0x7BEF);
+ //*dp++ = ((*dp >> 2) & 0x79E7) + ((pixels[*sp] >> 2)
& 0x79E7) +((pixels[*sp++] >> 1) & 0x7BEF);
+ //*dp++ = ((*dp >> 2) & 0x79E7) + ((pixels[*sp] >> 2) &
0x79E7) +((pixels[*sp++] >> 1) & 0x7BEF);
+ }
+ if (dp <= pp) {
+ *dp++ = ((*dp >> 1) & 0x7BEF) + ((pixels[*sp++] >> 1) &
0x7BEF);
+ }
+ } while (dp < lp);
+ dp += da;
+ } while (dp < ep); // all lines
+
+ } else { // Clip horizontal
+
+ da += ox;
+ do {
+ lp = dp + w;
+ //
+ // Clip left
+ //
+ pp = dp - ox;
+ for (;;) {
+ pp += *sp++; // transparent
+ if (pp >= dp) {
+ dp = pp;
+ goto middle_trans;
+ }
+ pp += *sp; // opaque
+ if (pp >= dp) {
+ sp += *sp - (pp - dp) + 1;
+ goto middle_pixel;
+ }
+ sp += *sp + 1;
+ }
+
+ //
+ // Draw middle
+ //
+ for (;;) {
+ dp += *sp++; // transparent
+middle_trans:
+ if (dp >= lp) {
+ lp += sw - w - ox;
+ goto right_trans;
+ }
+ pp = dp + *sp++; // opaque
+middle_pixel:
+ if (pp < lp) {
+ while (dp < pp) {
+ *dp++ = ((*dp >> 1) & 0x7BEF) + ((pixels[*sp++] >> 1)
& 0x7BEF);
+ }
+ continue;
+ }
+ while (dp < lp) {
+ *dp++ = ((*dp >> 1) & 0x7BEF) + ((pixels[*sp++] >> 1) &
0x7BEF);
+ }
+ sp += pp - dp;
+ dp = pp;
+ break;
+ }
+
+ //
+ // Clip right
+ //
+ lp += sw - w - ox;
+ while (dp < lp) {
+ dp += *sp++; // transparent
+right_trans:
+ dp += *sp; // opaque
+ sp += *sp + 1;
+ }
+ dp += da;
+ } while (dp < ep); // all lines
+
+ }
+}
+
+/**
+** Draw 8bit graphic object clipped into 24 bit framebuffer.
+**
+** @param sprite pointer to object
+** @param frame number of frame (object index)
+** @param x x coordinate on the screen
+** @param y y coordinate on the screen
+*/
+local void VideoDraw8to24ClipTrans50(const Graphic* sprite, unsigned frame,
int x, int y)
+{
+ int ox;
+ int ex;
+ int oy;
+ int w;
+ int h;
+ const unsigned char* sp;
+ int sw;
+ VMemType24* dp;
+ const VMemType24* lp;
+ const VMemType24* ep;
+ VMemType24* pp;
+ const VMemType24* pixels;
+ int da;
+
+ //
+ // reduce to visible range
+ //
+ sw = w = sprite->Width;
+ h = sprite->Height;
+ CLIP_RECTANGLE_OFS(x, y, w, h, ox, oy, ex);
+
+ //
+ // Draw the clipped sprite
+ //
+ pixels = (VMemType24*)sprite->Pixels;
+ sp = ((unsigned char**)sprite->Frames)[frame];
+
+ //
+ // Skip top lines, if needed.
+ //
+ while (oy--) {
+ da = 0;
+ do {
+ da += *sp++; // transparent
+ da += *sp; // opaque
+ sp += *sp + 1;
+ } while (da < sw);
+ }
+
+ da = VideoWidth - sw;
+ dp = VideoMemory24 + x + y * VideoWidth;
+ ep = dp + VideoWidth * h;
+
+ if (w == sw) { // Unclipped horizontal
+
+ do {
+ lp = dp + sw;
+ do { // 1 line
+ dp += *sp++; // transparent
+ pp = dp - 1 + *sp++; // opaque
+ while (dp < pp) { // unroll
+ *dp++ = pixels[*sp++];
+ *dp++ = pixels[*sp++];
+ }
+ if (dp <= pp) {
+ *dp++ = pixels[*sp++];
+ }
+ } while (dp < lp);
+ dp += da;
+ } while (dp < ep); // all lines
+
+ } else { // Clip horizontal
+
+ da += ox;
+ do {
+ lp = dp + w;
+ //
+ // Clip left
+ //
+ pp = dp - ox;
+ for (;;) {
+ pp += *sp++; // transparent
+ if (pp >= dp) {
+ dp = pp;
+ goto middle_trans;
+ }
+ pp += *sp; // opaque
+ if (pp >= dp) {
+ sp += *sp - (pp - dp) + 1;
+ goto middle_pixel;
+ }
+ sp += *sp + 1;
+ }
+
+ //
+ // Draw middle
+ //
+ for (;;) {
+ dp += *sp++; // transparent
+middle_trans:
+ if (dp >= lp) {
+ lp += sw - w - ox;
+ goto right_trans;
+ }
+ pp = dp + *sp++; // opaque
+middle_pixel:
+ if (pp < lp) {
+ while (dp < pp) {
+ *dp++ = pixels[*sp++];
+ }
+ continue;
+ }
+ while (dp < lp) {
+ *dp++ = pixels[*sp++];
+ }
+ sp += pp - dp;
+ dp = pp;
+ break;
+ }
+
+ //
+ // Clip right
+ //
+ lp += sw - w - ox;
+ while (dp < lp) {
+ dp += *sp++; // transparent
+right_trans:
+ dp += *sp; // opaque
+ sp += *sp + 1;
+ }
+ dp += da;
+ } while (dp < ep); // all lines
+
+ }
+}
+
+/**
+** Draw 8bit graphic object clipped into 32 bit framebuffer.
+**
+** @param sprite pointer to object
+** @param frame number of frame (object index)
+** @param x x coordinate on the screen
+** @param y y coordinate on the screen
+*/
+local void VideoDraw8to32ClipTrans50(const Graphic* sprite, unsigned frame,
int x, int y)
+{
+ int ox;
+ int ex;
+ int oy;
+ int w;
+ int h;
+ const unsigned char* sp;
+ int sw;
+ VMemType32* dp;
+ const VMemType32* lp;
+ const VMemType32* ep;
+ VMemType32* pp;
+ const VMemType32* pixels;
+ int da;
+
+ //
+ // reduce to visible range
+ //
+ sw = w = sprite->Width;
+ h = sprite->Height;
+ CLIP_RECTANGLE_OFS(x, y, w, h, ox, oy, ex);
+
+ //
+ // Draw the clipped sprite
+ //
+ pixels = (VMemType32*)sprite->Pixels;
+ sp = ((unsigned char**)sprite->Frames)[frame];
+
+ //
+ // Skip top lines, if needed.
+ //
+ while (oy--) {
+ da = 0;
+ do {
+ da += *sp++; // transparent
+ da += *sp; // opaque
+ sp += *sp + 1;
+ } while (da < sw);
+ }
+
+ da = VideoWidth - sw;
+ dp = VideoMemory32 + x + y * VideoWidth;
+ ep = dp + VideoWidth * h;
+
+ if (w == sw) { // Unclipped horizontal
+
+ do {
+ lp = dp + sw;
+ do { // 1 line
+ dp += *sp++; // transparent
+ pp = dp - 1 + *sp++; // opaque
+ while (dp < pp) { // unroll
+ *dp++ = ((*dp >> 1) & 0x7F7F7F7F) + ((pixels[*sp++] >> 1)
& 0x7F7F7F7F) ;
+ *dp++ = ((*dp >> 1) & 0x7F7F7F7F) + ((pixels[*sp++] >> 1)
& 0x7F7F7F7F) ;
+ }
+ if (dp <= pp) {
+ *dp++ = ((*dp >> 1) & 0x7F7F7F7F) + ((pixels[*sp++] >> 1) &
0x7F7F7F7F);
+ }
+ } while (dp < lp);
+ dp += da;
+ } while (dp < ep); // all lines
+
+ } else { // Clip horizontal
+
+ da += ox;
+ do {
+ lp = dp + w;
+ //
+ // Clip left
+ //
+ pp = dp - ox;
+ for (;;) {
+ pp += *sp++; // transparent
+ if (pp >= dp) {
+ dp = pp;
+ goto middle_trans;
+ }
+ pp += *sp; // opaque
+ if (pp >= dp) {
+ sp += *sp - (pp - dp) + 1;
+ goto middle_pixel;
+ }
+ sp += *sp + 1;
+ }
+
+ //
+ // Draw middle
+ //
+ for (;;) {
+ dp += *sp++; // transparent
+middle_trans:
+ if (dp >= lp) {
+ lp += sw - w - ox;
+ goto right_trans;
+ }
+ pp = dp + *sp++; // opaque
+middle_pixel:
+ if (pp < lp) {
+ while (dp < pp) {
+ *dp++ = ((*dp >> 1) & 0x7F7F7F7F) + ((pixels[*sp++] >>
1) & 0x7F7F7F7F);
+ }
+ continue;
+ }
+ while (dp < lp) {
+ *dp++ = ((*dp >> 1) & 0x7F7F7F7F) + ((pixels[*sp++] >> 1) &
0x7F7F7F7F);
+ }
+ sp += pp - dp;
+ dp = pp;
+ break;
+ }
+
+ //
+ // Clip right
+ //
+ lp += sw - w - ox;
+ while (dp < lp) {
+ dp += *sp++; // transparent
+right_trans:
+ dp += *sp; // opaque
+ sp += *sp + 1;
+ }
+ dp += da;
+ } while (dp < ep); // all lines
+
+ }
+}
+
+/**
+** Draw 8bit graphic object clipped and flipped in X direction
+** into 8 bit framebuffer.
+**
+** @param sprite pointer to object
+** @param frame number of frame (object index)
+** @param x x coordinate on the screen
+** @param y y coordinate on the screen
+*/
+local void VideoDraw8to8ClipXTrans50(const Graphic* sprite, unsigned frame,
int x, int y)
+{
+ int ox;
+ int ex;
+ int oy;
+ int w;
+ int h;
+ const unsigned char* sp;
+ int sw;
+ VMemType8* dp;
+ const VMemType8* lp;
+ const VMemType8* ep;
+ VMemType8* pp;
+ const VMemType8* pixels;
+ int da;
+
+ //
+ // reduce to visible range
+ //
+ sw = w = sprite->Width;
+ h = sprite->Height;
+ CLIP_RECTANGLE_OFS(x, y, w, h, ox, oy, ex);
+
+ //
+ // Draw the clipped sprite
+ //
+ pixels = (VMemType8*)sprite->Pixels;
+ sp = ((unsigned char**)sprite->Frames)[frame];
+
+ //
+ // Skip top lines
+ //
+ while (oy--) {
+ da = 0;
+ do {
+ da += *sp++; // transparent
+ da += *sp; // opaque
+ sp += *sp + 1;
+ } while (da < sw);
+ }
+
+ da = VideoWidth + sw;
+ dp = VideoMemory8 + x + y * VideoWidth + w - 1;
+ ep = dp + VideoWidth * h;
+
+ if (w == sw) { // Unclipped horizontal
+
+ while (dp < ep) { // all lines
+ lp = dp - w;
+ do { // 1 line
+ dp -= *sp++; // transparent
+ pp = dp + 1 - *sp++; // opaque
+ while (dp > pp) {
+ *dp-- = pixels[*sp++];
+ *dp-- = pixels[*sp++];
+ }
+ if (dp >= pp) {
+ *dp-- = pixels[*sp++];
+ }
+ } while (dp > lp);
+ dp += da;
+ }
+
+ } else { // Clip horizontal
+
+ da -= sw - w - ox;
+ while (dp < ep) { // all lines
+ lp = dp - w;
+ //
+ // Clip right side
+ //
+ pp = dp + sw - w - ox;
+ for (;;) {
+ pp -= *sp++; // transparent
+ if (pp <= dp) {
+ dp = pp;
+ goto middle_trans;
+ }
+ pp -= *sp; // opaque
+ if (pp <= dp) {
+ sp += *sp - (dp - pp) + 1;
+ goto middle_pixel;
+ }
+ sp += *sp + 1;
+ }
+
+ //
+ // Draw middle
+ //
+ for (;;) {
+ dp -= *sp++; // transparent
+middle_trans:
+ if (dp <= lp) {
+ lp -= ox;
+ goto right_trans;
+ }
+ pp = dp - *sp++; // opaque
+middle_pixel:
+ if (pp > lp) {
+ while (dp > pp) {
+ *dp-- = pixels[*sp++];
+ }
+ continue;
+ }
+ while (dp > lp) {
+ *dp-- = pixels[*sp++];
+ }
+ sp += dp - pp;
+ dp = pp;
+ break;
+ }
+
+ //
+ // Clip left side
+ //
+ lp -= ox;
+ while (dp > lp) {
+ dp -= *sp++; // transparent
+right_trans:
+ dp -= *sp; // opaque
+ sp += *sp + 1;
+ }
+ dp += da;
+
+ }
+ }
+}
+
+/**
+** Draw 8bit graphic object clipped and flipped in X direction
+** into 16 bit framebuffer.
+**
+** @param sprite pointer to object
+** @param frame number of frame (object index)
+** @param x x coordinate on the screen
+** @param y y coordinate on the screen
+*/
+local void VideoDraw8to16ClipXTrans50(const Graphic* sprite, unsigned frame,
+ int x, int y)
+{
+ int ox;
+ int ex;
+ int oy;
+ int w;
+ int h;
+ const unsigned char* sp;
+ int sw;
+ VMemType16* dp;
+ const VMemType16* lp;
+ const VMemType16* ep;
+ VMemType16* pp;
+ const VMemType16* pixels;
+ int da;
+
+
+ //
+ // reduce to visible range
+ //
+ sw = w = sprite->Width;
+ h = sprite->Height;
+ CLIP_RECTANGLE_OFS(x, y, w, h, ox, oy, ex);
+
+ //
+ // Draw the clipped sprite
+ //
+ pixels = (VMemType16*)sprite->Pixels;
+ sp = ((unsigned char**)sprite->Frames)[frame];
+
+ //
+ // Skip top lines
+ //
+ while (oy--) {
+ da = 0;
+ do {
+ da += *sp++; // transparent
+ da += *sp; // opaque
+ sp += *sp + 1;
+ } while (da < sw);
+ }
+
+ da = VideoWidth + sw;
+ dp = VideoMemory16 + x + y * VideoWidth + w - 1;
+ ep = dp + VideoWidth * h;
+
+ if (w == sw) { // Unclipped horizontal
+
+ while (dp < ep) { // all lines
+ lp = dp - w;
+ do { // 1 line
+ dp -= *sp++; // transparent
+ pp = dp + 1 - *sp++; // opaque
+ while (dp > pp) {
+ *dp-- = ((*dp >> 1) & 0x7BEF) + ((pixels[*sp++] >> 1) &
0x7BEF);
+ *dp-- = ((*dp >> 1) & 0x7BEF) + ((pixels[*sp++] >> 1) &
0x7BEF);
+ }
+ if (dp >= pp) {
+ *dp-- = ((*dp >> 1) & 0x7BEF) + ((pixels[*sp++] >> 1) &
0x7BEF);
+ }
+ } while (dp > lp);
+ dp += da;
+ }
+
+ } else { // Clip horizontal
+
+ da -= sw - w - ox;
+ while (dp < ep) { // all lines
+ lp = dp - w;
+ //
+ // Clip right side
+ //
+ pp = dp + sw - w - ox;
+ for (;;) {
+ pp -= *sp++; // transparent
+ if (pp <= dp) {
+ dp = pp;
+ goto middle_trans;
+ }
+ pp -= *sp; // opaque
+ if (pp <= dp) {
+ sp += *sp - (dp - pp) + 1;
+ goto middle_pixel;
+ }
+ sp += *sp + 1;
+ }
+
+ //
+ // Draw middle
+ //
+ for (;;) {
+ dp -= *sp++; // transparent
+middle_trans:
+ if (dp <= lp) {
+ lp -= ox;
+ goto right_trans;
+ }
+ pp = dp - *sp++; // opaque
+middle_pixel:
+ if (pp > lp) {
+ while (dp > pp) {
+ *dp-- = pixels[*sp++];
+ }
+ continue;
+ }
+ while (dp > lp) {
+ *dp-- = pixels[*sp++];
+ }
+ sp += dp - pp;
+ dp = pp;
+ break;
+ }
+
+ //
+ // Clip left side
+ //
+ lp -= ox;
+ while (dp > lp) {
+ dp -= *sp++; // transparent
+right_trans:
+ dp -= *sp; // opaque
+ sp += *sp + 1;
+ }
+ dp += da;
+
+ }
+ }
+}
+
+/**
+** Draw 8bit graphic object clipped and flipped in X direction
+** into 24bit framebuffer.
+**
+** @param sprite pointer to object
+** @param frame number of frame (object index)
+** @param x x coordinate on the screen
+** @param y y coordinate on the screen
+*/
+local void VideoDraw8to24ClipXTrans50(const Graphic* sprite, unsigned frame,
+ int x, int y)
+{
+ int ox;
+ int ex;
+ int oy;
+ int w;
+ int h;
+ const unsigned char* sp;
+ int sw;
+ VMemType24* dp;
+ const VMemType24* lp;
+ const VMemType24* ep;
+ VMemType24* pp;
+ const VMemType24* pixels;
+ int da;
+
+ //
+ // reduce to visible range
+ //
+ sw = w = sprite->Width;
+ h = sprite->Height;
+ CLIP_RECTANGLE_OFS(x, y, w, h, ox, oy, ex);
+
+ //
+ // Draw the clipped sprite
+ //
+ pixels = (VMemType24*)sprite->Pixels;
+ sp = ((unsigned char**)sprite->Frames)[frame];
+
+ //
+ // Skip top lines
+ //
+ while (oy--) {
+ da = 0;
+ do {
+ da += *sp++; // transparent
+ da += *sp; // opaque
+ sp += *sp + 1;
+ } while (da < sw);
+ }
+
+ da = VideoWidth + sw;
+ dp = VideoMemory24 + x + y * VideoWidth + w - 1;
+ ep = dp + VideoWidth * h;
+
+ if (w == sw) { // Unclipped horizontal
+
+ while (dp < ep) { // all lines
+ lp = dp - w;
+ do { // 1 line
+ dp -= *sp++; // transparent
+ pp = dp + 1 - *sp++; // opaque
+ while (dp > pp) {
+ *dp-- = pixels[*sp++];
+ *dp-- = pixels[*sp++];
+ }
+ if (dp >= pp) {
+ *dp-- = pixels[*sp++];
+ }
+ } while (dp > lp);
+ dp += da;
+ }
+
+ } else { // Clip horizontal
+
+ da -= sw - w - ox;
+ while (dp < ep) { // all lines
+ lp = dp - w;
+ //
+ // Clip right side
+ //
+ pp = dp + sw - w - ox;
+ for (;;) {
+ pp -= *sp++; // transparent
+ if (pp <= dp) {
+ dp = pp;
+ goto middle_trans;
+ }
+ pp -= *sp; // opaque
+ if (pp <= dp) {
+ sp += *sp - (dp - pp) + 1;
+ goto middle_pixel;
+ }
+ sp += *sp + 1;
+ }
+
+ //
+ // Draw middle
+ //
+ for (;;) {
+ dp -= *sp++; // transparent
+middle_trans:
+ if (dp <= lp) {
+ lp -= ox;
+ goto right_trans;
+ }
+ pp = dp - *sp++; // opaque
+middle_pixel:
+ if (pp > lp) {
+ while (dp > pp) {
+ *dp-- = pixels[*sp++];
+ }
+ continue;
+ }
+ while (dp > lp) {
+ *dp-- = pixels[*sp++];
+ }
+ sp += dp - pp;
+ dp = pp;
+ break;
+ }
+
+ //
+ // Clip left side
+ //
+ lp -= ox;
+ while (dp > lp) {
+ dp -= *sp++; // transparent
+right_trans:
+ dp -= *sp; // opaque
+ sp += *sp + 1;
+ }
+ dp += da;
+
+ }
+ }
+}
+
+/**
+** Draw 8bit graphic object clipped and flipped in X direction
+** into 32bit framebuffer.
+**
+** @param sprite pointer to object
+** @param frame number of frame (object index)
+** @param x x coordinate on the screen
+** @param y y coordinate on the screen
+*/
+local void VideoDraw8to32ClipXTrans50(const Graphic* sprite, unsigned frame
+ , int x, int y)
+{
+ int ex;
+ int ox;
+ int oy;
+ int w;
+ int h;
+ const unsigned char* sp;
+ int sw;
+ VMemType32* dp;
+ const VMemType32* lp;
+ const VMemType32* ep;
+ VMemType32* pp;
+ const VMemType32* pixels;
+ int da;
+
+ //
+ // reduce to visible range
+ //
+ sw = w = sprite->Width;
+ h = sprite->Height;
+ CLIP_RECTANGLE_OFS(x, y, w, h, ox, oy, ex);
+
+ //
+ // Draw the clipped sprite
+ //
+ pixels = (VMemType32*)sprite->Pixels;
+ sp = ((unsigned char**)sprite->Frames)[frame];
+
+ //
+ // Skip top lines
+ //
+ while (oy--) {
+ da = 0;
+ do {
+ da += *sp++; // transparent
+ da += *sp; // opaque
+ sp += *sp + 1;
+ } while (da < sw);
+ }
+
+ da = VideoWidth + sw;
+ dp = VideoMemory32 + x + y * VideoWidth + w - 1;
+ ep = dp + VideoWidth * h;
+
+ if (w == sw) { // Unclipped horizontal
+
+ while (dp < ep) { // all lines
+ lp = dp - w;
+ do { // 1 line
+ dp -= *sp++; // transparent
+ pp = dp + 1 - *sp++; // opaque
+ while (dp > pp) {
+ *dp-- = ((*dp >> 1) & 0x7F7F7F7F) + ((pixels[*sp++] >> 1) &
0x7F7F7F7F);
+ *dp-- = ((*dp >> 1) & 0x7F7F7F7F) + ((pixels[*sp++] >> 1) &
0x7F7F7F7F);
+ }
+ if (dp >= pp) {
+ *dp-- = pixels[*sp++];
+ }
+ } while (dp > lp);
+ dp += da;
+ }
+
+ } else { // Clip horizontal
+
+ da -= ex;
+ while (dp < ep) { // all lines
+ lp = dp - w;
+ //
+ // Clip right side
+ //
+ pp = dp + ex;
+ for (;;) {
+ pp -= *sp++; // transparent
+ if (pp <= dp) {
+ dp = pp;
+ goto middle_trans;
+ }
+ pp -= *sp; // opaque
+ if (pp <= dp) {
+ sp += *sp - (dp - pp) + 1;
+ goto middle_pixel;
+ }
+ sp += *sp + 1;
+ }
+
+ //
+ // Draw middle
+ //
+ for (;;) {
+ dp -= *sp++; // transparent
+middle_trans:
+ if (dp <= lp) {
+ lp -= ox;
+ goto right_trans;
+ }
+ pp = dp - *sp++; // opaque
+middle_pixel:
+ if (pp > lp) {
+ while (dp > pp) {
+ *dp-- = ((*dp >> 1) & 0x7F7F7F7F) + ((pixels[*sp++] >>
1) & 0x7F7F7F7F);
+ }
+ continue;
+ }
+ while (dp > lp) {
+ *dp-- = ((*dp >> 1) & 0x7F7F7F7F) + ((pixels[*sp++] >> 1) &
0x7F7F7F7F);
+ }
+ sp += dp - pp;
+ dp = pp;
+ break;
+ }
+
+ //
+ // Clip left side
+ //
+ lp -= ox;
+ while (dp > lp) {
+ dp -= *sp++; // transparent
+right_trans:
+ dp -= *sp; // opaque
+ sp += *sp + 1;
+ }
+ dp += da;
+
+ }
+ }
+}
+// End Of 50% Transparent functions
#endif
/**
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [Stratagus-CVS] stratagus/src include/video.h video/sprite.c,
address@hidden <=