X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?p=pcsx_rearmed.git;a=blobdiff_plain;f=plugins%2Fgpu-gles%2FgpuPrim.c;h=2f200ebfc11de745ce1723c3a194116d7a98ffd2;hp=980d3ddaa597c6c4f3c9b8f52f1c2d361e6d5571;hb=2857d72e4ca743bba3cf55e298949e24d97dff02;hpb=7eadbf885fc9ebd271fa0d7bce3f27394488b059

diff --git a/plugins/gpu-gles/gpuPrim.c b/plugins/gpu-gles/gpuPrim.c
index 980d3dda..2f200ebf 100644
--- a/plugins/gpu-gles/gpuPrim.c
+++ b/plugins/gpu-gles/gpuPrim.c
@@ -26,13 +26,6 @@
 
 #define _IN_PRIMDRAW
 
-#ifdef _WINDOWS
-#include "stdafx.h"
-#include "externals.h"
-#include "gpu.h"
-#include "draw.h"
-#include "texture.h"
-#else
 #include "gpuStdafx.h"
 #include "gpuExternals.h"
 #include "gpuPlugin.h"
@@ -40,8 +33,6 @@
 #include "gpuTexture.h"
 #include "gpuPrim.h"
 
-#endif
-
 ////////////////////////////////////////////////////////////////////////                                          
 // defines
 ////////////////////////////////////////////////////////////////////////
@@ -53,10 +44,9 @@
 // globals
 ////////////////////////////////////////////////////////////////////////
 
-//#ifndef _WINDOWS
-//EGLSurface surface;
-//EGLDisplay display;
-//#endif
+EGLSurface surface;
+EGLDisplay display;
+
 
 BOOL           bDrawTextured;                          // current active drawing states
 BOOL           bDrawSmoothShaded;
@@ -100,6 +90,19 @@ BOOL          bUseFixes;
 
 long          drawX,drawY,drawW,drawH;                 // offscreen drawing checkers
 short         sxmin,sxmax,symin,symax;
+unsigned int CSVERTEX=0,CSCOLOR=0,CSTEXTURE=0;
+
+void offsetPSX4(void)
+{
+ lx0 += PSXDisplay.DrawOffset.x;
+ ly0 += PSXDisplay.DrawOffset.y;
+ lx1 += PSXDisplay.DrawOffset.x;
+ ly1 += PSXDisplay.DrawOffset.y;
+ lx2 += PSXDisplay.DrawOffset.x;
+ ly2 += PSXDisplay.DrawOffset.y;
+ lx3 += PSXDisplay.DrawOffset.x;
+ ly3 += PSXDisplay.DrawOffset.y;
+}
 
 ////////////////////////////////////////////////////////////////////////                                          
 // Update global TP infos
@@ -146,66 +149,6 @@ void UpdateGlobalTP(unsigned short gdata)
 // Some ASM color convertion... Lewpy's special...
 ////////////////////////////////////////////////////////////////////////
 
-#ifdef _WINDOWS
-#pragma warning  (disable : 4035)
-
-unsigned long DoubleBGR2RGB (unsigned long BGR)
-{
-
-    __asm
-    {
-        mov eax, BGR                /* this can hold the G value */
-        mov ebx, eax                /* this can hold the R value */
-        mov edx, eax                /* this can hold the B value */
-        and ebx, 000000ffh          /* mask the R value */
-        shl ebx, 1
-        test ebx, 00000100h
-        jz    RSKIP
-        mov ebx, 000000ffh
-
-RSKIP: 
-        and eax, 0000ff00h          /* mask the G value */
-        shl eax, 1
-        test eax, 00010000h
-        jz    GSKIP
-        mov eax, 0000ff00h
-
-GSKIP: 
-        and edx, 00ff0000h          /* mask the B value */
-        shl edx, 1
-        test edx, 01000000h
-        jz    BSKIP
-        mov edx, 00ff0000h
-        
-BSKIP: 
-        or  eax, ebx                /* add R to G value */
-        or  eax, edx                /* add B to RG value */
-    }
-    /* Result returned in EAX */
-}
-
-unsigned short BGR24to16 (unsigned long BGR)
-{
-    __asm
-    {
-        mov eax, BGR                /* this can hold the G value */
-        mov ebx, eax                /* this can hold the R value */
-        mov edx, eax                /* this can hold the B value */
-        shr ebx, 3                  /* move the R value */
-        and edx, 00f80000h          /* mask the B value */
-        shr edx, 9                  /* move the B value */
-        and eax, 00f800h            /* mask the G value */
-        shr eax, 6                  /* move the G value */
-        and ebx, 0000001fh          /* mask the R value */
-        or  eax, ebx                /* add R to G value */
-        or  eax, edx                /* add B to RG value */
-    }
-    /* Result returned in AX */
-}
-
-#pragma warning  (default : 4035)
-
-#else
 
 unsigned long DoubleBGR2RGB (unsigned long BGR)
 {
@@ -228,13 +171,12 @@ unsigned short BGR24to16 (unsigned long BGR)
  return ((BGR>>3)&0x1f)|((BGR&0xf80000)>>9)|((BGR&0xf800)>>6);
 }
 
-#endif
 
 ////////////////////////////////////////////////////////////////////////
 // OpenGL primitive drawing commands
 ////////////////////////////////////////////////////////////////////////
 
-__inline void PRIMdrawTexturedQuad(OGLVertex* vertex1, OGLVertex* vertex2, 
+void PRIMdrawTexturedQuad(OGLVertex* vertex1, OGLVertex* vertex2,
                                    OGLVertex* vertex3, OGLVertex* vertex4) 
 {
 
@@ -264,22 +206,23 @@ v[3].xyz.y = fpoint(vertex3->y);
 v[3].xyz.z = fpoint(vertex3->z);
 v[3].st.x = fpoint(vertex3->sow);
 v[3].st.y = fpoint(vertex3->tow);
-
-glEnableClientState(GL_TEXTURE_COORD_ARRAY);
-glEnableClientState(GL_VERTEX_ARRAY);
-glTexCoordPointer(2, GL_FLOAT, sizeof(v[0]), &v[0].st);
-glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0].xyz);
-glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-glDisableClientState(GL_TEXTURE_COORD_ARRAY);
-glDisableClientState(GL_VERTEX_ARRAY); 
+if (CSCOLOR==1) glDisableClientState(GL_COLOR_ARRAY);glError();
+if (CSTEXTURE==0) glEnableClientState(GL_TEXTURE_COORD_ARRAY);glError();
+if (CSVERTEX==0) glEnableClientState(GL_VERTEX_ARRAY);glError();
+glTexCoordPointer(2, GL_FLOAT, sizeof(v[0]), &v[0].st);glError();
+glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0].xyz);glError();
+glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);glError();
+CSTEXTURE=CSVERTEX=1;
+CSCOLOR=0;
 }
 
 ///////////////////////////////////////////////////////// 
 
