private unsafe static void exePolyFT4(PSX_LIBGPU.POLY_FT4 *p)
{
Boolean tge = PSXGPU.IsShadeTex(p->code);
PSXGPU.DrawPolyGT3(PSXGPU.DRAW_BEGIN, p->code, p->clut, p->tpage, tge, ref p->rgbc0, ref p->xy0, ref p->uv0, ref p->rgbc0, ref p->xy1, ref p->uv1, ref p->rgbc0, ref p->xy2, ref p->uv2);
PSXGPU.DrawPolyGT3(PSXGPU.DRAW_END, p->code, p->clut, p->tpage, tge, ref p->rgbc0, ref p->xy2, ref p->uv2, ref p->rgbc0, ref p->xy1, ref p->uv1, ref p->rgbc0, ref p->xy3, ref p->uv3);
}
public static void DrawSprt(Boolean abe, Boolean tge, ref Color32 c0, ref PSX_LIBGPU.XY p0, ref PSX_LIBGPU.UV t0, ref PSX_LIBGPU.WH size, Int32 TP, Int32 ABR, Int32 TY, Int32 TX, Int32 clutY, Int32 clutX)
{
Byte a = c0.a;
PSXGPU.p1.x = (Single)(p0.x + size.w);
PSXGPU.p1.y = (Single)(p0.y + size.h);
PSXGPU.p1.z = PSXGPU.zDepth;
PSXGPU.uv0.x = (Single)t0.u + 0.5f;
PSXGPU.uv0.y = (Single)t0.v + 0.5f;
PSXGPU.uv1.x = (Single)((Int16)t0.u + size.w) - 0.5f;
PSXGPU.uv1.y = (Single)((Int16)t0.v + size.h) - 0.5f;
PSXGPU.SetMaterial(PSXGPU.matPSXShaderTextureShading);
PSXGPU.SetTexture(TP, TY, TX, clutY, clutX, FilterMode.Bilinear);
c0.a = PSXGPU.SetShader(abe, ABR, PSXGPU.drOffset);
PSXGPU.SetPolygon(7);
GL.Color(c0);
GL.TexCoord(PSXGPU.uv0);
GL.Vertex3((Single)p0.x, (Single)p0.y, PSXGPU.zDepth);
GL.Color(c0);
GL.TexCoord2(PSXGPU.uv1.x, PSXGPU.uv0.y);
GL.Vertex3(PSXGPU.p1.x, (Single)p0.y, PSXGPU.zDepth);
GL.Color(c0);
GL.TexCoord(PSXGPU.uv1);
GL.Vertex(PSXGPU.p1);
GL.Color(c0);
GL.TexCoord2(PSXGPU.uv0.x, PSXGPU.uv1.y);
GL.Vertex3((Single)p0.x, PSXGPU.p1.y, PSXGPU.zDepth);
GL.End();
c0.a = a;
}
private unsafe static void exeTILE_16(PSX_LIBGPU.TILE_16 *ObjPtr)
{
Boolean abe = PSXGPU.IsSemiTrans(ObjPtr->code);
Color32 c = new Color32(ObjPtr->r0, ObjPtr->g0, ObjPtr->b0, Byte.MaxValue);
Vector3 p = new Vector3((Single)ObjPtr->x0, (Single)ObjPtr->y0, PSXGPU.zDepth);
PSXGPU.DrawTile(abe, c, p, new Vector2(16f, 16f));
}
private unsafe static void exeDR_TPAGE(PSX_LIBGPU.DR_TPAGE *ObjPtr)
{
UInt16 obj = (UInt16)(ObjPtr->code[0] & 65535u);
PSXGPU.GlobalFlagTP = PSXGPU.GetFlagTP(obj);
PSXGPU.GlobalFlagABR = PSXGPU.GetFlagABR(obj);
PSXGPU.GlobalFlagTY = PSXGPU.GetFlagTY(obj);
PSXGPU.GlobalFlagTX = PSXGPU.GetFlagTX(obj);
}
private unsafe static void exeLineF2(PSX_LIBGPU.LINE_F2 *ObjPtr)
{
Boolean abe = PSXGPU.IsSemiTrans(ObjPtr->code);
Color32 color = new Color32(ObjPtr->r0, ObjPtr->g0, ObjPtr->b0, Byte.MaxValue);
Vector3 p = new Vector3((Single)ObjPtr->x0, (Single)ObjPtr->y0, PSXGPU.zDepth);
Vector3 vector = new Vector3((Single)ObjPtr->x1, (Single)ObjPtr->y1, PSXGPU.zDepth);
PSXGPU.DrawLineG2(abe, color, p, color, vector);
}
private unsafe static void exePolyF3(PSX_LIBGPU.POLY_F3 *ObjPtr)
{
Boolean abe = PSXGPU.IsSemiTrans(ObjPtr->code);
Color32 color = new Color32(ObjPtr->r0, ObjPtr->g0, ObjPtr->b0, Byte.MaxValue);
Vector3 p = new Vector3((Single)ObjPtr->x0, (Single)ObjPtr->y0, PSXGPU.zDepth);
Vector3 vector = new Vector3((Single)ObjPtr->x1, (Single)ObjPtr->y1, PSXGPU.zDepth);
Vector3 p2 = new Vector3((Single)ObjPtr->x2, (Single)ObjPtr->y2, PSXGPU.zDepth);
PSXGPU.DrawPolyG3(abe, color, p, color, vector, color, p2);
}
public static void DrawLineG2(Boolean blend, Color32 beginColor, Vector3 begin, Color32 endColor, Vector3 end)
{
PSXGPU.SetMaterial(PSXGPU.matPSXShaderNoTexture);
beginColor.a = (endColor.a = PSXGPU.SetShader(blend, PSXGPU.GlobalFlagABR, PSXGPU.drOffset));
PSXGPU.SetPolygon(1);
GL.Color(beginColor);
GL.Vertex(begin);
GL.Color(endColor);
GL.Vertex(end);
GL.End();
}
private unsafe static void exeSPRT(PSX_LIBGPU.SPRT *p)
{
Boolean abe = PSXGPU.IsSemiTrans(p->code);
Boolean tge = PSXGPU.IsShadeTex(p->code);
Int32 globalFlagTP = PSXGPU.GlobalFlagTP;
Int32 globalFlagABR = PSXGPU.GlobalFlagABR;
Int32 globalFlagTY = PSXGPU.GlobalFlagTY;
Int32 globalFlagTX = PSXGPU.GlobalFlagTX;
Int32 flagClutY = PSXGPU.GetFlagClutY(p->clut);
Int32 flagClutX = PSXGPU.GetFlagClutX(p->clut);
PSXGPU.DrawSprt(abe, tge, ref p->rgbc, ref p->xy0, ref p->uv0, ref p->wh, globalFlagTP, globalFlagABR, globalFlagTY, globalFlagTX, flagClutY, flagClutX);
}
private unsafe static void exeLineG3(PSX_LIBGPU.LINE_G3 *ObjPtr)
{
Boolean abe = PSXGPU.IsSemiTrans(ObjPtr->code);
Color32 c = new Color32(ObjPtr->r0, ObjPtr->g0, ObjPtr->b0, Byte.MaxValue);
Color32 color = new Color32(ObjPtr->r1, ObjPtr->g1, ObjPtr->b1, Byte.MaxValue);
Color32 c2 = new Color32(ObjPtr->r2, ObjPtr->g2, ObjPtr->b2, Byte.MaxValue);
Vector3 p = new Vector3((Single)ObjPtr->x0, (Single)ObjPtr->y0, PSXGPU.zDepth);
Vector3 p2 = new Vector3((Single)ObjPtr->x1, (Single)ObjPtr->y1, PSXGPU.zDepth);
Vector3 vector = new Vector3((Single)ObjPtr->x2, (Single)ObjPtr->y2, PSXGPU.zDepth);
PSXGPU.DrawLineG2(abe, c, p, color, p2);
PSXGPU.DrawLineG2(abe, color, p2, c2, vector);
}
public static void DrawPolyG3(Boolean abe, Color32 c0, Vector3 p0, Color32 c1, Vector3 p1, Color32 c2, Vector3 p2)
{
PSXGPU.SetMaterial(PSXGPU.matPSXShaderNoTexture);
c0.a = (c1.a = (c2.a = PSXGPU.SetShader(abe, PSXGPU.GlobalFlagABR, PSXGPU.drOffset)));
PSXGPU.SetPolygon(4);
GL.Color(c0);
GL.Vertex(p0);
GL.Color(c1);
GL.Vertex(p1);
GL.Color(c2);
GL.Vertex(p2);
GL.End();
}
static PSXGPU()
{
PSXGPU.InitMaterial();
PSXGPU.p1 = default(Vector3);
PSXGPU.uv0 = default(Vector3);
PSXGPU.uv1 = default(Vector3);
PSXGPU.constOffset = new Vector4(-9999f, -9999f, -9999f, 0.5f);
PSXGPU.constTexSize = new Vector4(-9999f, -9999f, 0f, 0f);
PSXGPU.constOffsetB = new Vector4(-9999f, -9999f, -9999f, 0.5f);
PSXGPU.constTexSizeB = new Vector4(-9999f, -9999f, 0f, 0f);
PSXGPU.isNeedSetPass = true;
PSXGPU.isNeedEnd = false;
PSXGPU.blendIndex = -1;
PSXGPU.texKey = 4294967280u;
}
public static void DrawTile(Boolean abe, Color32 c0, Vector3 p0, Vector2 size)
{
PSXGPU.SetMaterial(PSXGPU.matPSXShaderNoTexture);
c0.a = PSXGPU.SetShader(abe, PSXGPU.GlobalFlagABR, PSXGPU.drOffset);
PSXGPU.SetPolygon(7);
GL.Color(c0);
GL.Vertex(p0);
GL.Color(c0);
GL.Vertex(p0 + new Vector3(size.x, 0f, 0f));
GL.Color(c0);
GL.Vertex(p0 + new Vector3(size.x, size.y, 0f));
GL.Color(c0);
GL.Vertex(p0 + new Vector3(0f, size.y, 0f));
GL.End();
}
private unsafe static void exePolyG4(PSX_LIBGPU.POLY_G4 *ObjPtr)
{
Boolean abe = PSXGPU.IsSemiTrans(ObjPtr->code);
Color32 c = new Color32(ObjPtr->r0, ObjPtr->g0, ObjPtr->b0, Byte.MaxValue);
Color32 c2 = new Color32(ObjPtr->r1, ObjPtr->g1, ObjPtr->b1, Byte.MaxValue);
Color32 color = new Color32(ObjPtr->r2, ObjPtr->g2, ObjPtr->b2, Byte.MaxValue);
Color32 c3 = new Color32(ObjPtr->r3, ObjPtr->g3, ObjPtr->b3, Byte.MaxValue);
Vector3 p = new Vector3((Single)ObjPtr->x0, (Single)ObjPtr->y0, PSXGPU.zDepth);
Vector3 vector = new Vector3((Single)ObjPtr->x1, (Single)ObjPtr->y1, PSXGPU.zDepth);
Vector3 vector2 = new Vector3((Single)ObjPtr->x2, (Single)ObjPtr->y2, PSXGPU.zDepth);
Vector3 p2 = new Vector3((Single)ObjPtr->x3, (Single)ObjPtr->y3, PSXGPU.zDepth);
PSXGPU.DrawPolyG3(abe, c, p, c2, vector, color, vector2);
PSXGPU.DrawPolyG3(abe, color, vector2, c2, vector, c3, p2);
}
public static void DrawPolyGT3(Int32 drawMode, Byte code, UInt16 clut, UInt16 tpage, Boolean tge, ref Color32 c0, ref PSX_LIBGPU.XY p0, ref PSX_LIBGPU.UV t0, ref Color32 c1, ref PSX_LIBGPU.XY p1, ref PSX_LIBGPU.UV t1, ref Color32 c2, ref PSX_LIBGPU.XY p2, ref PSX_LIBGPU.UV t2)
{
Byte a = c0.a;
Byte a2 = c1.a;
Byte a3 = c2.a;
Boolean abe = PSXGPU.IsSemiTrans(code);
Int32 flagABR = PSXGPU.GetFlagABR(tpage);
if ((drawMode & 1) != 0)
{
Int32 flagTP = PSXGPU.GetFlagTP(tpage);
Int32 flagTY = PSXGPU.GetFlagTY(tpage);
Int32 flagTX = PSXGPU.GetFlagTX(tpage);
Int32 flagClutY = PSXGPU.GetFlagClutY(clut);
Int32 flagClutX = PSXGPU.GetFlagClutX(clut);
PSXGPU.SetMaterial(PSXGPU.matPSXShaderTextureShading);
PSXGPU.SetTexture(flagTP, flagTY, flagTX, flagClutY, flagClutX, FilterMode.Point);
c0.a = (c1.a = (c2.a = PSXGPU.SetShader(abe, flagABR, PSXGPU.drOffset)));
PSXGPU.SetPolygon(4);
}
else
{
c0.a = (c1.a = (c2.a = PSXGPU.GetAlpha(abe, flagABR)));
}
GL.Color(c0);
GL.TexCoord2((Single)t0.u, (Single)t0.v);
GL.Vertex3((Single)p0.x, (Single)p0.y, PSXGPU.zDepth);
GL.Color(c1);
GL.TexCoord2((Single)t1.u, (Single)t1.v);
GL.Vertex3((Single)p1.x, (Single)p1.y, PSXGPU.zDepth);
GL.Color(c2);
GL.TexCoord2((Single)t2.u, (Single)t2.v);
GL.Vertex3((Single)p2.x, (Single)p2.y, PSXGPU.zDepth);
if ((drawMode & 2) != 0)
{
GL.End();
}
c0.a = a;
c1.a = a2;
c2.a = a3;
}
private unsafe static void exePolyGT4(PSX_LIBGPU.POLY_GT4 *p)
{
PSXGPU.DrawPolyGT3(PSXGPU.DRAW_BEGIN, p->code, p->clut, p->tpage, false, ref p->rgbc0, ref p->xy0, ref p->uv0, ref p->rgbc1, ref p->xy1, ref p->uv1, ref p->rgbc2, ref p->xy2, ref p->uv2);
PSXGPU.DrawPolyGT3(PSXGPU.DRAW_END, p->code, p->clut, p->tpage, false, ref p->rgbc2, ref p->xy2, ref p->uv2, ref p->rgbc1, ref p->xy1, ref p->uv1, ref p->rgbc3, ref p->xy3, ref p->uv3);
}
public unsafe static void exePrim(void *addr)
{
PSXGPU.isNeedEnd = false;
PSXGPU.curMaterial = (PSXMaterial)null;
switch (PSXGPU.ff9debugGetPrimType((PSX_LIBGPU.P_TAG *)addr, true))
{
case PSXGPU.FF9DebugPrimType.FF9DEBUG_PRIMTYPE_POLY_F3:
PSXGPU.exePolyF3((PSX_LIBGPU.POLY_F3 *)addr);
break;
case PSXGPU.FF9DebugPrimType.FF9DEBUG_PRIMTYPE_POLY_FT3:
PSXGPU.exePolyFT3((PSX_LIBGPU.POLY_FT3 *)addr);
break;
case PSXGPU.FF9DebugPrimType.FF9DEBUG_PRIMTYPE_POLY_G3:
PSXGPU.exePolyG3((PSX_LIBGPU.POLY_G3 *)addr);
break;
case PSXGPU.FF9DebugPrimType.FF9DEBUG_PRIMTYPE_POLY_GT3:
PSXGPU.exePolyGT3((PSX_LIBGPU.POLY_GT3 *)addr);
break;
case PSXGPU.FF9DebugPrimType.FF9DEBUG_PRIMTYPE_POLY_F4:
PSXGPU.exePolyF4((PSX_LIBGPU.POLY_F4 *)addr);
break;
case PSXGPU.FF9DebugPrimType.FF9DEBUG_PRIMTYPE_POLY_FT4:
PSXGPU.exePolyFT4((PSX_LIBGPU.POLY_FT4 *)addr);
break;
case PSXGPU.FF9DebugPrimType.FF9DEBUG_PRIMTYPE_POLY_G4:
PSXGPU.exePolyG4((PSX_LIBGPU.POLY_G4 *)addr);
break;
case PSXGPU.FF9DebugPrimType.FF9DEBUG_PRIMTYPE_POLY_GT4:
PSXGPU.exePolyGT4((PSX_LIBGPU.POLY_GT4 *)addr);
break;
case PSXGPU.FF9DebugPrimType.FF9DEBUG_PRIMTYPE_SPRT_8:
PSXGPU.exeSPRT_8((PSX_LIBGPU.SPRT_8 *)addr);
break;
case PSXGPU.FF9DebugPrimType.FF9DEBUG_PRIMTYPE_SPRT_16:
PSXGPU.exeSPRT_16((PSX_LIBGPU.SPRT_16 *)addr);
break;
case PSXGPU.FF9DebugPrimType.FF9DEBUG_PRIMTYPE_SPRT:
PSXGPU.exeSPRT((PSX_LIBGPU.SPRT *)addr);
break;
case PSXGPU.FF9DebugPrimType.FF9DEBUG_PRIMTYPE_TILE_1:
PSXGPU.exeTILE_1((PSX_LIBGPU.TILE_1 *)addr);
break;
case PSXGPU.FF9DebugPrimType.FF9DEBUG_PRIMTYPE_TILE_8:
PSXGPU.exeTILE_8((PSX_LIBGPU.TILE_8 *)addr);
break;
case PSXGPU.FF9DebugPrimType.FF9DEBUG_PRIMTYPE_TILE_16:
PSXGPU.exeTILE_16((PSX_LIBGPU.TILE_16 *)addr);
break;
case PSXGPU.FF9DebugPrimType.FF9DEBUG_PRIMTYPE_TILE:
PSXGPU.exeTILE((PSX_LIBGPU.TILE *)addr);
break;
case PSXGPU.FF9DebugPrimType.FF9DEBUG_PRIMTYPE_LINE_F2:
PSXGPU.exeLineF2((PSX_LIBGPU.LINE_F2 *)addr);
break;
case PSXGPU.FF9DebugPrimType.FF9DEBUG_PRIMTYPE_LINE_G2:
PSXGPU.exeLineG2((PSX_LIBGPU.LINE_G2 *)addr);
break;
case PSXGPU.FF9DebugPrimType.FF9DEBUG_PRIMTYPE_LINE_F3:
PSXGPU.exeLineF3((PSX_LIBGPU.LINE_F3 *)addr);
break;
case PSXGPU.FF9DebugPrimType.FF9DEBUG_PRIMTYPE_LINE_G3:
PSXGPU.exeLineG3((PSX_LIBGPU.LINE_G3 *)addr);
break;
case PSXGPU.FF9DebugPrimType.FF9DEBUG_PRIMTYPE_LINE_F4:
PSXGPU.exeLineF4((PSX_LIBGPU.LINE_F4 *)addr);
break;
case PSXGPU.FF9DebugPrimType.FF9DEBUG_PRIMTYPE_LINE_G4:
PSXGPU.exeLineG4((PSX_LIBGPU.LINE_G4 *)addr);
break;
case PSXGPU.FF9DebugPrimType.FF9DEBUG_PRIMTYPE_DR_TWIN:
PSXGPU.exeDR_TWIN((PSX_LIBGPU.DR_TWIN *)addr);
break;
case PSXGPU.FF9DebugPrimType.FF9DEBUG_PRIMTYPE_DR_AREA:
PSXGPU.exeDR_AREA((PSX_LIBGPU.DR_AREA *)addr);
break;
case PSXGPU.FF9DebugPrimType.FF9DEBUG_PRIMTYPE_DR_OFFSET:
PSXGPU.exeDR_OFFSET((PSX_LIBGPU.DR_OFFSET *)addr);
break;
case PSXGPU.FF9DebugPrimType.FF9DEBUG_PRIMTYPE_DR_MODE:
PSXGPU.exeDR_MODE((PSX_LIBGPU.DR_MODE *)addr);
break;
case PSXGPU.FF9DebugPrimType.FF9DEBUG_PRIMTYPE_DR_ENV:
PSXGPU.exeDR_ENV((PSX_LIBGPU.DR_ENV *)addr);
break;
case PSXGPU.FF9DebugPrimType.FF9DEBUG_PRIMTYPE_DR_LOAD:
PSXGPU.exeDR_LOAD((PSX_LIBGPU.DR_LOAD *)addr);
break;
case PSXGPU.FF9DebugPrimType.FF9DEBUG_PRIMTYPE_DR_TPAGE:
PSXGPU.exeDR_TPAGE((PSX_LIBGPU.DR_TPAGE *)addr);
break;
case PSXGPU.FF9DebugPrimType.FF9DEBUG_PRIMTYPE_DR_STP:
PSXGPU.exeDR_STP((PSX_LIBGPU.DR_STP *)addr);
break;
}
if (PSXGPU.isNeedEnd)
{
}
}
public Color32[] CreateBufferColor32(Int32 tp, Int32 tx, Int32 ty, Int32 u, Int32 v, Int32 w, Int32 h, Int32 clutX, Int32 clutY, Boolean enableSemiTransparent, Int32 abr)
{
Color32[] array = new Color32[w * h];
ty = PSXGPU.GetPixelCoorTY(ty);
tx = PSXGPU.GetPixelCoorTX(tx);
clutY = PSXGPU.GetPixelCoorClutY(clutY);
clutX = PSXGPU.GetPixelCoorClutX(clutX);
if (tp == 0)
{
Int32 num = w / 4;
if (w % 4 != 0)
{
num++;
}
for (Int32 i = 0; i < h; i++)
{
Int32 num2 = 0;
for (Int32 j = 0; j < num; j++)
{
Int32 num3 = tx + u / 4 + j;
Int32 num4 = ty + v + i;
Int32 pixelIndex = num3 + num4 * 1024;
UInt16 pixel = this.GetPixel(pixelIndex);
Int32 num5 = j * 4 + i * w;
if (num2 == w)
{
break;
}
Int32 dataFromBit = (Int32)this.GetDataFromBit((UInt32)pixel, 0, 3);
array[num5] = PSX.ConvertABGR16toABGR32(this.GetPixel(clutX + clutY * 1024 + dataFromBit), enableSemiTransparent, abr);
num2++;
num5++;
if (num2 == w)
{
break;
}
dataFromBit = (Int32)this.GetDataFromBit((UInt32)pixel, 4, 7);
array[num5] = PSX.ConvertABGR16toABGR32(this.GetPixel(clutX + clutY * 1024 + dataFromBit), enableSemiTransparent, abr);
num2++;
num5++;
if (num2 == w)
{
break;
}
dataFromBit = (Int32)this.GetDataFromBit((UInt32)pixel, 8, 11);
array[num5] = PSX.ConvertABGR16toABGR32(this.GetPixel(clutX + clutY * 1024 + dataFromBit), enableSemiTransparent, abr);
num2++;
num5++;
if (num2 == w)
{
break;
}
dataFromBit = (Int32)this.GetDataFromBit((UInt32)pixel, 12, 15);
array[num5] = PSX.ConvertABGR16toABGR32(this.GetPixel(clutX + clutY * 1024 + dataFromBit), enableSemiTransparent, abr);
num2++;
}
}
}
else if (tp == 1)
{
Int32 num6 = w / 2;
if (w % 2 != 0)
{
num6++;
}
for (Int32 k = 0; k < h; k++)
{
Int32 num7 = 0;
for (Int32 l = 0; l < num6; l++)
{
Int32 num8 = tx + u / 2 + l;
Int32 num9 = ty + v + k;
Int32 pixelIndex2 = num8 + num9 * 1024;
UInt16 pixel2 = this.GetPixel(pixelIndex2);
Int32 num10 = l * 2 + k * w;
if (num7 == w)
{
break;
}
Int32 dataFromBit2 = (Int32)this.GetDataFromBit((UInt32)pixel2, 0, 7);
array[num10] = PSX.ConvertABGR16toABGR32(this.GetPixel(clutX + clutY * 1024 + dataFromBit2), enableSemiTransparent, abr);
num7++;
num10++;
if (num7 == w)
{
break;
}
dataFromBit2 = (Int32)this.GetDataFromBit((UInt32)pixel2, 8, 15);
array[num10] = PSX.ConvertABGR16toABGR32(this.GetPixel(clutX + clutY * 1024 + dataFromBit2), enableSemiTransparent, abr);
num7++;
}
}
}
else if (tp == 2)
{
for (Int32 m = 0; m < h; m++)
{
for (Int32 n = 0; n < w; n++)
{
Int32 num11 = tx + u + n;
Int32 num12 = ty + v + m;
Int32 pixelIndex3 = num11 + num12 * 1024;
Int32 num13 = n + m * w;
array[num13] = PSX.ConvertABGR16toABGR32(this.GetPixel(pixelIndex3), enableSemiTransparent, abr);
}
}
}
return(array);
}
public static void DrawLine(Vector3 start, Vector3 end, [Optional] Color color, float duration = 0.0f, bool depthTest = true)
{
PSXGPU.DrawLineG2(false, color, start, color, end);
}
