void DrawBackground()
{
VertexP3fT2fC4b[] vertices = game.ModelCache.vertices;
int index = 0, atlasIndex = 0;
int drawnY = 0, height = game.Height;
PackedCol col = new PackedCol(64, 64, 64);
int texLoc = BlockInfo.GetTextureLoc(Block.Dirt, Side.Top);
Texture tex = new Texture(0, 0, 0, game.Width, 64,
Atlas1D.GetTexRec(texLoc, 1, out atlasIndex));
tex.U2 = (float)game.Width / 64;
bool bound = false;
while (drawnY < height)
{
tex.Y1 = drawnY;
IGraphicsApi.Make2DQuad(ref tex, col, vertices, ref index);
if (index >= vertices.Length)
{
DrawBackgroundVertices(ref index, atlasIndex, ref bound);
}
drawnY += 64;
}
DrawBackgroundVertices(ref index, atlasIndex, ref bound);
}
public static void Vertical(FastBitmap bmp, Rectangle rect,
PackedCol a, PackedCol b)
{
int x, y, width, height;
if (!Drawer2DExt.ClampCoords(bmp, rect, out x, out y,
out width, out height))
{
return;
}
PackedCol c = a;
for (int yy = 0; yy < height; yy++)
{
int * row = bmp.GetRowPtr(y + yy);
float t = (float)yy / (height - 1); // so last row has b as its colour
c.R = (byte)Utils.Lerp(a.R, b.R, t);
c.G = (byte)Utils.Lerp(a.G, b.G, t);
c.B = (byte)Utils.Lerp(a.B, b.B, t);
int pixel = c.ToArgb();
for (int xx = 0; xx < width; xx++)
{
row[x + xx] = pixel;
}
}
}
public void Render(double delta, VertexP3fC4b[] vertices, VertexP3fC4b[] lineVertices,
ref int index, ref int lineIndex)
{
float offset = MinDist < 32 * 32 ? 1 / 32f : 1 / 16f;
Vector3 offsetV = new Vector3(offset, offset, offset);
Vector3 p1 = Min - offsetV, p2 = Max + offsetV;
PackedCol col = Colour;
HorQuad(vertices, ref index, col, p1.X, p1.Z, p2.X, p2.Z, p1.Y); // bottom
HorQuad(vertices, ref index, col, p1.X, p1.Z, p2.X, p2.Z, p2.Y); // top
VerQuad(vertices, ref index, col, p1.X, p1.Y, p1.Z, p2.X, p2.Y, p1.Z); // sides
VerQuad(vertices, ref index, col, p1.X, p1.Y, p2.Z, p2.X, p2.Y, p2.Z);
VerQuad(vertices, ref index, col, p1.X, p1.Y, p1.Z, p1.X, p2.Y, p2.Z);
VerQuad(vertices, ref index, col, p2.X, p1.Y, p1.Z, p2.X, p2.Y, p2.Z);
col = new PackedCol((byte)~Colour.R, (byte)~Colour.G, (byte)~Colour.B);
// bottom face
Line(lineVertices, ref lineIndex, p1.X, p1.Y, p1.Z, p2.X, p1.Y, p1.Z, col);
Line(lineVertices, ref lineIndex, p2.X, p1.Y, p1.Z, p2.X, p1.Y, p2.Z, col);
Line(lineVertices, ref lineIndex, p2.X, p1.Y, p2.Z, p1.X, p1.Y, p2.Z, col);
Line(lineVertices, ref lineIndex, p1.X, p1.Y, p2.Z, p1.X, p1.Y, p1.Z, col);
// top face
Line(lineVertices, ref lineIndex, p1.X, p2.Y, p1.Z, p2.X, p2.Y, p1.Z, col);
Line(lineVertices, ref lineIndex, p2.X, p2.Y, p1.Z, p2.X, p2.Y, p2.Z, col);
Line(lineVertices, ref lineIndex, p2.X, p2.Y, p2.Z, p1.X, p2.Y, p2.Z, col);
Line(lineVertices, ref lineIndex, p1.X, p2.Y, p2.Z, p1.X, p2.Y, p1.Z, col);
// side faces
Line(lineVertices, ref lineIndex, p1.X, p1.Y, p1.Z, p1.X, p2.Y, p1.Z, col);
Line(lineVertices, ref lineIndex, p2.X, p1.Y, p1.Z, p2.X, p2.Y, p1.Z, col);
Line(lineVertices, ref lineIndex, p2.X, p1.Y, p2.Z, p2.X, p2.Y, p2.Z, col);
Line(lineVertices, ref lineIndex, p1.X, p1.Y, p2.Z, p1.X, p2.Y, p2.Z, col);
}
void HandleEnvColours()
{
byte variable = reader.ReadUInt8();
ushort r = reader.ReadUInt16();
ushort g = reader.ReadUInt16();
ushort b = reader.ReadUInt16();
bool invalid = r > 255 || g > 255 || b > 255;
PackedCol col = new PackedCol(r, g, b);
if (variable == 0)
{
game.World.Env.SetSkyCol(invalid ? WorldEnv.DefaultSkyCol : col);
}
else if (variable == 1)
{
game.World.Env.SetCloudsCol(invalid ? WorldEnv.DefaultCloudsCol : col);
}
else if (variable == 2)
{
game.World.Env.SetFogCol(invalid ? WorldEnv.DefaultFogCol : col);
}
else if (variable == 3)
{
game.World.Env.SetShadowCol(invalid ? WorldEnv.DefaultShadowlight : col);
}
else if (variable == 4)
{
game.World.Env.SetSunCol(invalid ? WorldEnv.DefaultSunlight : col);
}
}
void DrawZ(int z, int x1, int x2, int y1, int y2, int axisSize,
PackedCol col, VertexP3fT2fC4b[] vertices, ref int i)
{
int endX = x2, endY = y2, startY = y1;
VertexP3fT2fC4b v;
v.Z = z; v.Col = col;
for (; x1 < endX; x1 += axisSize)
{
x2 = x1 + axisSize;
if (x2 > endX)
{
x2 = endX;
}
y1 = startY;
for (; y1 < endY; y1 += axisSize)
{
y2 = y1 + axisSize;
if (y2 > endY)
{
y2 = endY;
}
float u2 = x2 - x1, v2 = y2 - y1;
v.X = x1; v.Y = y1; v.U = 0f; v.V = v2; vertices[i++] = v;
v.Y = y2; v.V = 0f; vertices[i++] = v;
v.X = x2; v.U = u2; vertices[i++] = v;
v.Y = y1; v.V = v2; vertices[i++] = v;
}
}
}
static void DrawCoords(VertexP3fT2fC4b[] verts, ref int index, ShadowData data,
float x1, float z1, float x2, float z2)
{
Vector3 cen = entity.Position;
if (lequal(x2, x1) || lequal(z2, z1))
{
return;
}
float u1 = (x1 - cen.X) * uvScale + 0.5f;
float v1 = (z1 - cen.Z) * uvScale + 0.5f;
float u2 = (x2 - cen.X) * uvScale + 0.5f;
float v2 = (z2 - cen.Z) * uvScale + 0.5f;
if (u2 <= 0 || v2 <= 0 || u1 >= 1 || v1 >= 1)
{
return;
}
x1 = Math.Max(x1, cen.X - radius); u1 = u1 >= 0 ? u1 : 0;
z1 = Math.Max(z1, cen.Z - radius); v1 = v1 >= 0 ? v1 : 0;
x2 = Math.Min(x2, cen.X + radius); u2 = u2 <= 1 ? u2 : 1;
z2 = Math.Min(z2, cen.Z + radius); v2 = v2 <= 1 ? v2 : 1;
PackedCol col = new PackedCol(c, c, c, data.A);
VertexP3fT2fC4b v; v.Y = data.Y; v.Col = col;
v.X = x1; v.Z = z1; v.U = u1; v.V = v1; verts[index++] = v;
v.X = x2; v.U = u2; verts[index++] = v;
v.Z = z2; v.V = v2; verts[index++] = v;
v.X = x1; v.U = u1; verts[index++] = v;
}
void DrawSkyY(int x1, int z1, int x2, int z2, int y, int axisSize,
PackedCol col, VertexP3fC4b[] vertices)
{
int endX = x2, endZ = z2, startZ = z1;
int i = 0;
VertexP3fC4b v;
v.Y = y; v.Col = col;
for (; x1 < endX; x1 += axisSize)
{
x2 = x1 + axisSize;
if (x2 > endX)
{
x2 = endX;
}
z1 = startZ;
for (; z1 < endZ; z1 += axisSize)
{
z2 = z1 + axisSize;
if (z2 > endZ)
{
z2 = endZ;
}
v.X = x1; v.Z = z1; vertices[i++] = v;
v.Z = z2; vertices[i++] = v;
v.X = x2; vertices[i++] = v;
v.Z = z1; vertices[i++] = v;
}
}
}
unsafe void WriteBlockDefinitionCompound(byte id)
{
nbt.Write(NbtTagType.Compound, "Block" + id);
bool sprite = BlockInfo.Draw[id] == DrawType.Sprite;
nbt.Write(NbtTagType.Int8, "ID");
nbt.WriteUInt8(id);
nbt.Write(NbtTagType.String, "Name");
nbt.Write(BlockInfo.Name[id]);
nbt.Write(NbtTagType.Int8, "CollideType");
nbt.WriteUInt8((byte)BlockInfo.Collide[id]);
float speed = BlockInfo.SpeedMultiplier[id];
nbt.Write(NbtTagType.Real32, "Speed");
nbt.WriteInt32(*((int *)&speed));
nbt.Write(NbtTagType.Int8Array, "Textures");
nbt.WriteInt32(6);
nbt.WriteUInt8(BlockInfo.GetTextureLoc(id, Side.Top));
nbt.WriteUInt8(BlockInfo.GetTextureLoc(id, Side.Bottom));
nbt.WriteUInt8(BlockInfo.GetTextureLoc(id, Side.Left));
nbt.WriteUInt8(BlockInfo.GetTextureLoc(id, Side.Right));
nbt.WriteUInt8(BlockInfo.GetTextureLoc(id, Side.Front));
nbt.WriteUInt8(BlockInfo.GetTextureLoc(id, Side.Back));
nbt.Write(NbtTagType.Int8, "TransmitsLight");
nbt.WriteUInt8(BlockInfo.BlocksLight[id] ? 0 : 1);
nbt.Write(NbtTagType.Int8, "WalkSound");
nbt.WriteUInt8(BlockInfo.DigSounds[id]);
nbt.Write(NbtTagType.Int8, "FullBright");
nbt.WriteUInt8(BlockInfo.FullBright[id] ? 1 : 0);
nbt.Write(NbtTagType.Int8, "Shape");
int shape = sprite ? 0 : (int)(BlockInfo.MaxBB[id].Y * 16);
nbt.WriteUInt8(shape);
nbt.Write(NbtTagType.Int8, "BlockDraw");
byte draw = sprite ? BlockInfo.SpriteOffset[id] : BlockInfo.Draw[id];
nbt.WriteUInt8(draw);
PackedCol col = BlockInfo.FogCol[id];
nbt.Write(NbtTagType.Int8Array, "Fog");
nbt.WriteInt32(4);
byte fog = (byte)(128 * BlockInfo.FogDensity[id] - 1);
nbt.WriteUInt8(BlockInfo.FogDensity[id] == 0 ? (byte)0 : fog);
nbt.WriteUInt8(col.R); nbt.WriteUInt8(col.G); nbt.WriteUInt8(col.B);
Vector3 min = BlockInfo.MinBB[id], max = BlockInfo.MaxBB[id];
nbt.Write(NbtTagType.Int8Array, "Coords");
nbt.WriteInt32(6);
nbt.WriteUInt8((byte)(min.X * 16)); nbt.WriteUInt8((byte)(min.Y * 16));
nbt.WriteUInt8((byte)(min.Z * 16)); nbt.WriteUInt8((byte)(max.X * 16));
nbt.WriteUInt8((byte)(max.Y * 16)); nbt.WriteUInt8((byte)(max.Z * 16));
nbt.Write(NbtTagType.End);
}
void DrawY(int x1, int z1, int x2, int z2, float y, int axisSize,
PackedCol col, float offset, float yOffset, VertexP3fT2fC4b[] vertices, ref int i)
{
int endX = x2, endZ = z2, startZ = z1;
VertexP3fT2fC4b v;
v.Y = y + yOffset; v.Col = col;
for (; x1 < endX; x1 += axisSize)
{
x2 = x1 + axisSize;
if (x2 > endX)
{
x2 = endX;
}
z1 = startZ;
for (; z1 < endZ; z1 += axisSize)
{
z2 = z1 + axisSize;
if (z2 > endZ)
{
z2 = endZ;
}
float u2 = x2 - x1, v2 = z2 - z1;
v.X = x1 + offset; v.Z = z1 + offset; v.U = 0f; v.V = 0f; vertices[i++] = v;
v.Z = z2 + offset; v.V = v2; vertices[i++] = v;
v.X = x2 + offset; v.U = u2; vertices[i++] = v;
v.Z = z1 + offset; v.V = 0f; vertices[i++] = v;
}
}
}
void UpdateFogNormal(float fogDensity, PackedCol fogCol)
{
IGraphicsApi gfx = game.Graphics;
if (fogDensity != 0)
{
gfx.SetFogMode(Fog.Exp);
gfx.SetFogDensity(fogDensity);
}
else if (game.World.Env.ExpFog)
{
gfx.SetFogMode(Fog.Exp);
// f = 1-z/end f = e^(-dz)
// solve for f = 0.01 gives:
// e^(-dz)=0.01 --> -dz=ln(0.01)
// 0.99=z/end --> z=end*0.99
// therefore
// d = -ln(0.01)/(end*0.99)
const double log001 = -4.60517018598809;
double density = -log001 / (game.ViewDistance * 0.99);
gfx.SetFogDensity((float)density);
}
else
{
gfx.SetFogMode(Fog.Linear);
gfx.SetFogEnd(game.ViewDistance);
}
gfx.SetFogCol(fogCol);
}
public override void Render(double delta)
{
IGraphicsApi gfx = game.Graphics;
int x = X, width = Width;
gfx.Draw2DQuad(x, Y, width, Height, scrollBackCol);
int y, height;
GetScrollbarCoords(out y, out height);
x += scrollBorder; width -= scrollBorder * 2; y += Y;
bool hovered = Mouse.Y >= y && Mouse.Y < (y + height) &&
Mouse.X >= x && Mouse.X < (x + width);
PackedCol barCol = hovered ? scrollHoverCol : scrollBarCol;
gfx.Draw2DQuad(x, y, width, height, barCol);
if (height < 20)
{
return;
}
x += nubsWidth; width -= nubsWidth * 2; y += (height / 2);
gfx.Draw2DQuad(x, y - 1 - 4, width, scrollBorder, scrollBackCol);
gfx.Draw2DQuad(x, y - 1, width, scrollBorder, scrollBackCol);
gfx.Draw2DQuad(x, y - 1 + 4, width, scrollBorder, scrollBackCol);
}
void DrawClassic(IDrawer2D drawer)
{
PackedCol highlightCol = Active ? new PackedCol(189, 198, 255) : new PackedCol(168, 168, 168);
drawer.Clear(highlightCol, X + border * 2, Y + border, Width - border * 4, border);
drawer.Clear(highlightCol, X + border, Y + border * 2, border, Height - border * 4);
}
void HandleMakeSelection()
{
byte selectionId = reader.ReadUInt8();
string label = reader.ReadString();
Vector3I p1;
p1.X = reader.ReadInt16();
p1.Y = reader.ReadInt16();
p1.Z = reader.ReadInt16();
Vector3I p2;
p2.X = reader.ReadInt16();
p2.Y = reader.ReadInt16();
p2.Z = reader.ReadInt16();
byte r = (byte)reader.ReadUInt16();
byte g = (byte)reader.ReadUInt16();
byte b = (byte)reader.ReadUInt16();
byte a = (byte)reader.ReadUInt16();
PackedCol col = new PackedCol(r, g, b, a);
game.SelectionManager.AddSelection(selectionId, p1, p2, col);
}
void DrawX(int x, int z1, int z2, int y1, int y2, int axisSize,
PackedCol col, VertexP3fT2fC4b[] vertices, ref int i)
{
int endZ = z2, endY = y2, startY = y1;
VertexP3fT2fC4b v;
v.X = x; v.Col = col;
for (; z1 < endZ; z1 += axisSize)
{
z2 = z1 + axisSize;
if (z2 > endZ)
{
z2 = endZ;
}
y1 = startY;
for (; y1 < endY; y1 += axisSize)
{
y2 = y1 + axisSize;
if (y2 > endY)
{
y2 = endY;
}
float u2 = z2 - z1, v2 = y2 - y1;
v.Y = y1; v.Z = z1; v.U = 0f; v.V = v2; vertices[i++] = v;
v.Y = y2; v.V = 0f; vertices[i++] = v;
v.Z = z2; v.U = u2; vertices[i++] = v;
v.Y = y1; v.V = v2; vertices[i++] = v;
}
}
}
static void CheckShadowTexture(IGraphicsApi gfx)
{
if (shadowTex != 0)
{
return;
}
const int size = 128, half = size / 2;
using (Bitmap bmp = Platform.CreateBmp(size, size))
using (FastBitmap fastBmp = new FastBitmap(bmp, true, false))
{
int inPix = new PackedCol(0, 0, 0, 200).ToArgb();
int outPix = new PackedCol(0, 0, 0, 0).ToArgb();
for (int y = 0; y < fastBmp.Height; y++)
{
int *row = fastBmp.GetRowPtr(y);
for (int x = 0; x < fastBmp.Width; x++)
{
double dist = (half - (x + 0.5)) * (half - (x + 0.5)) +
(half - (y + 0.5)) * (half - (y + 0.5));
row[x] = dist < half * half ? inPix : outPix;
}
}
shadowTex = gfx.CreateTexture(fastBmp, false, false);
}
}
public static void Noise(FastBitmap bmp, Rectangle rect,
PackedCol col, int variation)
{
int x, y, width, height;
if (!Drawer2DExt.ClampCoords(bmp, rect, out x, out y,
out width, out height))
{
return;
}
const int alpha = 255 << 24;
for (int yy = 0; yy < height; yy++)
{
int *row = bmp.GetRowPtr(y + yy);
for (int xx = 0; xx < width; xx++)
{
int n = (x + xx) + (y + yy) * 57;
n = (n << 13) ^ n;
float noise = 1f - ((n * (n * n * 15731 + 789221) + 1376312589) & 0x7fffffff) / 1073741824f;
int r = col.R + (int)(noise * variation);
r = r < 0 ? 0 : (r > 255 ? 255 : r);
int g = col.G + (int)(noise * variation);
g = g < 0 ? 0 : (g > 255 ? 255 : g);
int b = col.B + (int)(noise * variation);
b = b < 0 ? 0 : (b > 255 ? 255 : b);
row[x + xx] = alpha | (r << 16) | (g << 8) | b;
}
}
}
public void AddSelection(byte id, Vector3I p1, Vector3I p2, PackedCol col)
{
RemoveSelection(id);
SelectionBox selection = new SelectionBox(p1, p2, col);
selection.ID = id;
selections.Add(selection);
}
public static void ResetToDefault()
{
BackgroundCol = new PackedCol(153, 127, 172);
ButtonBorderCol = new PackedCol(97, 81, 110);
ButtonForeActiveCol = new PackedCol(189, 168, 206);
ButtonForeCol = new PackedCol(141, 114, 165);
ButtonHighlightCol = new PackedCol(162, 131, 186);
}
public virtual void Draw2DTexture(ref Texture tex, PackedCol col)
{
int index = 0;
Make2DQuad(ref tex, col, texVerts, ref index);
SetBatchFormat(VertexFormat.P3fT2fC4b);
UpdateDynamicVb_IndexedTris(texVb, texVerts, 4);
}
public override void ClearCol(PackedCol col)
{
if (col != lastClearCol)
{
GL.ClearColor(col.R / 255f, col.G / 255f, col.B / 255f, col.A / 255f);
lastClearCol = col;
}
}
static PackedCol Expand(PackedCol a, int amount)
{
int r = a.R + amount; Utils.Clamp(ref r, 0, 255);
int g = a.G + amount; Utils.Clamp(ref g, 0, 255);
int b = a.B + amount; Utils.Clamp(ref b, 0, 255);
return(new PackedCol(r, g, b));
}
static void Line(VertexP3fC4b[] vertices, ref int index, float x1, float y1, float z1,
float x2, float y2, float z2, PackedCol col)
{
VertexP3fC4b v; v.Col = col;
v.X = x1; v.Y = y1; v.Z = z1; vertices[index++] = v;
v.X = x2; v.Y = y2; v.Z = z2; vertices[index++] = v;
}
void DrawTopFace(int count)
{
int texId = BlockInfo.textures[curBlock * Side.Sides + Side.Top];
int i = texId >> Atlas1D.Shift;
float vOrigin = (texId & Atlas1D.Mask) * Atlas1D.invTileSize;
int offset = (lightFlags >> Side.Top) & 1;
float u1 = minBB.X, u2 = (count - 1) + maxBB.X * 15.99f / 16f;
float v1 = vOrigin + maxBB.Y * Atlas1D.invTileSize;
float v2 = vOrigin + minBB.Y * Atlas1D.invTileSize * 15.99f / 16f;
DrawInfo part = isTranslucent ? translucentParts[i] : normalParts[i];
PackedCol col = fullBright ? PackedCol.White : light.LightCol_YTop_Fast(X, (Y + 1) - offset, Z);
if (tinted)
{
col *= BlockInfo.FogCol[curBlock];
}
float y2_x1z1 = y2, y2_x1z2 = y2, y2_x2z1 = y2, y2_x2z2 = y2;
if (BlockInfo.Draw[curBlock] == DrawType2.SlopeDownXMax)
{
y2_x2z1 = y1; y2_x2z2 = y1;
if (!fullBright)
{
col = PackedCol.Scale(col, 0.8f);
}
}
else if (BlockInfo.Draw[curBlock] == DrawType2.SlopeDownXMin)
{
y2_x1z1 = y1; y2_x1z2 = y1;
if (!fullBright)
{
col = PackedCol.Scale(col, 0.8f);
}
}
else if (BlockInfo.Draw[curBlock] == DrawType2.SlopeDownZMin)
{
y2_x1z1 = y1; y2_x2z1 = y1;
if (!fullBright)
{
col = PackedCol.Scale(col, 0.9f);
}
}
else if (BlockInfo.Draw[curBlock] == DrawType2.SlopeDownZMax)
{
y2_x1z2 = y1; y2_x2z2 = y1;
if (!fullBright)
{
col = PackedCol.Scale(col, 0.9f);
}
}
vertices[part.vIndex[Side.Top]++] = new VertexP3fT2fC4b(x2 + (count - 1), y2_x2z1, z1, u2, v1, col);
vertices[part.vIndex[Side.Top]++] = new VertexP3fT2fC4b(x1, y2_x1z1, z1, u1, v1, col);
vertices[part.vIndex[Side.Top]++] = new VertexP3fT2fC4b(x1, y2_x1z2, z2, u1, v2, col);
vertices[part.vIndex[Side.Top]++] = new VertexP3fT2fC4b(x2 + (count - 1), y2_x2z2, z2, u2, v2, col);
}
void ResetLight()
{
Shadow = DefaultShadowlight;
PackedCol.GetShaded(Shadow, out ShadowXSide,
out ShadowZSide, out ShadowYBottom);
Sun = DefaultSunlight;
PackedCol.GetShaded(Sun, out SunXSide,
out SunZSide, out SunYBottom);
}
void DrawBorder(IDrawer2D drawer)
{
PackedCol backCol = Window.ClassicBackground ? PackedCol.Black : LauncherSkin.ButtonBorderCol;
drawer.Clear(backCol, X + border, Y, Width - border * 2, border);
drawer.Clear(backCol, X + border, Y + Height - border, Width - border * 2, border);
drawer.Clear(backCol, X, Y + border, border, Height - border * 2);
drawer.Clear(backCol, X + Width - border, Y + border, border, Height - border * 2);
}
void IGameComponent.Init(Game game)
{
this.game = game;
col = new PackedCol(0, 0, 0, 102);
ContextRecreated();
game.Graphics.ContextLost += ContextLost;
game.Graphics.ContextRecreated += ContextRecreated;
}
void MakeRGBTriplet(PackedCol defCol, bool force, int y)
{
MakeInput(GetCol(defCol.R, force), 55, false, 3, null)
.SetLocation(Anchor.Centre, Anchor.Centre, 30, y);
MakeInput(GetCol(defCol.G, force), 55, false, 3, null)
.SetLocation(Anchor.Centre, Anchor.Centre, 95, y);
MakeInput(GetCol(defCol.B, force), 55, false, 3, null)
.SetLocation(Anchor.Centre, Anchor.Centre, 160, y);
}
public override void SetFogCol(PackedCol col)
{
if (col != lastFogCol)
{
Vector4 colRGBA = new Vector4(col.R / 255f, col.G / 255f, col.B / 255f, col.A / 255f);
GL.Fog(All.FogColor, &colRGBA.X);
lastFogCol = col;
}
}
public void Render(Game game, float t, VertexP3fT2fC4b[] vertices, ref int index)
{
Vector3 pos = Vector3.Lerp(lastPos, nextPos, t);
Vector2 size; size.X = Size * 0.015625f; size.Y = size.X;
int x = Utils.Floor(pos.X), y = Utils.Floor(pos.Y), z = Utils.Floor(pos.Z);
PackedCol col = game.World.IsValidPos(x, y, z) ? game.Lighting.LightCol(x, y, z) : game.Lighting.Outside;
DoRender(ref game.Graphics.View, ref size, ref pos, ref rec, col, vertices, ref index);
}
void DrawNormal(IDrawer2D drawer)
{
if (Active)
{
return;
}
PackedCol lineCol = LauncherSkin.ButtonHighlightCol;
drawer.Clear(lineCol, X + border * 2, Y + border, Width - border * 4, border);
}