-__inline void PRIMdrawTexturedTri(OGLVertex* vertex1, OGLVertex* vertex2, 
+void PRIMdrawTexturedTri(OGLVertex* vertex1, OGLVertex* vertex2,
                                   OGLVertex* vertex3) 
 {
 Vertex v[3];
+if (vertex1->x==0&&vertex1->y==0&&vertex2->x==0&&vertex2->y==0&&vertex3->x==0&&vertex3->y==0) return;
 
 v[0].xyz.x = fpoint(vertex1->x);
 v[0].xyz.y = fpoint(vertex1->y);
@@ -298,24 +241,25 @@ v[2].xyz.y = fpoint(vertex3->y);
 v[2].xyz.z = fpoint(vertex3->z);
 v[2].st.x = fpoint(vertex3->sow);
 v[2].st.y = fpoint(vertex3->tow);
-
-glEnableClientState(GL_TEXTURE_COORD_ARRAY);
-glEnableClientState(GL_VERTEX_ARRAY);
-glTexCoordPointer(2, GL_FLOAT, sizeof(v[0]), &v[0].st);
-glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0].xyz);
-glDrawArrays(GL_TRIANGLES, 0, 3);
-glDisableClientState(GL_TEXTURE_COORD_ARRAY);
-glDisableClientState(GL_VERTEX_ARRAY);
+if (CSCOLOR==1) glDisableClientState(GL_COLOR_ARRAY);glError();
+if (CSTEXTURE==0) glEnableClientState(GL_TEXTURE_COORD_ARRAY);glError();
+if (CSVERTEX==0) glEnableClientState(GL_VERTEX_ARRAY);glError();
+glTexCoordPointer(2, GL_FLOAT, sizeof(v[0]), &v[0].st);glError();
+glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0].xyz);glError();
+glDrawArrays(GL_TRIANGLES, 0, 3);glError();
+CSTEXTURE=CSVERTEX=1;
+CSCOLOR=0;
 
 }
 
 ///////////////////////////////////////////////////////// 
 
-__inline void PRIMdrawTexGouraudTriColor(OGLVertex* vertex1, OGLVertex* vertex2, 
+void PRIMdrawTexGouraudTriColor(OGLVertex* vertex1, OGLVertex* vertex2,
                                          OGLVertex* vertex3) 
 {
 
 Vertex2 v[3];
+if (vertex1->x==0&&vertex1->y==0&&vertex2->x==0&&vertex2->y==0&&vertex3->x==0&&vertex3->y==0) return;
 
 v[0].xyz.x = fpoint(vertex1->x);
 v[0].xyz.y = fpoint(vertex1->y);
@@ -347,26 +291,25 @@ v[2].rgba.g = vertex3->c.col[1];
 v[2].rgba.b = vertex3->c.col[2];
 v[2].rgba.a = vertex3->c.col[3];
 
-glEnableClientState(GL_TEXTURE_COORD_ARRAY);
-glEnableClientState(GL_VERTEX_ARRAY);
-glEnableClientState(GL_COLOR_ARRAY);
+if (CSTEXTURE==0) glEnableClientState(GL_TEXTURE_COORD_ARRAY);glError();
+if (CSVERTEX==0) glEnableClientState(GL_VERTEX_ARRAY);glError();
+if (CSCOLOR==0) glEnableClientState(GL_COLOR_ARRAY);glError();
 
-glTexCoordPointer(2, GL_FLOAT, sizeof(v[0]), &v[0].st);
-glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0].xyz);
-glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(v[0]), &v[0].rgba);
+glTexCoordPointer(2, GL_FLOAT, sizeof(v[0]), &v[0].st);glError();
+glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0].xyz);glError();
+glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(v[0]), &v[0].rgba);glError();
 
-glDrawArrays(GL_TRIANGLES, 0, 3);
-glDisableClientState(GL_TEXTURE_COORD_ARRAY);
-glDisableClientState(GL_VERTEX_ARRAY);
-glDisableClientState(GL_COLOR_ARRAY);
+glDrawArrays(GL_TRIANGLES, 0, 3);glError();
+CSTEXTURE=CSVERTEX=CSCOLOR=1;
 }
 
 ///////////////////////////////////////////////////////// 
 
-__inline void PRIMdrawTexGouraudTriColorQuad(OGLVertex* vertex1, OGLVertex* vertex2, 
+void PRIMdrawTexGouraudTriColorQuad(OGLVertex* vertex1, OGLVertex* vertex2,
                                              OGLVertex* vertex3, OGLVertex* vertex4) 
 {
 Vertex2 v[4];
+if (vertex1->x==0&&vertex1->y==0&&vertex2->x==0&&vertex2->y==0&&vertex3->x==0&&vertex3->y==0&&vertex4->x==0&&vertex4->y==0) return;
 
 v[0].xyz.x = fpoint(vertex1->x);
 v[0].xyz.y = fpoint(vertex1->y);
@@ -408,25 +351,24 @@ v[3].rgba.g = vertex3->c.col[1];
 v[3].rgba.b = vertex3->c.col[2];
 v[3].rgba.a = vertex3->c.col[3];
 
-glEnableClientState(GL_TEXTURE_COORD_ARRAY);
-glEnableClientState(GL_VERTEX_ARRAY);
-glEnableClientState(GL_COLOR_ARRAY);
+if (CSTEXTURE==0) glEnableClientState(GL_TEXTURE_COORD_ARRAY);glError();
+if (CSVERTEX==0) glEnableClientState(GL_VERTEX_ARRAY);glError();
+if (CSCOLOR==0) glEnableClientState(GL_COLOR_ARRAY);glError();
 
-glTexCoordPointer(2, GL_FLOAT, sizeof(v[0]), &v[0].st);
-glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0].xyz);
-glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(v[0]), &v[0].rgba);
+glTexCoordPointer(2, GL_FLOAT, sizeof(v[0]), &v[0].st);glError();
+glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0].xyz);glError();
+glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(v[0]), &v[0].rgba);glError();
 
-glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-glDisableClientState(GL_TEXTURE_COORD_ARRAY);
-glDisableClientState(GL_VERTEX_ARRAY);
-glDisableClientState(GL_COLOR_ARRAY);
+glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);glError();
+CSTEXTURE=CSVERTEX=CSCOLOR=1;
 }
 
 ///////////////////////////////////////////////////////// 
 
-__inline void PRIMdrawTri(OGLVertex* vertex1, OGLVertex* vertex2, OGLVertex* vertex3) 
+void PRIMdrawTri(OGLVertex* vertex1, OGLVertex* vertex2, OGLVertex* vertex3)
 {
 Vec3f v[3];
+if (vertex1->x==0&&vertex1->y==0&&vertex2->x==0&&vertex2->y==0&&vertex3->x==0&&vertex3->y==0) return;
 
 v[0].x = fpoint(vertex1->x);
 v[0].y = fpoint(vertex1->y);
@@ -440,18 +382,24 @@ v[2].x = fpoint(vertex3->x);
 v[2].y = fpoint(vertex3->y);
 v[2].z = fpoint(vertex3->z);
 
-glEnableClientState(GL_VERTEX_ARRAY);
-glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0]);
-glDrawArrays(GL_TRIANGLES, 0, 3);
-glDisableClientState(GL_VERTEX_ARRAY);
+if (CSVERTEX==0) glEnableClientState(GL_VERTEX_ARRAY);glError();
+if (CSTEXTURE==1) glDisableClientState(GL_TEXTURE_COORD_ARRAY);glError();
+if (CSCOLOR==1) glDisableClientState(GL_COLOR_ARRAY);glError();
+
+glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0]);glError();
+glDrawArrays(GL_TRIANGLES, 0, 3);glError();
+CSVERTEX=1;
+CSTEXTURE=CSCOLOR=0;
+
 }
 
 ///////////////////////////////////////////////////////// 
 
-__inline void PRIMdrawTri2(OGLVertex* vertex1, OGLVertex* vertex2, 
+void PRIMdrawTri2(OGLVertex* vertex1, OGLVertex* vertex2,
                            OGLVertex* vertex3, OGLVertex* vertex4) 
 {
 Vec3f v[4];
+if (vertex1->x==0&&vertex1->y==0&&vertex2->x==0&&vertex2->y==0&&vertex3->x==0&&vertex3->y==0&&vertex4->x==0&&vertex4->y==0) return;
 
 v[0].x = fpoint(vertex1->x);
 v[0].y = fpoint(vertex1->y);
@@ -469,18 +417,23 @@ v[3].x = fpoint(vertex4->x);
 v[3].y = fpoint(vertex4->y);
 v[3].z = fpoint(vertex4->z);
 
-glEnableClientState(GL_VERTEX_ARRAY);
-glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0]);
-glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-glDisableClientState(GL_VERTEX_ARRAY);
+if (CSVERTEX==0) glEnableClientState(GL_VERTEX_ARRAY);glError();
+if (CSTEXTURE==1) glDisableClientState(GL_TEXTURE_COORD_ARRAY);glError();
+if (CSCOLOR==1) glDisableClientState(GL_COLOR_ARRAY);glError();
+
+glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0]);glError();
+glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);glError();
+CSVERTEX=1;
+CSTEXTURE=CSCOLOR=0;
 }
 
 ///////////////////////////////////////////////////////// 
 
-__inline void PRIMdrawGouraudTriColor(OGLVertex* vertex1, OGLVertex* vertex2, 
+void PRIMdrawGouraudTriColor(OGLVertex* vertex1, OGLVertex* vertex2,
                                       OGLVertex* vertex3) 
 {
 Vertex2 v[3];
+if (vertex1->x==0&&vertex1->y==0&&vertex2->x==0&&vertex2->y==0&&vertex3->x==0&&vertex3->y==0) return;
 
 v[0].xyz.x = fpoint(vertex1->x);
 v[0].xyz.y = fpoint(vertex1->y);
@@ -506,23 +459,25 @@ v[2].rgba.g = vertex3->c.col[1];
 v[2].rgba.b = vertex3->c.col[2];
 v[2].rgba.a = vertex3->c.col[3];
 
-glEnableClientState(GL_VERTEX_ARRAY);
-glEnableClientState(GL_COLOR_ARRAY);
+if (CSVERTEX==0) glEnableClientState(GL_VERTEX_ARRAY);glError();
+if (CSCOLOR==0) glEnableClientState(GL_COLOR_ARRAY);glError();
+if (CSTEXTURE==1) glDisableClientState(GL_TEXTURE_COORD_ARRAY);glError();
 
-glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0].xyz);
-glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(v[0]), &v[0].rgba);
+glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0].xyz);glError();
+glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(v[0]), &v[0].rgba);glError();
 
-glDrawArrays(GL_TRIANGLES, 0, 3);
-glDisableClientState(GL_VERTEX_ARRAY);
-glDisableClientState(GL_COLOR_ARRAY);
+glDrawArrays(GL_TRIANGLES, 0, 3);glError();
+CSVERTEX=CSCOLOR=1;
+CSTEXTURE=0;
 }
 
 ///////////////////////////////////////////////////////// 
 
-__inline void PRIMdrawGouraudTri2Color(OGLVertex* vertex1, OGLVertex* vertex2, 
+void PRIMdrawGouraudTri2Color(OGLVertex* vertex1, OGLVertex* vertex2,
                                        OGLVertex* vertex3, OGLVertex* vertex4) 
 {
 Vertex2 v[4];
+if (vertex1->x==0&&vertex1->y==0&&vertex2->x==0&&vertex2->y==0&&vertex3->x==0&&vertex3->y==0&&vertex4->x==0&&vertex4->y==0) return;
 
 v[0].xyz.x = fpoint(vertex1->x);
 v[0].xyz.y = fpoint(vertex1->y);
@@ -556,22 +511,24 @@ v[3].rgba.g = vertex4->c.col[1];
 v[3].rgba.b = vertex4->c.col[2];
 v[3].rgba.a = vertex4->c.col[3];
 
-glEnableClientState(GL_VERTEX_ARRAY);
-glEnableClientState(GL_COLOR_ARRAY);
+if (CSTEXTURE==1) glDisableClientState(GL_TEXTURE_COORD_ARRAY);glError();
+if (CSVERTEX==0) glEnableClientState(GL_VERTEX_ARRAY);glError();
+if (CSCOLOR==0) glEnableClientState(GL_COLOR_ARRAY);glError();
 
-glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0].xyz);
-glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(v[0]), &v[0].rgba);
+glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0].xyz);glError();
+glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(v[0]), &v[0].rgba);glError();
 
-glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-glDisableClientState(GL_VERTEX_ARRAY);
-glDisableClientState(GL_COLOR_ARRAY);
+glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);glError();
+CSTEXTURE=0;
+CSVERTEX=CSCOLOR=1;
 }
 
 ///////////////////////////////////////////////////////// 
 
-__inline void PRIMdrawFlatLine(OGLVertex* vertex1, OGLVertex* vertex2,OGLVertex* vertex3, OGLVertex* vertex4)
+void PRIMdrawFlatLine(OGLVertex* vertex1, OGLVertex* vertex2,OGLVertex* vertex3, OGLVertex* vertex4)
 {
 Vertex2 v[4];
+if (vertex1->x==0&&vertex1->y==0&&vertex2->x==0&&vertex2->y==0&&vertex3->x==0&&vertex3->y==0&&vertex4->x==0&&vertex4->y==0) return;
 
 v[0].xyz.x = fpoint(vertex1->x);
 v[0].xyz.y = fpoint(vertex1->y);
@@ -605,24 +562,27 @@ v[3].rgba.g = vertex1->c.col[1];
 v[3].rgba.b = vertex1->c.col[2];
 v[3].rgba.a = vertex1->c.col[3];
 
-glEnableClientState(GL_VERTEX_ARRAY);
-glEnableClientState(GL_COLOR_ARRAY);
+if (CSTEXTURE==1) glDisableClientState(GL_TEXTURE_COORD_ARRAY);glError();
+if (CSVERTEX==0) glEnableClientState(GL_VERTEX_ARRAY);glError();
+if (CSCOLOR==0) glEnableClientState(GL_COLOR_ARRAY);glError();
+
+glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0].xyz);glError();
+glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(v[0]), &v[0].rgba);glError();
 
-glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0].xyz);
-glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(v[0]), &v[0].rgba);
+glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);glError();
 
-glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-glDisableClientState(GL_VERTEX_ARRAY);
-glDisableClientState(GL_COLOR_ARRAY);
+CSTEXTURE=0;
+CSVERTEX=CSCOLOR=1;
 
 
 }
 
 ///////////////////////////////////////////////////////// 
      
-__inline void PRIMdrawGouraudLine(OGLVertex* vertex1, OGLVertex* vertex2,OGLVertex* vertex3, OGLVertex* vertex4)
+void PRIMdrawGouraudLine(OGLVertex* vertex1, OGLVertex* vertex2,OGLVertex* vertex3, OGLVertex* vertex4)
 {
 	Vertex2 v[4];
+if (vertex1->x==0&&vertex1->y==0&&vertex2->x==0&&vertex2->y==0&&vertex3->x==0&&vertex3->y==0&&vertex4->x==0&&vertex4->y==0) return;
 
 v[0].xyz.x = fpoint(vertex1->x);
 v[0].xyz.y = fpoint(vertex1->y);
@@ -656,23 +616,25 @@ v[2].rgba.g = vertex4->c.col[1];
 v[2].rgba.b = vertex4->c.col[2];
 v[2].rgba.a = vertex4->c.col[3];
 
-glEnableClientState(GL_VERTEX_ARRAY);
-glEnableClientState(GL_COLOR_ARRAY);
+if (CSTEXTURE==1) glDisableClientState(GL_TEXTURE_COORD_ARRAY);glError();
+if (CSVERTEX==0) glEnableClientState(GL_VERTEX_ARRAY);glError();
+if (CSCOLOR==0) glEnableClientState(GL_COLOR_ARRAY);glError();
 
-glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0].xyz);
-glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(v[0]), &v[0].rgba);
+glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0].xyz);glError();
+glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(v[0]), &v[0].rgba);glError();
 
-glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-glDisableClientState(GL_VERTEX_ARRAY);
-glDisableClientState(GL_COLOR_ARRAY);
+glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);glError();
+CSTEXTURE=0;
+CSVERTEX=CSCOLOR=1;
 }
 
 ///////////////////////////////////////////////////////// 
              
-__inline void PRIMdrawQuad(OGLVertex* vertex1, OGLVertex* vertex2, 
+void PRIMdrawQuad(OGLVertex* vertex1, OGLVertex* vertex2,
                            OGLVertex* vertex3, OGLVertex* vertex4) 
 {
 Vec3f v[4];
+if (vertex1->x==0&&vertex1->y==0&&vertex2->x==0&&vertex2->y==0&&vertex3->x==0&&vertex3->y==0&&vertex4->x==0&&vertex4->y==0) return;
 
 v[0].x = fpoint(vertex1->x);
 v[0].y = fpoint(vertex1->y);
@@ -690,10 +652,15 @@ v[3].x = fpoint(vertex3->x);
 v[3].y = fpoint(vertex3->y);
 v[3].z = fpoint(vertex3->z);
 
-glEnableClientState(GL_VERTEX_ARRAY);
-glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0]);
-glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-glDisableClientState(GL_VERTEX_ARRAY);
+if (CSTEXTURE==1) glDisableClientState(GL_TEXTURE_COORD_ARRAY);glError();
+if (CSVERTEX==0) glEnableClientState(GL_VERTEX_ARRAY);glError();
+if (CSCOLOR==1) glDisableClientState(GL_COLOR_ARRAY);glError();
+
+glVertexPointer(3, GL_FLOAT, sizeof(v[0]), &v[0]);glError();
+glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);glError();
+CSTEXTURE=0;
+CSVERTEX=1;
+CSCOLOR=0;
 }
 
 ////////////////////////////////////////////////////////////////////////                                          
@@ -732,7 +699,7 @@ void SetSemiTrans(void)
  if(!DrawSemiTrans)                                    // no semi trans at all?
   {
    if(bBlendEnable)
-    {glDisable(GL_BLEND);bBlendEnable=FALSE;}          // -> don't wanna blend
+    {glDisable(GL_BLEND);glError();bBlendEnable=FALSE;}// -> don't wanna blend
    ubGloAlpha=ubGloColAlpha=255;                       // -> full alpha
    return;                                             // -> and bye
   }
