/*******************************************************
$Id$
*******************************************************/
#include "objgfx30.h"
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <ubixos/types.h>
// TGfx0 constructor
TGfx0::TGfx0(void) {
DataState = og_None;
Buffer = NULL;
LineOfs = NULL;
pal = NULL;
xRes = 0;
yRes = 0;
MaxX = 0;
MaxY = 0;
bSize = 0;
lSize = 0;
TransparentColor = 0;
BPP = 0;
RedShifter = 0;
GreenShifter = 0;
BlueShifter = 0;
RedFieldPosition = 0;
GreenFieldPosition = 0;
BlueFieldPosition = 0;
return;
} // TGfx0::TGfx0()
bool
TGfx0::alias(TGfx0& SrcObject, UInt32 x1, UInt32 y1, UInt32 x2, UInt32 y2) {
UInt32 tmp;
if (DataState==og_Owner) return FALSE;
if (x2<x1) {
tmp= x2;
x2 = x1;
x1 = tmp;
} // if
if (y2<y1) {
tmp= y2;
y2 = y1;
y1 = tmp;
} // if
Owner = &SrcObject;
Buffer =((unsigned char *)(SrcObject.Buffer)+x1*((SrcObject.BPP+7) >> 3));
LineOfs=((UInt32 *)SrcObject.LineOfs)+y1;
pal = SrcObject.pal;
xRes = SrcObject.xRes;
yRes = SrcObject.yRes;
MaxX = (x2-x1);
MaxY = (y2-y1);
bSize = 0;
lSize = 0;
TransparentColor = SrcObject.TransparentColor;
DataState = og_Aliasing;
BPP = SrcObject.BPP;
// For 8bpp modes the next part doesn't matter
RedFieldPosition = SrcObject.RedFieldPosition;
GreenFieldPosition = SrcObject.GreenFieldPosition;
BlueFieldPosition = SrcObject.BlueFieldPosition;
// The next part is only used by 15/16bpp
RedShifter = SrcObject.RedShifter;
GreenShifter = SrcObject.GreenShifter;
BlueShifter = SrcObject.BlueShifter;
return TRUE;
} // TGfx0::alias
void
TGfx0::arc(UInt32 x_center, UInt32 y_center, UInt32 radius,
UInt32 s_angle, UInt32 e_angle, UInt32 colour) {
Int32 p;
UInt32 x, y, tmp;
double alpha;
if (radius==0) {
putPixel(x_center, y_center, colour);
return;
} // if
s_angle%=361;
e_angle%=361;
if (s_angle>e_angle) {
tmp = s_angle;
s_angle = e_angle;
e_angle = tmp;
} // if
x = 0;
y = radius;
p = 3-2*radius;
while (x<=y) {
alpha = RadToDeg(atan(x/y));
if ((alpha>=s_angle) && (alpha<=e_angle))
putPixel(x_center-x, y_center-y, colour);
if ((90-alpha>=s_angle) && (90-alpha<=e_angle))
putPixel(x_center-y, y_center-x, colour);
if ((90+alpha>=s_angle) && (90+alpha<=e_angle))
putPixel(x_center-y, y_center+x,colour);
if ((180-alpha>=s_angle) && (180-alpha<=e_angle))
putPixel(x_center-x, y_center+y,colour);
if ((180+alpha>=s_angle) && (180+alpha<=e_angle))
putPixel(x_center+x, y_center+y,colour);
if ((270-alpha>=s_angle) && (270-alpha<=e_angle))
putPixel(x_center+y, y_center+x,colour);
if ((270+alpha>=s_angle) && (270+alpha<=e_angle))
putPixel(x_center+y, y_center-x,colour);
if ((360-alpha>=s_angle) && (360-alpha<=e_angle))
putPixel(x_center+x, y_center-y,colour);
if (p<0) p+=4*x+6;
else {
p+=4*(x-y)+10;
y--;
}
x++;
} // while
} // TGfx0::arc
void
TGfx0::bar(Int32 x1, Int32 y1, Int32 x2, Int32 y2, UInt32 colour) {
Int32 yy;
Int32 tmp;
if (x2<x1) {
tmp= x2;
x2 = x1;
x1 = tmp;
} // if
if (y2<y1) {
tmp= y2;
y2 = y1;
y1 = tmp;
} // if
if ((y2<0) || (y1>(Int32)MaxY)) return;
if (y1<0) y1=0;
if (y2>(Int32)MaxY) y2=MaxY;
for (yy=y1; yy<=y2; yy++)
hLine(x1,x2,yy,colour);
} // TGfx0::bar
void
TGfx0::circle(Int32 x_center, Int32 y_center, UInt32 radius, UInt32 colour) {
Int32 x, y, d;
x = 0;
y = radius;
d = 2*(1-radius);
while (y>=0) {
putPixel(x_center+x,y_center+y,colour);
putPixel(x_center+x,y_center-y,colour);
putPixel(x_center-x,y_center+y,colour);
putPixel(x_center-x,y_center-y,colour);
if (d + y > 0) {
y--;
d -= 2*y+1;
} // if
if (x > d) {
x++;
d += 2*x+1;
} // if
} // while
} // TGfx0::circle
void
TGfx0::clear(UInt32 colour) {
UInt32 height;
if ((Buffer==NULL) || (LineOfs==NULL)) return;
asm("cld\n");
switch (BPP) {
case 8:
asm(
" add (%%esi), %%edi \n" // add edi, [esi]
" mov %%ecx, %%esi \n" // mov esi, ecx
" inc %%edx \n" // inc edx (MaxY)
" inc %%ebx \n" // inc ebx (MaxX)
" sub %%edx, %%esi \n" // sub esi, edx
" mov %%al, %%ah \n" // mov ah, al
" mov %%ax, %%cx \n" // mov cx, ax
" shl $16, %%eax \n" // shl eax, 16
" mov %%cx, %%ax \n" // mov ax, cx
"loop8: \n"
" push %%edx \n"
" mov %%edx, %%ecx \n" // mov ecx, edx
" and $3, %%edx \n" // and edx, 3
" shr $2, %%ecx \n" // shr ecx, 2
" rep \n"
" stosl \n"
" mov %%edx, %%ecx \n" // mov ecx, edx
" rep \n"
" stosb \n"
" pop %%edx \n"
" add %%esi, %%edi \n" // add edi, esi
" dec %%ebx \n"
" jnz loop8 \n"
:
: "D" (Buffer), "S" (LineOfs), // %0, %1
"a" (colour), "b" (MaxY), // %2, %3
"c" (xRes), "d" (MaxX) // %4, %5
);
break;
case 15:
case 16:
asm(
" add (%%esi), %%edi \n" // add edi, [esi]
" mov %%ecx, %%esi \n" // mov esi, ecx
" inc %%edx \n" // inc edx (MaxX)
" inc %%ebx \n" // inc ebx (MaxY)
" sub %%edx, %%esi \n" // sub esi, edx
" sub %%edx, %%esi \n" // sub esi, edx // adjust for pix size
" mov %%ax, %%cx \n" // mov cx, ax
" shl $16, %%eax \n" // shl eax, 16
" mov %%cx, %%ax \n" // mov ax, cx
"loop16: \n"
" mov %%edx, %%ecx \n" // mov ecx, edx
" shr $1, %%ecx \n" // shr ecx, 1
" rep \n"
" stosl \n"
" jnc noc16 \n"
" stosw \n"
"noc16: \n"
" add %%esi, %%edi \n" // add edi, esi
" dec %%ebx \n"
" jnz loop16 \n"
:
: "D" (Buffer), "S" (LineOfs), // %0, %1
"a" (colour), "b" (MaxY), // %2, %3
"c" (xRes), "d" (MaxX) // %4, %5
);
break;
case 24:
asm(
" add (%%esi), %%edi \n" // add edi, [esi]
" mov %%ecx, %%esi \n" // mov esi, ecx
" inc %%edx \n" // inc edx (MaxX)
" inc %%ebx \n" // inc ebx (MaxY)
" sub %%edx, %%esi \n" // sub esi, edx // adjust for pix size
" mov %%ebx, %6 \n" // mov height, ebx
" sub %%edx, %%esi \n" // sub esi, edx // adjust for pix size
" mov %%eax, %%ebx \n" // mov ebx, eax
" sub %%edx, %%esi \n" // sub esi, edx // adjust for pix size
" shr $16, %%ebx \n" // shr ebx, 16
"oloop24: \n"
" mov %%edx, %%ecx \n" // mov ecx, edx
"iloop24: \n"
" mov %%ax,(%%edi) \n" // mov [edi],ax
" movb %%bl,2(%%edi) \n" // mov [edi+2],bl
" add $3, %%edi \n" // add edi, 3
" dec %%ecx \n" // dec ecx
" jnz iloop24 \n"
" add %%esi, %%edi \n" // add edi, esi
" decl %6 \n" // dec height
" jnz oloop24 \n"
:
: "D" (Buffer), "S" (LineOfs), // %0, %1
"a" (colour), "b" (MaxY), // %2, %3
"c" (xRes), "d" (MaxX), // %4, %5
"g" (height) // %6
);
break;
case 32:
asm(
" add (%%esi), %%edi \n" // add edi, [esi]
" mov %%ecx, %%esi \n" // mov esi, ecx
" inc %%edx \n" // inc edx (MaxX)
" inc %%ebx \n" // inc ebx (MaxY)
" mov %%edx, %%ecx \n" // mov ecx, edx
" shl $2, %%ecx \n" // shl ecx, 2
" sub %%ecx, %%esi \n" // sub esi, ecx // adjust for pix size
"loop32: \n"
" mov %%edx, %%ecx \n" // mov ecx, edx
" rep \n"
" stosl \n"
" add %%esi, %%edi \n" // add edi, esi
" dec %%ebx \n"
" jnz loop32 \n"
:
: "D" (Buffer), "S" (LineOfs), // %0, %1
"a" (colour), "b" (MaxY), // %2, %3
"c" (xRes), "d" (MaxX) // %4, %5
);
}
} // TGfx0::clear
void
TGfx0::clone(TGfx0& SrcObject) {
TPixelFmt pixfmt;
if (SrcObject.DataState==og_None) return;
SrcObject.getPixFmt(pixfmt);
create(SrcObject.MaxX+1,SrcObject.MaxY+1,pixfmt);
if (pal!=NULL) memcpy(pal, SrcObject.pal, sizeof(TRGB)*256);
copy(SrcObject);
} // TGfx0::clone
void
TGfx0::copy(TGfx0& SrcObject) {
UInt32 count, xCount, yCount;
UInt32 xx, yy;
UInt8 r, g, b;
if ((Buffer==NULL) || (LineOfs==NULL)) return;
if ((SrcObject.Buffer==NULL) || (SrcObject.LineOfs==NULL)) return;
xCount = SrcObject.MaxX+1;
if (xCount>MaxX+1) xCount=MaxX+1;
yCount = SrcObject.MaxY+1;
if (yCount>MaxY+1) yCount=MaxY+1;
if ((BPP!=SrcObject.BPP) || (RedShifter!=SrcObject.RedShifter) ||
(BlueShifter!=SrcObject.BlueShifter) ||
(GreenShifter!=SrcObject.GreenShifter)) {
for (yy=0; yy<=yCount-1; yy++)
for (xx=0; xx<=xCount-1; xx++) {
SrcObject.unpackRGB(SrcObject.getPixel(xx,yy),r,g,b);
putPixel(xx,yy,RGB(r,g,b));
} // for
} // if
else
{
xCount *= ((BPP+7) >> 3); // adjust for bpp
for (count=0; count<=yCount-1; count++) ;
memcpy(((char*)Buffer+LineOfs[count]), // dest
((char*)SrcObject.Buffer+SrcObject.LineOfs[count]), // src
xCount); // len
} // else
} // TGfx0::copy
void
TGfx0::copyBuf(Int32 DestX, Int32 DestY,
TGfx0& SrcObject, Int32 x1, Int32 y1, Int32 x2, Int32 y2) {
UInt32 pixmap[256];
Int32 xx,yy,count,xCount, yCount;
UInt32 bm; // bit multiplyer
UInt8 r, g, b;
if ((Buffer==NULL) || (LineOfs==NULL)) return;
if ((SrcObject.Buffer==NULL) || (SrcObject.LineOfs==NULL)) return;
if ((DestX>(Int32)MaxX) || (DestY>(Int32)MaxY)) return;
if (x1>x2) {
xx = x1;
x1 = x2;
x2 = xx;
} // if
if (y1>y2) {
yy = y1;
y1 = y2;
y2 = yy;
} // if
xCount = abs(x2-x1)+1;
yCount = abs(y2-y1)+1;
if (DestX+xCount>(Int32)MaxX+1) xCount=MaxX-DestX+1;
if (DestY+yCount>(Int32)MaxY+1) yCount=MaxY-DestY+1;
if (DestX<0) {
xCount += DestX;
x1 -= DestX;
DestX = 0;
} // if
if (DestY<0) {
yCount += DestY;
y1 -= DestY;
DestY = 0;
} // if
if ((DestX+xCount<0) || (DestY+yCount<0)) return;
if ((BPP!=SrcObject.BPP) || (RedShifter!=SrcObject.RedShifter) ||
(BlueShifter!=SrcObject.BlueShifter) ||
(GreenShifter!=SrcObject.GreenShifter)) {
if (SrcObject.BPP==8) {
for (xx=0; xx<256; xx++)
pixmap[xx] = RGB(SrcObject.pal[xx].red,
SrcObject.pal[xx].green,
SrcObject.pal[xx].blue);
for (yy=0; yy<=yCount-1; yy++)
for (xx=0; xx<=xCount-1; xx++)
putPixel(DestX+xx,DestY+yy,pixmap[SrcObject.getPixel(x1+xx,y1+yy)]);
} // if srcobject->bpp
else
{
for (yy=0; yy<=yCount-1; yy++)
for (xx=0; xx<=xCount-1; xx++) {
SrcObject.unpackRGB(SrcObject.getPixel(x1+xx,y1+yy),r,g,b);
putPixel(DestX+xx,DestY+yy,RGB(r,g,b));
} // for
} // else
} // if
else
{
bm = (BPP+7) >> 3;
x1 *= bm;
DestX *= bm;
xCount *= bm;
for (count=0; count<=yCount-1; count++) {
memcpy(((char*)Buffer+LineOfs[DestY+count]+DestX), // dest
((char*)SrcObject.Buffer+SrcObject.LineOfs[y1+count]+x1), // src
xCount); // len
}
} // else
} // TGfx0::copyBuf
bool
TGfx0::create(UInt32 _xRes, UInt32 _yRes,TPixelFmt _pixformat) {
/*
* constructor TGfx0::create()
* Allocates memory for a buffer of size _xRes by _yRes with
* the pixel format defined in _pixformat. Allocates memory
* for pal and LineOfs.
*/
UInt32 yy;
if (DataState==og_Owner) {
if (Buffer!=NULL) free(Buffer);
if (LineOfs!=NULL) free(LineOfs);
if (pal!=NULL) free(pal);
} // if datastate
BPP = _pixformat.BPP;
bSize=_xRes*_yRes*((BPP+7) >> 3);
Buffer = malloc(bSize);
if (Buffer==NULL) return FALSE;
memset(Buffer,0,bSize);
lSize = _yRes*sizeof(UInt32);
LineOfs = (UInt32*)malloc(lSize);
if (LineOfs == NULL) return FALSE;
pal = (TRGB*)malloc(256*sizeof(TRGB));
if (pal == NULL) return FALSE;
memset(pal,0,sizeof(TRGB)*256);
MaxX=_xRes-1;
xRes=_xRes*((BPP+7) >> 3);
MaxY=_yRes-1;
yRes=_yRes;
LineOfs[0]=0;
for (yy=1; yy<=MaxY; yy++)
LineOfs[yy]=LineOfs[yy-1]+xRes;
DataState = og_Owner;
// For 8bpp modes the next part doesn't matter
RedFieldPosition=_pixformat.RedFieldPosition;
GreenFieldPosition=_pixformat.GreenFieldPosition;
BlueFieldPosition=_pixformat.BlueFieldPosition;
// The next part is only used by 15/16hpp
RedShifter=8-_pixformat.RedMaskSize;
GreenShifter=8-_pixformat.GreenMaskSize;
BlueShifter=8-_pixformat.BlueMaskSize;
Owner = this;
return TRUE;
} // TGfx0::create
UInt8
TGfx0::getBPP(void) {
return BPP;
} // TGfx0::getBPP
void*
TGfx0::getBufferPtr(void) {
return Buffer;
} // TGfx0::getBufferPtr
og_DataState
TGfx0::getDataState(void) {
return DataState;
} // TGfx0::getDataState(void)
UInt32*
TGfx0::getLineOfsPtr(void) {
return LineOfs;
} // TGfx0::getLineOfsPtr
TRGB *
TGfx0::getPalPtr(void) {
return pal;
} // TGfx0::getPalPtr
UInt32
TGfx0::getMaxX(void) {
return MaxX;
} // TGfx0::getMaxX
UInt32
TGfx0::getMaxY(void) {
return MaxY;
} // TGfx0::getMaxY
UInt32
TGfx0::getPixel(Int32 x, Int32 y) {
UInt32 result;
result = 42;
if ((Buffer==NULL) || (LineOfs==NULL)) return TransparentColor;
if ((x<0) || (x>(Int32)MaxX) || (y<0) || y>(Int32)MaxY)
return TransparentColor;
switch (BPP) {
case 8:
asm(
" add %%esi, %%edi \n" // add edi, esi
" add %%ecx, %%edi \n" // add edi, ecx
" movzbl (%%edi),%%eax \n" // movzx edx,byte ptr [edi]
" mov %%eax, %3 \n" // mov result, eax
:
: "D" (Buffer), "S" (LineOfs[y]), // %0, %1
"c" (x), "m" (result) // %2, %3
);
break;
case 15:
case 16:
asm(
" add %%esi, %%edi \n" // add edi, esi
" add %%ecx, %%ecx \n" // add ecx, ecx {adjust for pixel size}
" add %%ecx, %%edi \n" // add edi, ecx
" movzwl (%%edi),%%eax \n" // movzx edx,word ptr [edi]
" mov %%eax, %3 \n" // mov result, eax
:
: "D" (Buffer), "S" (LineOfs[y]), // %0, %1
"c" (x), "m" (result) // %2, %3
);
break;
case 24:
asm(
" mov %%ecx, %%eax \n" // mov eax, ecx - adjust for pixel size
" add %%ecx, %%ecx \n" // add ecx, ecx - adjust for pixel size
" add %%eax, %%ecx \n" // add ecx, eax - adjust for pixel size
" add %%esi, %%edi \n" // add edi, esi
// " add (%%esi,%%ebx,4), %%edi \n" // add edi, [esi + ebx*4]
" add %%ecx, %%edi \n" // add edi, ecx
" movzwl (%%edi),%%eax \n" // edx,word ptr [edi]
" xor %%eax, %%eax \n"
" mov 2(%%edi), %%al \n" // mov al, [edi+2]
" shl $16, %%eax \n" // shl eax, 16
" mov (%%edi), %%ax \n" // mov ax, [edi]
" mov %%eax, %3 \n" // mov result, eax
:
: "D" (Buffer), "S" (LineOfs[y]), // %0, %1
"c" (x), "m" (result) // %2, %3
);
break;
case 32:
asm(
" shl $2, %%ecx \n" // shl ecx, 2 {adjust for pixel size}
// " add (%%esi,%%ebx,4), %%edi \n" // add edi, [esi + ebx*4]
" add %%esi, %%edi \n" // add edi, esi
" add %%ecx, %%edi \n" // add edi, ecx
" mov (%%edi),%%eax \n" // eax,word ptr [edi]
" mov %%eax, %3 \n" // mov result, eax
:
: "D" (Buffer), "S" (LineOfs[y]), // %0, %1
"c" (x), "m" (result) // %2, %3
);
} // switch
return result;
} // TGfx0::getPixel
void
TGfx0::getPixFmt(TPixelFmt& pixfmt) {
pixfmt.BPP=BPP;
pixfmt.RedFieldPosition=RedFieldPosition;
pixfmt.GreenFieldPosition=GreenFieldPosition;
pixfmt.BlueFieldPosition=BlueFieldPosition;
pixfmt.RedMaskSize=8-RedShifter;
pixfmt.GreenMaskSize=8-GreenShifter;
pixfmt.BlueMaskSize=8-BlueShifter;
} // TGfx0::getPixFmt
UInt32
TGfx0::getTransparentColor(void) {
return TransparentColor;
} // TGfx0::getTransparentColor
void
TGfx0::hFlip(void) {
} // TGfx0::hFlip
void
TGfx0::hLine(Int32 x1, Int32 x2, Int32 y, UInt32 colour) {
Int32 tmp;
if ((Buffer==NULL) || (LineOfs==NULL)) return;
if ((UInt32)y>MaxY) return;
if (x1>x2) {
tmp= x1;
x1 = x2;
x2 = tmp;
} // if
if (x1<0) x1 = 0;
if (x2>(Int32)MaxX) x1=MaxX;
if (x2<x1) return;
asm("cld \n");
switch (BPP) {
case 8:
asm(
" add %%ebx, %%edi \n" // add edi, ebx
" add %%esi, %%edi \n" // add edi, esi
" and $0xff, %%eax \n" // and eax, 0ffh
" sub %%ebx, %%ecx \n" // sub ecx, ebx
" mov %%al, %%ah \n" // mov ah, al
" inc %%ecx \n" // inc ecx
" mov %%eax, %%ebx \n" // mov ebx, eax
" shl $16, %%ebx \n" // shl ebx, 16
" add %%ebx, %%eax \n" // add eax, ebx
" mov %%ecx, %%edx \n" // mov edx, ecx
" mov $4, %%ecx \n" // mov ecx, 4
" sub %%edi, %%ecx \n" // sub ecx, edi
" and $3, %%ecx \n" // and ecx, 3
" sub %%ecx, %%edx \n" // sub edx, ecx
" jle LEndBytes \n"
" rep \n"
" stosb \n"
" mov %%edx, %%ecx \n" // mov ecx, edx
" and $3, %%edx \n" // and edx, 3
" shr $2, %%ecx \n" // shr ecx, 2
" rep \n"
" stosl \n"
"LEndBytes: \n"
" add %%edx, %%ecx \n" // add ecx, edx
" rep \n"
" stosb \n"
:
: "D" (Buffer), "S" (LineOfs[y]), // %0, %1
"a" (colour), "b" (x1), // %2, %3
"c" (x2)
);
break;
case 15:
case 16:
asm(
" sub %%ebx, %%ecx \n" // sub ecx, ebx
" add %%ebx, %%ebx \n" // add ebx, ebx - pix size
" inc %%ecx \n" // inc ecx
" add %%ebx, %%edi \n" // add edi, ebx
" add %%esi, %%edi \n" // add edi, esi
" xor %%edx, %%edx \n" // xor edx, edx
" mov %%ax, %%dx \n" // mov dx, ax
" shl $16, %%eax \n" // shl eax, 16
" add %%edx, %%eax \n" // add eax, edx
" shr $1, %%ecx \n" // shr ecx, 1
" rep \n"
" stosl \n"
" jnc hLnoc16 \n"
" stosw \n"
"hLnoc16: \n"
:
: "D" (Buffer), "S" (LineOfs[y]), // %0, %1
"a" (colour), "b" (x1), // %2, %3
"c" (x2) // %4
);
break;
case 24:
asm(
" sub %%ebx, %%ecx \n" // sub ecx, ebx
" add %%esi, %%edi \n" // add edi, esi
" add %%ebx, %%ebx \n" // add ebx, ebx - pix size
" inc %%ecx \n" // inc ecx
" add %%edx, %%ebx \n" // add ebx, edx - pix size
" add %%ebx, %%edi \n" // add edi, ebx
" mov %%eax, %%ebx \n" // mov ebx, eax
" shr $16, %%ebx \n" // shr ebx, 16
"hLlop24: \n"
" mov %%ax, (%%edi) \n" // mov [edi], ax
" mov %%bl, 2(%%edi)\n" // mov [edi+2], bl
" add $3, %%edi \n" // add edi, 3
" dec %%ecx \n" // dec ecx
" jnz hLlop24 \n"
:
: "D" (Buffer), "S" (LineOfs[y]), // %0, %1
"a" (colour), "b" (x1), // %2, %3
"c" (x2), "d" (x1) // %4, %5
);
break;
case 32:
asm(
" sub %%ebx, %%ecx \n" // sub ecx, ebx
" add %%esi, %%edi \n" // add edi, esi
" inc %%ecx \n"
" shl $2, %%ebx \n" // shl ebx, 2
" add %%ebx, %%edi \n" // add edi, ebx
" rep \n"
" stosl \n"
:
: "D" (Buffer), "S" (LineOfs[y]), // %0, %1
"a" (colour), "b" (x1), // %2, %3
"c" (x2) // %4
);
break;
} // switch
} // TGfx0::hLine
void
TGfx0::putPixel(UInt32 x, UInt32 y, UInt32 colour) {
if ((Buffer==NULL) || (LineOfs==NULL)) return;
if ((x<0) || (x>MaxX) || (y<0) || y>MaxY) return;
switch (BPP) {
case 8:
asm(
// { Calculate offset, prepare the pixel to be drawn }
// " add (%%esi,%%ebx,4), %%edi \n" // add edi, [esi + ebx * 4]
" add %%esi, %%edi \n" // add edi, esi
" mov %3, %%eax \n" // mov eax, colour
" add %%ecx, %%edi \n" // add edi, ecx
// { Draw the pixel }
" mov %%al, (%%edi) \n" // mov [edi], al
:
: "D" (Buffer), "S" (LineOfs[y]), // %0, %1
"c" (x), "m" (colour) // %2, %3
);
break;
case 15:
case 16:
asm(
// { Calculate offset, prepare the pixel to be drawn }
// " add (%%esi,%%ebx,4), %%edi \n" // add edi, [esi + ebx * 4]
" add %%ecx, %%ecx \n" // add ecx, ecx {adjust for pixel size}
" add %%esi, %%edi \n" // add edi, esi
" mov %3, %%eax \n" // mov eax, colour
" add %%ecx, %%edi \n" // add edi, ecx
// { Draw the pixel }
" mov %%ax, (%%edi) \n" // mov [edi], al
:
: "D" (Buffer), "S" (LineOfs[y]), // %0, %1
"c" (x), "m" (colour) // %2, %3
);
break;
case 24:
asm(
// { Calculate offset, prepare the pixel to be drawn }
// " add (%%esi,%%ebx,4),%%edi \n" // add edi, [esi + ebx * 4]
" add %%esi, %%edi \n" // add edi, esi
" add %%ecx, %%edi \n" // add edi, ecx
" add %%ecx, %%edi \n" // add edi, ecx {adjust for pixel size}
" add %%ecx, %%edi \n" // add edi, ecx {adjust for pixel size}
// { Draw the pixel }
" mov %%ax, (%%edi) \n" // mov [edi], ax
" shr $16, %%eax \n" // shr eax, 16
" mov %%al, 2(%%edi)\n" // mov [edi+2],al
:
: "D" (Buffer), "S" (LineOfs[y]), // %0, %1
"c" (x), "a" (colour) // %2, %3
);
break;
case 32:
asm(
// { Calculate offset, prepare the pixel to be drawn }
" shl $2, %%ecx \n" // shl eax, 2 {adjust for pixel size}
" add %%esi, %%edi \n" // add edi, esi
" add %%ecx, %%edi \n" // add edi, ecx
// { Draw the pixel }
" mov %%eax, (%%edi) \n" // mov [edi], eax
:
: "D" (Buffer), "S" (LineOfs[y]), // %0, %1
"c" (x), "a" (colour) // %2, %3
);
} // switch
return;
} // TGfx0::putPixel
UInt32
TGfx0::RGB(UInt8 red, UInt8 green, UInt8 blue) {
UInt32 lastclr;
lastclr=0;
switch (BPP) {
case 8:
asm(
" movl $256,%%ecx \n"
" movl $256*3+1,%%ebx \n"
" xor %%eax,%%eax \n"
"lop: \n"
" pushl %%eax \n"
" mov (%%esi),%%al \n"
" incl %%esi \n"
" sub %1,%%al \n"
" jns abs1 \n"
" neg %%al \n"
"abs1: \n"
" movl %%eax,%%edi \n"
" mov (%%esi),%%al \n"
" incl %%esi \n"
" sub %2,%%al \n"
" jns abs2 \n"
" neg %%al \n"
"abs2: \n"
" addl %%eax,%%edi \n"
" mov (%%esi),%%al \n"
" incl %%esi \n"
" sub %3,%%al \n"
" jns abs3 \n"
" neg %%al \n"
"abs3: \n"
" addl %%eax,%%edi \n"
" popl %%eax \n"
" cmpl %%ebx,%%edi \n"
" jae no_good_match \n"
" movl %%edi,%%ebx \n"
" movl %%eax,%4 \n"
"no_good_match: \n"
" incl %%eax \n"
" decl %%ecx \n"
" jnz lop \n"
:
: "S" (pal), "m" (red), "m" (green), "m" (blue), "m" (lastclr)
);
break;
case 15:
case 16:
asm(
" xor %%eax, %%eax \n"
" xor %%ebx, %%ebx \n"
" xor %%ecx, %%ecx \n"
" mov %0, %%al \n" // mov al, red
" mov %3, %%cl \n" // mov cl, RedShifter
" shr %%cl, %%al \n" // shr al, cl
" mov %4, %%cl \n" // mov cl, RedFieldPosition
" shl %%cl, %%eax \n" // shl eax, cl
" mov %%eax, %%ebx \n" // mov ebx, eax
" xor %%eax, %%eax \n" // xor eax, eax
" mov %1, %%al \n" // mov al, green
" mov %5, %%cl \n" // mov cl, GreenShifter
" shr %%cl, %%al \n" // shr al, cl
" mov %6, %%cl \n" // mov cl, GreenFieldPosition
" shl %%cl, %%eax \n" // shl eax, cl
" or %%eax, %%ebx \n" // or eax, ebx
" xor %%eax, %%eax \n" // xor eax, eax
" mov %2, %%al \n" // mov al, blue
" mov %7, %%cl \n" // mov cl, BlueShifter
" shr %%cl, %%al \n" // shr al, cl
" mov %8, %%cl \n" // mov cl, BlueFieldPosition
" shl %%cl, %%eax \n" // shl eax, cl
" or %%ebx, %%eax \n" // or eax, ebx
" mov %%eax, %9 \n" // mov lastclr, eax
:
: "m" (red), "m" (green), "m" (blue), // %0, %1, %2
"m" (RedShifter), "m" (RedFieldPosition), // %3, %4
"m" (GreenShifter), "m" (GreenFieldPosition), // %5, %6
"m" (BlueShifter), "m" (BlueFieldPosition), // %7, %8
"m" (lastclr) // %9
);
break;
case 24:
case 32:
asm(
" xor %%eax, %%eax \n" // xor eax, eax
" xor %%ebx, %%ebx \n" // xor ebx, ebx
" xor %%ecx, %%ecx \n" // xor ecx, ecx
" mov %0, %%al \n" // mov al, red
" mov %3, %%cl \n" // mov cl, RedFieldPosition
" shl %%cl, %%eax \n" // shl eax, cl
" mov %%eax, %%ebx \n" // mov ebx, eax
" xor %%eax, %%eax \n" // xor eax, eax
" mov %1, %%al \n" // mov al, green
" mov %4, %%cl \n" // mov cl, GreenFieldPosition
" shl %%cl, %%eax \n" // shl eax, cl
" or %%eax, %%ebx \n" // or ebx, eax
" xor %%eax, %%eax \n" // xor eax, eax
" mov %2, %%al \n" // mov al, blue
" mov %5, %%cl \n" // mov cl, BlueFieldPosition
" shl %%cl, %%eax \n" // shl eax, cl
" or %%ebx, %%eax \n" // or eax, ebx
" mov %%eax, %6 \n" // mov lastclr, eax
:
: "m" (red), "m" (green), "m" (blue), // %0, %1, %2
"m" (RedFieldPosition), // %3
"m" (GreenFieldPosition), // %4
"m" (BlueFieldPosition), // %5
"m" (lastclr) // %6
);
} // switch
//asm("": "=a" (lastclr));
return lastclr;
} // TGfx0::RGB
void
TGfx0::setRGBPalette(UInt8 colour, UInt8 red, UInt8 green, UInt8 blue) {
if (!pal) return;
pal[colour].red = red;
pal[colour].green = green;
pal[colour].blue = blue;
return;
} // TGfx0::setRGBPalette
void
TGfx0::rectangle(Int32 x1, Int32 y1, Int32 x2, Int32 y2, UInt32 colour) {
hLine(x1,x2,y1,colour); // Horizline has built in clipping
vLine(x2,y1,y2,colour); // vertline has built in clipping too
vLine(x1,y1,y2,colour);
hLine(x1,x2,y2,colour);
return;
} // TGfx0::rectangle
void
TGfx0::unpackRGB(UInt32 colour, UInt8& red, UInt8& green, UInt8& blue) {
switch (BPP) {
case 8:
if (!pal) {
red = 0;
green = 0;
blue = 0;
return;
}
if (colour>255) colour=colour & 255;
red = pal[colour].red;
green = pal[colour].green;
blue = pal[colour].blue;
break;
case 15:
case 16:
red = ((colour >> RedFieldPosition) << RedShifter);
green = ((colour >> GreenFieldPosition) << GreenShifter);
blue = ((colour >> BlueFieldPosition) << BlueShifter);
if ((red) && (RedShifter)) red+=(1 << RedShifter)-1;
if ((green) && (GreenShifter)) green+=(1 << GreenShifter)-1;
if ((blue) && (BlueShifter)) blue+=(1 << BlueShifter)-1;
break;
case 24:
case 32:
red = colour >> RedFieldPosition;
green = colour >> GreenFieldPosition;
blue = colour >> BlueFieldPosition;
break;
default:
red = 0;
green = 0;
blue = 0;
}
return;
} // TGfx0::unpackRGB
void
TGfx0::vFlip(void) {
return;
} // TGfx0::vFlip
void
TGfx0::vLine(Int32 x, Int32 y1, Int32 y2, UInt32 colour) {
Int32 tmp;
if ((Buffer==NULL) || (LineOfs==NULL)) return;
if ((UInt32)x>MaxX) return;
if (y1>y2) {
tmp= y1;
y1 = y2;
y2 = tmp;
} // if
if (y1<0) y1 = 0;
if (y2>(Int32)MaxY) y2 = MaxY;
if (y2<y1) return;
switch (BPP) {
case 8:
asm(
" add %%esi, %%edi \n" // add edi, esi
" mov %6, %%esi \n" // mov esi, y1
" sub %%esi, %%ecx \n" // sub ecx, esi
" add %%ebx, %%edi \n" // add edi, ebx
" inc %%ecx \n" // inc ecx
"vLlop8: \n"
" mov %%al, (%%edi) \n" // mov [edi], al
" add %%edx, %%edi \n" // add edi, edx
" dec %%ecx \n" // dec ecx
" jnz vLlop8 \n"
:
: "D" (Buffer), "S" (LineOfs[y1]), // %0, %1
"a" (colour), "b" (x), // %2, %3
"c" (y2), "d" (xRes), // %4, %5
"m" (y1) // %6
);
break;
case 15:
case 16:
asm(
" add %%esi, %%edi \n" // add edi, esi
" add %%ebx, %%ebx \n" // add ebx, ebx - pix size
" mov %6, %%esi \n" // mov esi, y1
" sub %%esi, %%ecx \n" // sub ecx, esi
" add %%ebx, %%edi \n" // add edi, ebx
" inc %%ecx \n" // inc ecx
"vLlop16: \n"
" mov %%ax, (%%edi) \n" // mov [edi], ax
" add %%edx, %%edi \n" // add edi, edx
" dec %%ecx \n" // dec ecx
" jnz vLlop16 \n"
:
: "D" (Buffer), "S" (LineOfs[y1]), // %0, %1
"a" (colour), "b" (x), // %2, %3
"c" (y2), "d" (xRes), // %4, %5
"m" (y1) // %6
);
break;
case 24:
asm(
" add %%esi, %%edi \n" // add edi, esi
" mov %%ebx, %%esi \n" // mov esi, ebx - pix size
" add %%ebx, %%ebx \n" // add ebx, ebx - pix size
" add %%esi, %%ebx \n" // add ebx, esi - pix size
" mov %6, %%esi \n" // mov esi, y1
" sub %%esi, %%ecx \n" // sub ecx, esi
" add %%ebx, %%edi \n" // add edi, ebx
" inc %%ecx \n" // inc ecx
" mov %%eax, %%ebx \n" // mov ebx, eax
" shr $16, %%ebx \n" // shr ebx, 16
"vLlop24: \n"
" mov %%ax, (%%edi) \n" // mov [edi], eax
" mov %%bl, 2(%%edi)\n" // mov [edi+2], bl
" add %%edx, %%edi \n" // add edi, edx
" dec %%ecx \n" // dec ecx
" jnz vLlop24 \n"
:
: "D" (Buffer), "S" (LineOfs[y1]), // %0, %1
"a" (colour), "b" (x), // %2, %3
"c" (y2), "d" (xRes), // %4, %5
"m" (y1) // %6
);
break;
case 32:
asm(
" add %%esi, %%edi \n" // add edi, esi
" shl $2, %%ebx \n" // shl ebx, 2 - pix size
" mov %6, %%esi \n" // mov esi, y1
" sub %%esi, %%ecx \n" // sub ecx, esi
" add %%ebx, %%edi \n" // add edi, ebx
" inc %%ecx \n" // inc ecx
"vLlop32: \n"
" mov %%eax, (%%edi)\n" // mov [edi],al
" add %%edx, %%edi \n" // add edi, edx
" dec %%ecx \n" // dec ecx
" jnz vLlop32 \n"
:
: "D" (Buffer), "S" (LineOfs[y1]), // %0, %1
"a" (colour), "b" (x), // %2, %3
"c" (y2), "d" (xRes), // %4, %5
"m" (y1) // %6
);
} // switch
return;
} // TGfx0::vLine
TGfx0::~TGfx0(void) {
if (DataState == og_Owner) {
if (pal!=NULL) free(pal);
if (Buffer!=NULL) free(Buffer);
if (LineOfs!=NULL) free(LineOfs);
} // if datastate
pal = NULL;
LineOfs= NULL;
Buffer = NULL;
bSize = 0;
lSize = 0;
DataState = og_None;
return;
} // TGfx0::~TGfx0()
/*
*
* TSCREEN METHODS
*
*/
TScreen::TScreen(void) {
InGraphics = FALSE;
VESARec = NULL;
ModeRec = NULL;
return;
}
TScreen::~TScreen(void) {
return;
}
