/*******************************************************
$Id$
*******************************************************/
#include "objgfx30.h"
#include <stdlib.h>
#include <string.h>
#include <ubixos/types.h>
// TGfx0 constructor
TGfx0::TGfx0(void) {
DataState = og_None;
Buffer = 0;
LineOfs = 0;
pal = 0;
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) {
} // 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) {
} // 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) pal = SrcObject.pal;
copy(SrcObject);
} // TGfx0::clone
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) free(Buffer);
if (LineOfs) free(LineOfs);
if (pal) free(pal);
} // if datastate
BPP = _pixformat.BPP;
bSize=_xRes*_yRes*((BPP+7) >> 3);
Buffer = malloc(bSize);
if (!Buffer) return FALSE;
memset(Buffer,0,bSize);
lSize = _yRes*sizeof(UInt32);
LineOfs = (UInt32*)malloc(lSize);
if (!LineOfs) return FALSE;
pal = (TRGB*)malloc(256*sizeof(TRGB));
if (!pal) 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
void
TGfx0::copy(TGfx0& SrcObject) {
UInt32 count, xCount, yCount;
UInt32 xx, yy;
UInt8 r, g, b;
if (Buffer==NULL) return;
if (SrcObject.Buffer==NULL) return;
xCount = SrcObject.MaxX+1;
if (xCount>MaxX+1) xCount=MaxX+1;
yCount = SrcObject.MaxY+1;
if (yCount>MaxY+1) yCount=MaxY;
if ((BPP!=SrcObject.BPP) || (RedShifter!=SrcObject.RedShifter) ||
(BlueShifter!=SrcObject.BlueShifter) ||
(GreenShifter!=SrcObject.GreenShifter)) {
for (yy=0; yy<yCount; yy++)
for (xx=0; xx<xCount; xx++) {
SrcObject.unpackRGB(SrcObject.getPixel(xx,yy),r,g,b);
putPixel(xx,yy,RGB(r,g,b));
} // for
} // if
else
{
xCount=xCount*((BPP+7) >> 3); // adjust for bpp
for (count=0; count<=yCount; 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; yy++)
for (xx=0; xx<xCount; xx++)
putPixel(DestX+xx,DestY+yy,pixmap[SrcObject.getPixel(x1+xx,y1+yy)]);
} // if srcobject->bpp
else
{
for (yy=0; yy<yCount; yy++)
for (xx=0; xx<xCount; 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; count++) {
memcpy(((char*)Buffer+LineOfs[DestY+count]+DestX), // dest
((char*)SrcObject.Buffer+SrcObject.LineOfs[y1+count]+x1), // src
xCount); // len
}
} // else
} // TGfx0::copyBuf
void
TGfx0::flipX(void) {
} // TGfx0::flipX
void
TGfx0::flipY(void) {
} // TGfx0::flipY
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,%%ebx,4), %%edi \n" // add edi, [esi + ebx*4]
" add %%ecx, %%edi \n" // add edi, ecx
" movzbl (%%edi),%%eax \n" // edx,byte ptr [edi]
" mov %%eax, %4 \n" // mov result, eax
:
: "D" (Buffer), "S" (LineOfs), // %0, %1
"c" (x), "b" (y), // %2, %3
"m" (result) // %4
);
break;
case 15:
case 16:
asm(
" add %%ecx, %%ecx \n" // add ecx, ecx {adjust for pixel size}
" 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]
" mov %%eax, %4 \n" // mov result, eax
:
: "D" (Buffer), "S" (LineOfs), // %0, %1
"c" (x), "b" (y), // %2, %3
"m" (result) // %4
);
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,%%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, %4 \n" // mov result, eax
:
: "D" (Buffer), "S" (LineOfs), // %0, %1
"c" (x), "b" (y), // %2, %3
"m" (result) // %4
);
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 %%ecx, %%edi \n" // add edi, ecx
" mov (%%edi),%%eax \n" // eax,word ptr [edi]
" mov %%eax, %4 \n" // mov result, eax
:
: "D" (Buffer), "S" (LineOfs), // %0, %1
"c" (x), "b" (y), // %2, %3
"m" (result) // %4
);
} // 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;
}
void
TGfx0::hLine(Int32 x1, Int32 x2, Int32 y, UInt32 colour) {
} // 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]
" mov %4, %%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), // %0, %1
"c" (x), "b" (y), // %2, %3
"m" (colour) // %4
);
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}
" mov %4, %%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), // %0, %1
"c" (x), "b" (y), // %2, %3
"m" (colour) // %4
);
break;
case 24:
asm(
// { Calculate offset, prepare the pixel to be drawn }
" add (%%esi,%%ebx,4),%%edi \n" // add edi, [esi + ebx * 4]
" 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), // %0, %1
"c" (x), "b" (y), // %2, %3
"a" (colour) // %4
);
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,%%ebx,4),%%edi \n" // add edi, [esi + ebx * 4]
" add %%ecx, %%edi \n" // add edi, ecx
// { Draw the pixel }
" mov %%eax, (%%edi) \n" // mov [edi], eax
:
: "D" (Buffer), "S" (LineOfs), // %0, %1
"c" (x), "b" (y), // %2, %3
"a" (colour) // %4
);
} // 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::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
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()