@@ -740,7 +707,7 @@ void SetSemiTrans(void)
  ubGloAlpha=ubGloColAlpha=TransSets[GlobalTextABR].alpha;
 
  if(!bBlendEnable)
-  {glEnable(GL_BLEND);bBlendEnable=TRUE;}              // wanna blend
+  {glEnable(GL_BLEND);glError();bBlendEnable=TRUE;}    // wanna blend
 
  if(TransSets[GlobalTextABR].srcFac!=obm1 || 
     TransSets[GlobalTextABR].dstFac!=obm2)
@@ -749,7 +716,7 @@ void SetSemiTrans(void)
     {
      obm1=TransSets[GlobalTextABR].srcFac;
      obm2=TransSets[GlobalTextABR].dstFac;
-     glBlendFunc(obm1,obm2);                           // set blend func
+     glBlendFunc(obm1,obm2); glError();                // set blend func
     }
    /*else
    if(TransSets[GlobalTextABR].dstFac !=GL_ONE_MINUS_SRC_COLOR)
@@ -780,7 +747,7 @@ void SetScanTrans(void)                                // blending for scan line
 */
  obm1=TransSets[0].srcFac;
  obm2=TransSets[0].dstFac;
- glBlendFunc(obm1,obm2);                               // set blend func
+ glBlendFunc(obm1,obm2); glError();                    // set blend func
 }
 
 void SetScanTexTrans(void)                             // blending for scan mask texture
@@ -793,7 +760,7 @@ void SetScanTexTrans(void)                             // blending for scan mask
 */
  obm1=TransSets[2].srcFac;
  obm2=TransSets[2].dstFac;
- glBlendFunc(obm1,obm2);                               // set blend func
+ glBlendFunc(obm1,obm2); glError();                    // set blend func
 }
 
 ////////////////////////////////////////////////////////////////////////                                          
@@ -873,11 +840,11 @@ void SetSemiTransMulti(int Pass)
   }
 
  if(!bBlendEnable)
-  {glEnable(GL_BLEND);bBlendEnable=TRUE;}              // wanna blend
+  {glEnable(GL_BLEND);glError();bBlendEnable=TRUE;}    // wanna blend
 
  if(bm1!=obm1 || bm2!=obm2)
   {
-   glBlendFunc(bm1,bm2);                               // set blend func
+   glBlendFunc(bm1,bm2); glError();                    // set blend func
    obm1=bm1;obm2=bm2;
   }
 }
@@ -886,7 +853,7 @@ void SetSemiTransMulti(int Pass)
 // Set several rendering stuff including blending 
 ////////////////////////////////////////////////////////////////////////
 
-__inline void SetZMask3O(void)
+void SetZMask3O(void)
 {
  if(iUseMask && DrawSemiTrans && !iSetMask)
   {
@@ -895,7 +862,7 @@ __inline void SetZMask3O(void)
   }
 }
 
-__inline void SetZMask3(void)
+void SetZMask3(void)
 {
  if(iUseMask)
   {
@@ -909,7 +876,7 @@ __inline void SetZMask3(void)
   }
 }
 
