public static void DrawArrowPointingAt(Vector3 mapTarget, bool offscreenOnly = false)
{
Vector3 vector = UI.UIToMapPosition((float)(UI.screenWidth / 2), (float)(UI.screenHeight / 2));
if ((vector - mapTarget).MagnitudeHorizontalSquared() < 81.0)
{
if (!offscreenOnly)
{
Vector3 position = mapTarget;
position.y = Altitudes.AltitudeFor(AltitudeLayer.MetaOverlays);
position.z -= 1.5f;
Graphics.DrawMesh(MeshPool.plane20, position, Quaternion.identity, GenDraw.ArrowMatWhite, 0);
}
}
else
{
Vector3 vector2 = (mapTarget - vector).normalized * 7f;
Vector3 position2 = vector + vector2;
position2.y = Altitudes.AltitudeFor(AltitudeLayer.MetaOverlays);
Quaternion rotation = Quaternion.LookRotation(vector2);
Graphics.DrawMesh(MeshPool.plane20, position2, rotation, GenDraw.ArrowMatWhite, 0);
}
}
public override void Regenerate()
{
if (!MatBases.SunShadow.shader.isSupported)
{
return;
}
SectionLayer_SunShadows.edificeGrid = base.Map.edificeGrid.InnerArray;
float y = Altitudes.AltitudeFor(AltitudeLayer.Shadows);
CellRect cellRect = new CellRect(this.section.botLeft.x, this.section.botLeft.z, 17, 17);
cellRect.ClipInsideMap(base.Map);
LayerSubMesh subMesh = base.GetSubMesh(MatBases.SunShadow);
subMesh.Clear(MeshParts.All);
subMesh.verts.Capacity = cellRect.Area * 2;
subMesh.tris.Capacity = cellRect.Area * 4;
subMesh.colors.Capacity = cellRect.Area * 2;
CellIndices cellIndices = base.Map.cellIndices;
for (int i = cellRect.minX; i <= cellRect.maxX; i++)
{
for (int j = cellRect.minZ; j <= cellRect.maxZ; j++)
{
Thing thing = SectionLayer_SunShadows.edificeGrid[cellIndices.CellToIndex(i, j)];
if (thing != null && thing.def.staticSunShadowHeight > 0f)
{
float staticSunShadowHeight = thing.def.staticSunShadowHeight;
Color32 item = new Color32(0, 0, 0, (byte)(255f * staticSunShadowHeight));
int count = subMesh.verts.Count;
subMesh.verts.Add(new Vector3((float)i, y, (float)j));
subMesh.verts.Add(new Vector3((float)i, y, (float)(j + 1)));
subMesh.verts.Add(new Vector3((float)(i + 1), y, (float)(j + 1)));
subMesh.verts.Add(new Vector3((float)(i + 1), y, (float)j));
subMesh.colors.Add(SectionLayer_SunShadows.LowVertexColor);
subMesh.colors.Add(SectionLayer_SunShadows.LowVertexColor);
subMesh.colors.Add(SectionLayer_SunShadows.LowVertexColor);
subMesh.colors.Add(SectionLayer_SunShadows.LowVertexColor);
int count2 = subMesh.verts.Count;
subMesh.tris.Add(count2 - 4);
subMesh.tris.Add(count2 - 3);
subMesh.tris.Add(count2 - 2);
subMesh.tris.Add(count2 - 4);
subMesh.tris.Add(count2 - 2);
subMesh.tris.Add(count2 - 1);
if (i > 0)
{
thing = SectionLayer_SunShadows.edificeGrid[cellIndices.CellToIndex(i - 1, j)];
if (thing == null || thing.def.staticSunShadowHeight < staticSunShadowHeight)
{
int count3 = subMesh.verts.Count;
subMesh.verts.Add(new Vector3((float)i, y, (float)j));
subMesh.verts.Add(new Vector3((float)i, y, (float)(j + 1)));
subMesh.colors.Add(item);
subMesh.colors.Add(item);
subMesh.tris.Add(count + 1);
subMesh.tris.Add(count);
subMesh.tris.Add(count3);
subMesh.tris.Add(count3);
subMesh.tris.Add(count3 + 1);
subMesh.tris.Add(count + 1);
}
}
if (i < base.Map.Size.x - 1)
{
thing = SectionLayer_SunShadows.edificeGrid[cellIndices.CellToIndex(i + 1, j)];
if (thing == null || thing.def.staticSunShadowHeight < staticSunShadowHeight)
{
int count4 = subMesh.verts.Count;
subMesh.verts.Add(new Vector3((float)(i + 1), y, (float)(j + 1)));
subMesh.verts.Add(new Vector3((float)(i + 1), y, (float)j));
subMesh.colors.Add(item);
subMesh.colors.Add(item);
subMesh.tris.Add(count + 2);
subMesh.tris.Add(count4);
subMesh.tris.Add(count4 + 1);
subMesh.tris.Add(count4 + 1);
subMesh.tris.Add(count + 3);
subMesh.tris.Add(count + 2);
}
}
if (j > 0)
{
thing = SectionLayer_SunShadows.edificeGrid[cellIndices.CellToIndex(i, j - 1)];
if (thing == null || thing.def.staticSunShadowHeight < staticSunShadowHeight)
{
int count5 = subMesh.verts.Count;
subMesh.verts.Add(new Vector3((float)i, y, (float)j));
subMesh.verts.Add(new Vector3((float)(i + 1), y, (float)j));
subMesh.colors.Add(item);
subMesh.colors.Add(item);
subMesh.tris.Add(count);
subMesh.tris.Add(count + 3);
subMesh.tris.Add(count5);
subMesh.tris.Add(count + 3);
subMesh.tris.Add(count5 + 1);
subMesh.tris.Add(count5);
}
}
}
}
}
if (subMesh.verts.Count > 0)
{
subMesh.FinalizeMesh(MeshParts.Verts | MeshParts.Tris | MeshParts.Colors);
float num = Mathf.Max(15f, 15f);
Vector3 size = subMesh.mesh.bounds.size;
size.x += 2f * num + 2f;
size.z += 2f * num + 2f;
subMesh.mesh.bounds = new Bounds(subMesh.mesh.bounds.center, size);
}
}
public override void Draw()
{
this.exactPosition.y = Altitudes.AltitudeFor(base.def.altitudeLayer);
base.Draw();
}
public override void Regenerate()
{
Building[] innerArray = base.Map.edificeGrid.InnerArray;
float y = Altitudes.AltitudeFor(AltitudeLayer.Shadows);
CellRect cellRect = new CellRect(base.section.botLeft.x, base.section.botLeft.z, 17, 17);
cellRect.ClipInsideMap(base.Map);
LayerSubMesh sm = base.GetSubMesh(MatBases.EdgeShadow);
sm.Clear(MeshParts.All);
sm.verts.Capacity = cellRect.Area * 4;
sm.colors.Capacity = cellRect.Area * 4;
sm.tris.Capacity = cellRect.Area * 8;
bool[] array = new bool[4];
bool[] array2 = new bool[4];
bool[] array3 = new bool[4];
float num = 0f;
float num2 = 0f;
CellIndices cellIndices = base.Map.cellIndices;
for (int i = cellRect.minX; i <= cellRect.maxX; i++)
{
for (int j = cellRect.minZ; j <= cellRect.maxZ; j++)
{
Thing thing = innerArray[cellIndices.CellToIndex(i, j)];
if (thing != null && thing.def.castEdgeShadows)
{
sm.verts.Add(new Vector3((float)i, y, (float)j));
sm.verts.Add(new Vector3((float)i, y, (float)(j + 1)));
sm.verts.Add(new Vector3((float)(i + 1), y, (float)(j + 1)));
sm.verts.Add(new Vector3((float)(i + 1), y, (float)j));
sm.colors.Add(SectionLayer_EdgeShadows.Shadowed);
sm.colors.Add(SectionLayer_EdgeShadows.Shadowed);
sm.colors.Add(SectionLayer_EdgeShadows.Shadowed);
sm.colors.Add(SectionLayer_EdgeShadows.Shadowed);
int count = sm.verts.Count;
sm.tris.Add(count - 4);
sm.tris.Add(count - 3);
sm.tris.Add(count - 2);
sm.tris.Add(count - 4);
sm.tris.Add(count - 2);
sm.tris.Add(count - 1);
}
else
{
array[0] = false;
array[1] = false;
array[2] = false;
array[3] = false;
array2[0] = false;
array2[1] = false;
array2[2] = false;
array2[3] = false;
array3[0] = false;
array3[1] = false;
array3[2] = false;
array3[3] = false;
IntVec3 a = new IntVec3(i, 0, j);
IntVec3[] cardinalDirectionsAround = GenAdj.CardinalDirectionsAround;
for (int k = 0; k < 4; k++)
{
IntVec3 c = a + cardinalDirectionsAround[k];
if (c.InBounds(base.Map))
{
thing = innerArray[cellIndices.CellToIndex(c)];
if (thing != null && thing.def.castEdgeShadows)
{
array2[k] = true;
array[(k + 3) % 4] = true;
array[k] = true;
}
}
}
IntVec3[] diagonalDirectionsAround = GenAdj.DiagonalDirectionsAround;
for (int l = 0; l < 4; l++)
{
if (!array[l])
{
IntVec3 c = a + diagonalDirectionsAround[l];
if (c.InBounds(base.Map))
{
thing = innerArray[cellIndices.CellToIndex(c)];
if (thing != null && thing.def.castEdgeShadows)
{
array[l] = true;
array3[l] = true;
}
}
}
}
Action <int> action = delegate(int idx)
{
sm.tris.Add(sm.verts.Count - 2);
sm.tris.Add(idx);
sm.tris.Add(sm.verts.Count - 1);
sm.tris.Add(sm.verts.Count - 1);
sm.tris.Add(idx);
sm.tris.Add(idx + 1);
};
Action action2 = delegate
{
sm.colors.Add(SectionLayer_EdgeShadows.Shadowed);
sm.colors.Add(SectionLayer_EdgeShadows.Lit);
sm.colors.Add(SectionLayer_EdgeShadows.Lit);
sm.tris.Add(sm.verts.Count - 3);
sm.tris.Add(sm.verts.Count - 2);
sm.tris.Add(sm.verts.Count - 1);
};
int count2 = sm.verts.Count;
if (array[0])
{
if (array2[0] || array2[1])
{
num = (num2 = 0f);
if (array2[0])
{
num2 = 0.45f;
}
if (array2[1])
{
num = 0.45f;
}
sm.verts.Add(new Vector3((float)i, y, (float)j));
sm.colors.Add(SectionLayer_EdgeShadows.Shadowed);
sm.verts.Add(new Vector3((float)i + num, y, (float)j + num2));
sm.colors.Add(SectionLayer_EdgeShadows.Lit);
if (array[1] && !array3[1])
{
action(sm.verts.Count);
}
}
else
{
sm.verts.Add(new Vector3((float)i, y, (float)j));
sm.verts.Add(new Vector3((float)i, y, (float)((float)j + 0.44999998807907104)));
sm.verts.Add(new Vector3((float)((float)i + 0.44999998807907104), y, (float)j));
action2();
}
}
if (array[1])
{
if (array2[1] || array2[2])
{
num = (num2 = 0f);
if (array2[1])
{
num = 0.45f;
}
if (array2[2])
{
num2 = -0.45f;
}
sm.verts.Add(new Vector3((float)i, y, (float)(j + 1)));
sm.colors.Add(SectionLayer_EdgeShadows.Shadowed);
sm.verts.Add(new Vector3((float)i + num, y, (float)(j + 1) + num2));
sm.colors.Add(SectionLayer_EdgeShadows.Lit);
if (array[2] && !array3[2])
{
action(sm.verts.Count);
}
}
else
{
sm.verts.Add(new Vector3((float)i, y, (float)(j + 1)));
sm.verts.Add(new Vector3((float)((float)i + 0.44999998807907104), y, (float)(j + 1)));
sm.verts.Add(new Vector3((float)i, y, (float)((float)(j + 1) - 0.44999998807907104)));
action2();
}
}
if (array[2])
{
if (array2[2] || array2[3])
{
num = (num2 = 0f);
if (array2[2])
{
num2 = -0.45f;
}
if (array2[3])
{
num = -0.45f;
}
sm.verts.Add(new Vector3((float)(i + 1), y, (float)(j + 1)));
sm.colors.Add(SectionLayer_EdgeShadows.Shadowed);
sm.verts.Add(new Vector3((float)(i + 1) + num, y, (float)(j + 1) + num2));
sm.colors.Add(SectionLayer_EdgeShadows.Lit);
if (array[3] && !array3[3])
{
action(sm.verts.Count);
}
}
else
{
sm.verts.Add(new Vector3((float)(i + 1), y, (float)(j + 1)));
sm.verts.Add(new Vector3((float)(i + 1), y, (float)((float)(j + 1) - 0.44999998807907104)));
sm.verts.Add(new Vector3((float)((float)(i + 1) - 0.44999998807907104), y, (float)(j + 1)));
action2();
}
}
if (array[3])
{
if (array2[3] || array2[0])
{
num = (num2 = 0f);
if (array2[3])
{
num = -0.45f;
}
if (array2[0])
{
num2 = 0.45f;
}
sm.verts.Add(new Vector3((float)(i + 1), y, (float)j));
sm.colors.Add(SectionLayer_EdgeShadows.Shadowed);
sm.verts.Add(new Vector3((float)(i + 1) + num, y, (float)j + num2));
sm.colors.Add(SectionLayer_EdgeShadows.Lit);
if (array[0] && !array3[0])
{
action(count2);
}
}
else
{
sm.verts.Add(new Vector3((float)(i + 1), y, (float)j));
sm.verts.Add(new Vector3((float)((float)(i + 1) - 0.44999998807907104), y, (float)j));
sm.verts.Add(new Vector3((float)(i + 1), y, (float)((float)j + 0.44999998807907104)));
action2();
}
}
}
}
}
if (sm.verts.Count > 0)
{
sm.FinalizeMesh(MeshParts.Verts | MeshParts.Tris | MeshParts.Colors);
}
}
public void RenderPawnAt(Vector3 drawLoc, RotDrawMode bodyDrawType, bool headStump)
{
if (!this.graphics.AllResolved)
{
this.graphics.ResolveAllGraphics();
}
if (this.pawn.GetPosture() == PawnPosture.Standing)
{
this.RenderPawnInternal(drawLoc, Quaternion.identity, true, bodyDrawType, headStump);
if (this.pawn.carryTracker != null)
{
Thing carriedThing = this.pawn.carryTracker.CarriedThing;
if (carriedThing != null)
{
Vector3 vector = drawLoc;
bool flag = false;
bool flip = false;
if (this.pawn.CurJob == null || !this.pawn.jobs.curDriver.ModifyCarriedThingDrawPos(ref vector, ref flag, ref flip))
{
if (carriedThing is Pawn || carriedThing is Corpse)
{
vector += new Vector3(0.44f, 0f, 0f);
}
else
{
vector += new Vector3(0.18f, 0f, 0.05f);
}
}
if (flag)
{
vector.y -= 0.0390625f;
}
else
{
vector.y += 0.0390625f;
}
carriedThing.DrawAt(vector, flip);
}
}
if (this.pawn.def.race.specialShadowData != null)
{
if (this.shadowGraphic == null)
{
this.shadowGraphic = new Graphic_Shadow(this.pawn.def.race.specialShadowData);
}
this.shadowGraphic.Draw(drawLoc, Rot4.North, this.pawn, 0f);
}
if (this.graphics.nakedGraphic != null && this.graphics.nakedGraphic.ShadowGraphic != null)
{
this.graphics.nakedGraphic.ShadowGraphic.Draw(drawLoc, Rot4.North, this.pawn, 0f);
}
}
else
{
Rot4 rot = this.LayingFacing();
Building_Bed building_Bed = this.pawn.CurrentBed();
bool renderBody;
Quaternion quat;
Vector3 rootLoc;
if (building_Bed != null && this.pawn.RaceProps.Humanlike)
{
renderBody = building_Bed.def.building.bed_showSleeperBody;
Rot4 rotation = building_Bed.Rotation;
rotation.AsInt += 2;
quat = rotation.AsQuat;
AltitudeLayer altLayer = (AltitudeLayer)Mathf.Max((int)building_Bed.def.altitudeLayer, 15);
Vector3 vector2 = this.pawn.Position.ToVector3ShiftedWithAltitude(altLayer);
Vector3 vector3 = vector2;
vector3.y += 0.02734375f;
float d = -this.BaseHeadOffsetAt(Rot4.South).z;
Vector3 a = rotation.FacingCell.ToVector3();
rootLoc = vector2 + a * d;
rootLoc.y += 0.0078125f;
}
else
{
renderBody = true;
rootLoc = drawLoc;
if (!this.pawn.Dead && this.pawn.CarriedBy == null)
{
rootLoc.y = Altitudes.AltitudeFor(AltitudeLayer.LayingPawn) + 0.0078125f;
}
if (this.pawn.Downed || this.pawn.Dead)
{
quat = Quaternion.AngleAxis(this.wiggler.downedAngle, Vector3.up);
}
else if (this.pawn.RaceProps.Humanlike)
{
quat = rot.AsQuat;
}
else
{
Rot4 rot2 = Rot4.West;
int num = this.pawn.thingIDNumber % 2;
if (num != 0)
{
if (num == 1)
{
rot2 = Rot4.East;
}
}
else
{
rot2 = Rot4.West;
}
quat = rot2.AsQuat;
}
}
this.RenderPawnInternal(rootLoc, quat, renderBody, rot, rot, bodyDrawType, false, headStump);
}
if (this.pawn.Spawned && !this.pawn.Dead)
{
this.pawn.stances.StanceTrackerDraw();
this.pawn.pather.PatherDraw();
}
this.DrawDebug();
}
public void RegenerateMesh()
{
for (int i = 0; i < this.meshes.Count; i++)
{
this.meshes[i].Clear();
}
int num = 0;
int num2 = 0;
if (this.meshes.Count < num + 1)
{
Mesh mesh = new Mesh();
mesh.name = "CellBoolDrawer";
this.meshes.Add(mesh);
}
Mesh mesh2 = this.meshes[num];
CellRect cellRect = new CellRect(0, 0, this.mapSizeX, this.mapSizeZ);
float y = Altitudes.AltitudeFor(AltitudeLayer.MapDataOverlay);
bool careAboutVertexColors = false;
for (int j = cellRect.minX; j <= cellRect.maxX; j++)
{
for (int k = cellRect.minZ; k <= cellRect.maxZ; k++)
{
int index = CellIndicesUtility.CellToIndex(j, k, this.mapSizeX);
if (this.giver.GetCellBool(index))
{
CellBoolDrawer.verts.Add(new Vector3((float)j, y, (float)k));
CellBoolDrawer.verts.Add(new Vector3((float)j, y, (float)(k + 1)));
CellBoolDrawer.verts.Add(new Vector3((float)(j + 1), y, (float)(k + 1)));
CellBoolDrawer.verts.Add(new Vector3((float)(j + 1), y, (float)k));
Color cellExtraColor = this.giver.GetCellExtraColor(index);
CellBoolDrawer.colors.Add(cellExtraColor);
CellBoolDrawer.colors.Add(cellExtraColor);
CellBoolDrawer.colors.Add(cellExtraColor);
CellBoolDrawer.colors.Add(cellExtraColor);
if (cellExtraColor != Color.white)
{
careAboutVertexColors = true;
}
int count = CellBoolDrawer.verts.Count;
CellBoolDrawer.tris.Add(count - 4);
CellBoolDrawer.tris.Add(count - 3);
CellBoolDrawer.tris.Add(count - 2);
CellBoolDrawer.tris.Add(count - 4);
CellBoolDrawer.tris.Add(count - 2);
CellBoolDrawer.tris.Add(count - 1);
num2++;
if (num2 >= 16383)
{
this.FinalizeWorkingDataIntoMesh(mesh2);
num++;
if (this.meshes.Count < num + 1)
{
Mesh mesh3 = new Mesh();
mesh3.name = "CellBoolDrawer";
this.meshes.Add(mesh3);
}
mesh2 = this.meshes[num];
num2 = 0;
}
}
}
}
this.FinalizeWorkingDataIntoMesh(mesh2);
this.CreateMaterialIfNeeded(careAboutVertexColors);
this.dirty = false;
}
public Vector3 ToVector3ShiftedWithAltitude(AltitudeLayer AltLayer)
{
return(this.ToVector3ShiftedWithAltitude(Altitudes.AltitudeFor(AltLayer)));
}
public override void Regenerate()
{
if (MatBases.SunShadow.shader.isSupported)
{
LayerSubMesh subMesh = base.GetSubMesh(MatBases.IndoorMask);
subMesh.Clear(MeshParts.All);
Building[] innerArray = base.Map.edificeGrid.InnerArray;
CellRect cellRect = new CellRect(base.section.botLeft.x, base.section.botLeft.z, 17, 17);
cellRect.ClipInsideMap(base.Map);
subMesh.verts.Capacity = cellRect.Area * 2;
subMesh.tris.Capacity = cellRect.Area * 4;
float y = Altitudes.AltitudeFor(AltitudeLayer.MetaOverlays);
CellIndices cellIndices = base.Map.cellIndices;
for (int i = cellRect.minX; i <= cellRect.maxX; i++)
{
for (int j = cellRect.minZ; j <= cellRect.maxZ; j++)
{
IntVec3 intVec = new IntVec3(i, 0, j);
if (!this.HideRainPrimary(intVec))
{
bool flag = intVec.Roofed(base.Map);
bool flag2 = false;
if (flag)
{
for (int k = 0; k < 8; k++)
{
IntVec3 c = intVec + GenAdj.AdjacentCells[k];
if (c.InBounds(base.Map) && this.HideRainPrimary(c))
{
flag2 = true;
break;
}
}
}
if (flag && flag2)
{
goto IL_016e;
}
continue;
}
goto IL_016e;
IL_016e:
Thing thing = innerArray[cellIndices.CellToIndex(i, j)];
float num = (float)((thing == null || (thing.def.passability != Traversability.Impassable && !thing.def.IsDoor)) ? 0.15999999642372131 : 0.0);
subMesh.verts.Add(new Vector3((float)i - num, y, (float)j - num));
subMesh.verts.Add(new Vector3((float)i - num, y, (float)(j + 1) + num));
subMesh.verts.Add(new Vector3((float)(i + 1) + num, y, (float)(j + 1) + num));
subMesh.verts.Add(new Vector3((float)(i + 1) + num, y, (float)j - num));
int count = subMesh.verts.Count;
subMesh.tris.Add(count - 4);
subMesh.tris.Add(count - 3);
subMesh.tris.Add(count - 2);
subMesh.tris.Add(count - 4);
subMesh.tris.Add(count - 2);
subMesh.tris.Add(count - 1);
}
}
if (subMesh.verts.Count > 0)
{
subMesh.FinalizeMesh(MeshParts.Verts | MeshParts.Tris);
}
}
}