-__inline void SetZMask3NT(void)
+void SetZMask3NT(void)
 {
  if(iUseMask)
   {
@@ -925,7 +892,7 @@ __inline void SetZMask3NT(void)
 
 ////////////////////////////////////////////////////////////////////////
 
-__inline void SetZMask4O(void)
+ void SetZMask4O(void)
 {
  if(iUseMask && DrawSemiTrans && !iSetMask)
   {
@@ -934,7 +901,7 @@ __inline void SetZMask4O(void)
   }
 }
 
-__inline void SetZMask4(void)
+ void SetZMask4(void)
 {
  if(iUseMask)
   {
@@ -948,7 +915,7 @@ __inline void SetZMask4(void)
   }
 }
 
-__inline void SetZMask4NT(void)
+ void SetZMask4NT(void)
 {
  if(iUseMask)
   {
@@ -962,7 +929,7 @@ __inline void SetZMask4NT(void)
   }
 }
 
-__inline void SetZMask4SP(void)
+ void SetZMask4SP(void)
 {
  if(iUseMask)
   {
@@ -983,7 +950,7 @@ __inline void SetZMask4SP(void)
 
 ////////////////////////////////////////////////////////////////////////
 
-__inline void SetRenderState(unsigned long DrawAttributes)
+ void SetRenderState(unsigned long DrawAttributes)
 {
  bDrawNonShaded = (SHADETEXBIT(DrawAttributes)) ? TRUE : FALSE;
  DrawSemiTrans = (SEMITRANSBIT(DrawAttributes)) ? TRUE : FALSE;
@@ -991,7 +958,7 @@ __inline void SetRenderState(unsigned long DrawAttributes)
 
 ////////////////////////////////////////////////////////////////////////                                          
 
-__inline void SetRenderColor(unsigned long DrawAttributes)
+ void SetRenderColor(unsigned long DrawAttributes)
 {
  if(bDrawNonShaded) {g_m1=g_m2=g_m3=128;}
  else
@@ -1018,14 +985,14 @@ void SetRenderMode(unsigned long DrawAttributes,BOOL bSCol)
    else                 currTex=SelectSubTextureS(GlobalTextTP,ulClutID);
 
    if(gTexName!=currTex)
-    {gTexName=currTex;glBindTexture(GL_TEXTURE_2D,currTex);}
+    {gTexName=currTex;glBindTexture(GL_TEXTURE_2D,currTex); glError();}
 
    if(!bTexEnabled)                                    // -> turn texturing on
-    {bTexEnabled=TRUE;glEnable(GL_TEXTURE_2D);}
+    {bTexEnabled=TRUE;glEnable(GL_TEXTURE_2D); glError();}
   }
  else                                                  // no texture ?
  if(bTexEnabled) 
-  {bTexEnabled=FALSE;glDisable(GL_TEXTURE_2D);}        // -> turn texturing off
+  {bTexEnabled=FALSE;glDisable(GL_TEXTURE_2D); glError();} // -> turn texturing off
 
  if(bSCol)                                             // also set color ?
   {
@@ -1051,6 +1018,7 @@ void SetRenderMode(unsigned long DrawAttributes,BOOL bSCol)
   {
    if(bDrawSmoothShaded) glShadeModel(GL_SMOOTH);      // -> set actual shading
    else                  glShadeModel(GL_FLAT);
+   glError();
    bOldSmoothShaded=bDrawSmoothShaded;
   }
 }
@@ -1514,7 +1482,7 @@ void PrepareFullScreenUpload (long Position)
 ////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////
 
-u8 * LoadDirectMovieFast(void);
+unsigned char * LoadDirectMovieFast(void);
 
 void UploadScreenEx(long Position)
 {
@@ -1523,14 +1491,14 @@ void UploadScreenEx(long Position)
  if(!PSXDisplay.DisplayMode.x) return;
  if(!PSXDisplay.DisplayMode.y) return;
 
- glDisable(GL_SCISSOR_TEST);
- glShadeModel(GL_FLAT);
+ glDisable(GL_SCISSOR_TEST); glError();
+ glShadeModel(GL_FLAT); glError();
  bOldSmoothShaded=FALSE;
- glDisable(GL_BLEND);
+ glDisable(GL_BLEND); glError();
  bBlendEnable=FALSE;
- glDisable(GL_TEXTURE_2D);
+ glDisable(GL_TEXTURE_2D); glError();
  bTexEnabled=FALSE;
- glDisable(GL_ALPHA_TEST);
+ glDisable(GL_ALPHA_TEST); glError();
 
  //glPixelZoom(((float)rRatioRect.right)/((float)PSXDisplay.DisplayMode.x),
  //            -1.0f*(((float)rRatioRect.bottom)/((float)PSXDisplay.DisplayMode.y)));
@@ -1594,8 +1562,8 @@ void UploadScreenEx(long Position)
 
 // glPixelZoom(1.0F,1.0F);
 
- glEnable(GL_ALPHA_TEST);
- glEnable(GL_SCISSOR_TEST);
+ glEnable(GL_ALPHA_TEST); glError();
+ glEnable(GL_SCISSOR_TEST); glError();
 }
 
 ////////////////////////////////////////////////////////////////////////
@@ -1745,7 +1713,7 @@ BOOL IsInsideNextScreen(short x, short y, short xoff, short yoff)
 //Mask1    Set mask bit while drawing. 1 = on
 //Mask2    Do not draw to mask areas. 1= on
 
-void cmdSTP(u8 * baseAddr)
+void cmdSTP(unsigned char * baseAddr)
 {
  unsigned long gdata = ((unsigned long*)baseAddr)[0];
 
@@ -1763,13 +1731,13 @@ void cmdSTP(u8 * baseAddr)
    bCheckMask=TRUE;
    if(iDepthFunc==0) return;
    iDepthFunc=0;
-   glDepthFunc(GL_LESS);
+   glDepthFunc(GL_LESS); glError();
   }
  else
   {
    bCheckMask=FALSE;
    if(iDepthFunc==1) return;
-   glDepthFunc(GL_ALWAYS);
+   glDepthFunc(GL_ALWAYS); glError();
    iDepthFunc=1;
   }
 }
@@ -1778,7 +1746,7 @@ void cmdSTP(u8 * baseAddr)
 // cmd: Set texture page infos
 ////////////////////////////////////////////////////////////////////////
 
-void cmdTexturePage(u8 * baseAddr)
+void cmdTexturePage(unsigned char * baseAddr)
 {
  unsigned long gdata = ((unsigned long*)baseAddr)[0];
  UpdateGlobalTP((unsigned short)gdata);
@@ -1789,7 +1757,7 @@ void cmdTexturePage(u8 * baseAddr)
 // cmd: turn on/off texture window
 ////////////////////////////////////////////////////////////////////////
 
-void cmdTextureWindow(u8 *baseAddr)
+void cmdTextureWindow(unsigned char *baseAddr)
 {
  unsigned long gdata = ((unsigned long*)baseAddr)[0];
 
@@ -1998,7 +1966,7 @@ void ClampToPSXScreenOffset(short *x0, short *y0, short *x1, short *y1)
 // cmd: start of drawing area... primitives will be clipped inside
 ////////////////////////////////////////////////////////////////////////
 
-void cmdDrawAreaStart(u8 * baseAddr)
+void cmdDrawAreaStart(unsigned char * baseAddr)
 {
  unsigned long gdata = ((unsigned long*)baseAddr)[0];
 
@@ -2029,7 +1997,7 @@ void cmdDrawAreaStart(u8 * baseAddr)
 // cmd: end of drawing area... primitives will be clipped inside
 ////////////////////////////////////////////////////////////////////////
 
-void cmdDrawAreaEnd(u8 * baseAddr)
+void cmdDrawAreaEnd(unsigned char * baseAddr)
 {
  unsigned long gdata = ((unsigned long*)baseAddr)[0];
 
@@ -2064,7 +2032,7 @@ void cmdDrawAreaEnd(u8 * baseAddr)
 // cmd: draw offset... will be added to prim coords
 ////////////////////////////////////////////////////////////////////////
 
-void cmdDrawOffset(u8 * baseAddr)
+void cmdDrawOffset(unsigned char * baseAddr)
 {
  unsigned long gdata = ((unsigned long*)baseAddr)[0];
 
@@ -2095,7 +2063,7 @@ void cmdDrawOffset(u8 * baseAddr)
 // cmd: load image to vram
 ////////////////////////////////////////////////////////////////////////
 
-void primLoadImage(u8 * baseAddr)
+void primLoadImage(unsigned char * baseAddr)
 {
  unsigned short *sgpuData = ((unsigned short *) baseAddr);
 
@@ -2252,7 +2220,7 @@ void CheckWriteUpdate()
 // cmd: vram -> psx mem
 ////////////////////////////////////////////////////////////////////////
 
-void primStoreImage(u8 * baseAddr)
+void primStoreImage(unsigned char * baseAddr)
 {
  unsigned short *sgpuData = ((unsigned short *) baseAddr);
 
@@ -2274,7 +2242,7 @@ void primStoreImage(u8 * baseAddr)
 // cmd: blkfill - NO primitive! Doesn't care about draw areas...
 ////////////////////////////////////////////////////////////////////////
 
-void primBlkFill(u8 * baseAddr)
+void primBlkFill(unsigned char * baseAddr)
 {
  unsigned long *gpuData = ((unsigned long *) baseAddr);
  short *sgpuData = ((short *) baseAddr);
@@ -2316,9 +2284,9 @@ void primBlkFill(u8 * baseAddr)
      b=((GLclampf)BLUE(gpuData[0]))/255.0f;
      r=((GLclampf)RED(gpuData[0]))/255.0f;
      
-     glDisable(GL_SCISSOR_TEST);                       
-     glClearColor(r,g,b,1.0f);
-     glClear(uiBufferBits); 
+     //glDisable(GL_SCISSOR_TEST); glError();
+     glClearColor(r,g,b,1.0f); glError();
+     glClear(uiBufferBits); glError();
      gl_z=0.0f;
 
      if(gpuData[0]!=0x02000000 &&
@@ -2349,7 +2317,7 @@ void primBlkFill(u8 * baseAddr)
         }
       }
 
-     glEnable(GL_SCISSOR_TEST);                       
+     //glEnable(GL_SCISSOR_TEST); glError();
     }
    else
     {
@@ -2359,9 +2327,9 @@ void primBlkFill(u8 * baseAddr)
      SetRenderMode((unsigned long)0x01000000, FALSE);
      vertex[0].c.lcol=gpuData[0]|0xff000000;
      SETCOL(vertex[0]); 
-     glDisable(GL_SCISSOR_TEST);                       
+     //glDisable(GL_SCISSOR_TEST); glError();
      PRIMdrawQuad(&vertex[0], &vertex[1], &vertex[2], &vertex[3]);
-     glEnable(GL_SCISSOR_TEST);                       
+     //glEnable(GL_SCISSOR_TEST); glError();
     }
   }
 
@@ -2471,7 +2439,7 @@ void MoveImageWrapped(short imageX0,short imageY0,
 
 ////////////////////////////////////////////////////////////////////////
 
-void primMoveImage(u8 * baseAddr)
+void primMoveImage(unsigned char * baseAddr)
 {
  short *sgpuData = ((short *) baseAddr);
  short imageY0,imageX0,imageY1,imageX1,imageSX,imageSY,i,j;
@@ -2630,7 +2598,7 @@ void primMoveImage(u8 * baseAddr)
 // cmd: draw free-size Tile 
 ////////////////////////////////////////////////////////////////////////
 
-void primTileS(u8 * baseAddr)
+void primTileS(unsigned char * baseAddr)
 {
  unsigned long *gpuData = ((unsigned long*)baseAddr);
  short *sgpuData = ((short *) baseAddr);
@@ -2695,7 +2663,7 @@ void primTileS(u8 * baseAddr)
 // cmd: draw 1 dot Tile (point)
 ////////////////////////////////////////////////////////////////////////
 
-void primTile1(u8 * baseAddr)
+void primTile1(unsigned char * baseAddr)
 {
  unsigned long *gpuData = ((unsigned long*)baseAddr);
  short *sgpuData = ((short *) baseAddr);
@@ -2742,7 +2710,7 @@ void primTile1(u8 * baseAddr)
 // cmd: draw 8 dot Tile (small rect)
 ////////////////////////////////////////////////////////////////////////
 
-void primTile8(u8 * baseAddr)
+void primTile8(unsigned char * baseAddr)
 {
  unsigned long *gpuData = ((unsigned long*)baseAddr);
  short *sgpuData = ((short *) baseAddr);
@@ -2789,7 +2757,7 @@ void primTile8(u8 * baseAddr)
 // cmd: draw 16 dot Tile (medium rect)
 ////////////////////////////////////////////////////////////////////////
 
-void primTile16(u8 * baseAddr)
+void primTile16(unsigned char * baseAddr)
 {
  unsigned long *gpuData = ((unsigned long*)baseAddr);
  short *sgpuData = ((short *) baseAddr);
@@ -2900,7 +2868,7 @@ void DrawMultiFilterSprite(void)
 // cmd: small sprite (textured rect)
 ////////////////////////////////////////////////////////////////////////
 
-void primSprt8(u8 * baseAddr)
+void primSprt8(unsigned char * baseAddr)
 {
  unsigned long *gpuData = ((unsigned long *) baseAddr);
  short *sgpuData = ((short *) baseAddr);
@@ -3021,7 +2989,7 @@ void primSprt8(u8 * baseAddr)
 // cmd: medium sprite (textured rect)
 ////////////////////////////////////////////////////////////////////////
 
-void primSprt16(u8 * baseAddr)
+void primSprt16(unsigned char * baseAddr)
 {
  unsigned long *gpuData = ((unsigned long *) baseAddr);
  short *sgpuData = ((short *) baseAddr);
@@ -3141,7 +3109,7 @@ void primSprt16(u8 * baseAddr)
 // cmd: free-size sprite (textured rect)
 ////////////////////////////////////////////////////////////////////////
  
-void primSprtSRest(u8 * baseAddr,unsigned short type)
+void primSprtSRest(unsigned char * baseAddr,unsigned short type)
 {
  unsigned long *gpuData = ((unsigned long *) baseAddr);
  short *sgpuData = ((short *) baseAddr);
@@ -3312,7 +3280,7 @@ void primSprtSRest(u8 * baseAddr,unsigned short type)
   }
 }
 
-void primSprtS(u8 * baseAddr)
+void primSprtS(unsigned char * baseAddr)
 {
  unsigned long *gpuData = ((unsigned long *) baseAddr);
  short *sgpuData = ((short *) baseAddr);
@@ -3451,7 +3419,7 @@ void primSprtS(u8 * baseAddr)
 // cmd: flat shaded Poly4
 ////////////////////////////////////////////////////////////////////////
 
-void primPolyF4(u8 *baseAddr)
+void primPolyF4(unsigned char *baseAddr)
 {
  unsigned long *gpuData = ((unsigned long *) baseAddr);
  short *sgpuData = ((short *) baseAddr);
@@ -3496,7 +3464,7 @@ void primPolyF4(u8 *baseAddr)
 // cmd: smooth shaded Poly4
 ////////////////////////////////////////////////////////////////////////
 
-void primPolyG4(u8 * baseAddr);
+void primPolyG4(unsigned char * baseAddr);
 
 BOOL bDrawOffscreenFrontFF9G4(void)
 {
@@ -3519,9 +3487,9 @@ BOOL bDrawOffscreenFrontFF9G4(void)
  return TRUE;
 }
 
-BOOL bCheckFF9G4(u8 * baseAddr)
+BOOL bCheckFF9G4(unsigned char * baseAddr)
 {
- static u8 pFF9G4Cache[32];
+ static unsigned char pFF9G4Cache[32];
  static int iFF9Fix=0;
 
  if(baseAddr)
@@ -3560,7 +3528,7 @@ BOOL bCheckFF9G4(u8 * baseAddr)
 
 ////////////////////////////////////////////////////////////////////////
 
-void primPolyG4(u8 * baseAddr)
+void primPolyG4(unsigned char * baseAddr)
 {
  unsigned long *gpuData = (unsigned long *)baseAddr;
  short *sgpuData = ((short *) baseAddr);
@@ -3778,7 +3746,7 @@ BOOL DoLineCheck(unsigned long * gpuData)
 
 ////////////////////////////////////////////////////////////////////////
 
-void primPolyFT3(u8 * baseAddr)
+void primPolyFT3(unsigned char * baseAddr)
 {
  unsigned long *gpuData = ((unsigned long *) baseAddr);
  short *sgpuData = ((short *) baseAddr);
@@ -4214,7 +4182,7 @@ void RectTexAlign(void)
 
 }
 
-void primPolyFT4(u8 * baseAddr)
+void primPolyFT4(unsigned char * baseAddr)
 {
  unsigned long *gpuData = ((unsigned long *) baseAddr);
  short *sgpuData = ((short *) baseAddr);
@@ -4302,7 +4270,7 @@ void primPolyFT4(u8 * baseAddr)
 // cmd: smooth shaded Texture3
 ////////////////////////////////////////////////////////////////////////
 
-void primPolyGT3(u8 *baseAddr)
+void primPolyGT3(unsigned char *baseAddr)
 {    
  unsigned long *gpuData = ((unsigned long *) baseAddr);
  short *sgpuData = ((short *) baseAddr);
@@ -4411,7 +4379,7 @@ void primPolyGT3(u8 *baseAddr)
 // cmd: smooth shaded Poly3
 ////////////////////////////////////////////////////////////////////////
 
-void primPolyG3(u8 *baseAddr)
+void primPolyG3(unsigned char *baseAddr)
 {    
  unsigned long *gpuData = ((unsigned long *) baseAddr);
  short *sgpuData = ((short *) baseAddr);
@@ -4456,7 +4424,7 @@ void primPolyG3(u8 *baseAddr)
 // cmd: smooth shaded Texture4
 ////////////////////////////////////////////////////////////////////////
 
-void primPolyGT4(u8 *baseAddr)
+void primPolyGT4(unsigned char *baseAddr)
 { 
  unsigned long *gpuData = ((unsigned long *) baseAddr);
  short *sgpuData = ((short *) baseAddr);
@@ -4576,7 +4544,7 @@ void primPolyGT4(u8 *baseAddr)
 // cmd: smooth shaded Poly3
 ////////////////////////////////////////////////////////////////////////
 
-void primPolyF3(u8 *baseAddr)
+void primPolyF3(unsigned char *baseAddr)
 {    
  unsigned long *gpuData = ((unsigned long *) baseAddr);
  short *sgpuData = ((short *) baseAddr);
@@ -4620,7 +4588,7 @@ void primPolyF3(u8 *baseAddr)
 // cmd: skipping shaded polylines
 ////////////////////////////////////////////////////////////////////////
 
-void primLineGSkip(u8 *baseAddr)
+void primLineGSkip(unsigned char *baseAddr)
 {    
  unsigned long *gpuData = ((unsigned long *) baseAddr);
  short *sgpuData = ((short *) baseAddr);
@@ -4645,7 +4613,7 @@ void primLineGSkip(u8 *baseAddr)
 // cmd: shaded polylines
 ////////////////////////////////////////////////////////////////////////
 
-void primLineGEx(u8 *baseAddr)
+void primLineGEx(unsigned char *baseAddr)
 {    
  unsigned long *gpuData = ((unsigned long *) baseAddr);
  int iMax=255;
@@ -4709,7 +4677,7 @@ void primLineGEx(u8 *baseAddr)
 // cmd: shaded polyline2
 ////////////////////////////////////////////////////////////////////////
 
-void primLineG2(u8 *baseAddr)
+void primLineG2(unsigned char *baseAddr)
 {    
  unsigned long *gpuData = ((unsigned long *) baseAddr);
  short *sgpuData = ((short *) baseAddr);
@@ -4754,7 +4722,7 @@ void primLineG2(u8 *baseAddr)
 // cmd: skipping flat polylines
 ////////////////////////////////////////////////////////////////////////
 
-void primLineFSkip(u8 *baseAddr)
+void primLineFSkip(unsigned char *baseAddr)
 {
  unsigned long *gpuData = ((unsigned long *) baseAddr);
  int i=2,iMax=255;
@@ -4774,7 +4742,7 @@ void primLineFSkip(u8 *baseAddr)
 // cmd: drawing flat polylines
 ////////////////////////////////////////////////////////////////////////
 
-void primLineFEx(u8 *baseAddr)
+void primLineFEx(unsigned char *baseAddr)
 {
  unsigned long *gpuData = ((unsigned long *) baseAddr);
  int iMax;
@@ -4832,7 +4800,7 @@ void primLineFEx(u8 *baseAddr)
 // cmd: drawing flat polyline2
 ////////////////////////////////////////////////////////////////////////
 
-void primLineF2(u8 *baseAddr)
+void primLineF2(unsigned char *baseAddr)
 {
  unsigned long *gpuData = ((unsigned long *) baseAddr);
  short *sgpuData = ((short *) baseAddr);
@@ -4873,7 +4841,7 @@ void primLineF2(u8 *baseAddr)
 // cmd: well, easiest command... not implemented
 ////////////////////////////////////////////////////////////////////////
 
-void primNI(u8 *bA)
+void primNI(unsigned char *bA)
 {
 }
 
@@ -4881,7 +4849,7 @@ void primNI(u8 *bA)
 // cmd func ptr table
 ////////////////////////////////////////////////////////////////////////
 
-void (*primTableJ[256])(u8 *) = 
+void (*primTableJ[256])(unsigned char *) = 
 {
     // 00
     primNI,primNI,primBlkFill,primNI,primNI,primNI,primNI,primNI,
@@ -4953,7 +4921,7 @@ void (*primTableJ[256])(u8 *) =
 // cmd func ptr table for skipping
 ////////////////////////////////////////////////////////////////////////
 
-void (*primTableSkip[256])(u8 *) = 
+void (*primTableSkip[256])(unsigned char *) = 
 {
     // 00
     primNI,primNI,primBlkFill,primNI,primNI,primNI,primNI,primNI,