public static Vector2 ForPawn(Pawn pawn)
{
if (pawn.RaceProps.Humanlike)
{
PawnRenderer renderer = pawn.Drawer.renderer;
PawnGraphicSet graphicSet = renderer.graphics;
if (!graphicSet.AllResolved)
{
graphicSet.ResolveAllGraphics();
}
if (pawn.IsDessicated() && graphicSet.dessicatedGraphic != null)
{
return(BoundMap(
graphicSet.dessicatedGraphic,
GraphicType.Pawn,
graphicSet.desiccatedHeadGraphic,
new Vector2(renderer.BaseHeadOffsetAt(Rot4.South).x,
renderer.BaseHeadOffsetAt(Rot4.East).z)));
}
return(BoundMap(
graphicSet.nakedGraphic,
GraphicType.Pawn,
graphicSet.headGraphic,
new Vector2(renderer.BaseHeadOffsetAt(Rot4.South).x,
renderer.BaseHeadOffsetAt(Rot4.East).z)));
}
else
{
PawnKindLifeStage lifeStage = pawn.ageTracker.CurKindLifeStage;
GraphicData graphicData;
if (pawn.IsDessicated() && lifeStage.dessicatedBodyGraphicData != null)
{
graphicData = lifeStage.dessicatedBodyGraphicData;
}
else if (pawn.gender == Gender.Female && lifeStage.femaleGraphicData != null)
{
graphicData = lifeStage.femaleGraphicData;
}
else
{
graphicData = lifeStage.bodyGraphicData;
}
return(Vector2.Scale(BoundMap(graphicData.Graphic, GraphicType.Pawn), graphicData.drawSize));
}
}
public static void Postfix(PawnRenderer __instance, Pawn ___pawn, Vector3 drawLoc)
{
Building_Bed softWarmBed = ___pawn.CurrentBed();
CompMakeableBed bedComp = softWarmBed.TryGetComp <CompMakeableBed>();
if (___pawn.RaceProps.Humanlike && bedComp != null)//___pawn.CurrentBed() is Building_SoftWarmBed)
{
if (!bedComp.Loaded)
{
// Thanks to @Zamu & @Mehni!
var rotDrawMode = (RotDrawMode)AccessTools.Property(typeof(PawnRenderer), "CurRotDrawMode").GetGetMethod(true).Invoke(__instance, new object[0]);
MethodInfo layingFacing = AccessTools.Method(type: typeof(PawnRenderer), name: "LayingFacing");
Rot4 rot = (Rot4)layingFacing.Invoke(__instance, new object[0]);
float angle;
Vector3 rootLoc;
Rot4 rotation = softWarmBed.Rotation;
rotation.AsInt += 2;
angle = rotation.AsAngle;
AltitudeLayer altLayer = (AltitudeLayer)Mathf.Max((int)softWarmBed.def.altitudeLayer, 15);
Vector3 vector2 = ___pawn.Position.ToVector3ShiftedWithAltitude(altLayer);
Vector3 vector3 = vector2;
vector3.y += 0.02734375f;
float d = -__instance.BaseHeadOffsetAt(Rot4.South).z;
Vector3 a = rotation.FacingCell.ToVector3();
rootLoc = vector2 + a * d;
rootLoc.y += 0.0078125f;
MethodInfo renderPawnInternal = AccessTools.Method(type: typeof(PawnRenderer), name: "RenderPawnInternal", parameters: new[] { typeof(Vector3), typeof(float), typeof(bool), typeof(Rot4), typeof(Rot4), typeof(RotDrawMode), typeof(bool), typeof(bool), typeof(bool) });
renderPawnInternal.Invoke(__instance, new object[] { rootLoc, angle, true, rot, rot, rotDrawMode, false, false, false });
}
}
}
private static void Postfix(PawnRenderer __instance, ref Vector3 rootLoc, ref float angle,
ref bool renderBody, ref Rot4 bodyFacing, ref Rot4 headFacing, ref RotDrawMode bodyDrawType,
ref bool portrait, ref bool headStump, ref bool invisible, Pawn ___pawn)
{
if (invisible)
{
return;
}
if (__instance != null)
{
Pawn pawn = ___pawn;
var hediff = (AlienMutationHediff)pawn.health.hediffSet.GetFirstHediffOfDef(PurpleIvyDefOf.PI_AlienMutation);
if (pawn != null && !pawn.Dead && hediff != null && hediff.mutationActive &&
!headStump && ((!portrait && pawn?.jobs?.curDriver != null
? !pawn.jobs.curDriver.asleep : portrait) || portrait))
{
Quaternion quat = Quaternion.AngleAxis(angle, Vector3.up);
//Get base offset.
Vector3 baseHeadOffset = rootLoc;
if (bodyFacing != Rot4.North)
{
baseHeadOffset.y += 0.0281250011f;
rootLoc.y += 0.0234375f;
}
else
{
baseHeadOffset.y += 0.0234375f;
rootLoc.y += 0.0281250011f;
}
Vector3 headOffset = quat * __instance.BaseHeadOffsetAt(headFacing);
//Finalize offset.
Vector3 eyeOffset = baseHeadOffset + headOffset + new Vector3(0f, 0.01f, 0f);
//Render eyes.
if (headFacing != Rot4.North)
{
//Is not the back.
Mesh headMesh = MeshPool.humanlikeHeadSet.MeshAt(headFacing);
Log.Message("Glow eyes");
if (headFacing.IsHorizontal)
{
//Side
GenDraw.DrawMeshNowOrLater(headMesh, eyeOffset, quat, PurpleEyes.GetEyeGraphic(false, new Color(0.368f, 0f, 1f)).MatSingle, portrait);
}
else
{
//Front
GenDraw.DrawMeshNowOrLater(headMesh, eyeOffset, quat, PurpleEyes.GetEyeGraphic(true, new Color(0.368f, 0f, 1f)).MatSingle, portrait);
}
}
}
}
}
static void DrawImplant(HediffComp_DrawImplant comp, PawnRenderer __instance, Vector3 rootLoc, float angle, bool renderBody, Rot4 bodyFacing, Rot4 headFacing, RotDrawMode bodyDrawType, bool portrait, bool headStump)
{// this.Pawn
Pawn pawn = Traverse.Create(__instance).Field("pawn").GetValue <Pawn>();
bool selected = Find.Selector.SelectedObjects.Contains(pawn) && Prefs.DevMode;
Rot4 rot = bodyFacing;
Vector3 vector3 = pawn.RaceProps.Humanlike ? __instance.BaseHeadOffsetAt(headFacing) : new Vector3();
Vector3 s = new Vector3(pawn.BodySize * 1.75f, pawn.BodySize * 1.75f, pawn.BodySize * 1.75f);
GetAltitudeOffset(pawn, comp.parent, rot, out float X, out float Y, out float Z, out float DsX, out float DsZ, out float ang);
vector3.x += X;
vector3.y += Y;
vector3.z += Z;
angle += ang;
s.x = DsX;
s.z = DsZ;
if (pawn.RaceProps.Humanlike)
{
vector3.x += 0.01f;
vector3.z += -0.35f;
}
Quaternion quaternion = Quaternion.AngleAxis(angle, Vector3.up);
Vector3 b = quaternion * vector3;
Vector3 vector = rootLoc;
Vector3 a = rootLoc;
if (bodyFacing != Rot4.North)
{
a.y += 0.02734375f;
vector.y += 0.0234375f;
}
else
{
a.y += 0.0234375f;
vector.y += 0.02734375f;
}
/*
* Material material = __instance.graphics.HeadMatAt(headFacing, bodyDrawType, headStump);
* if (material != null)
* {
* Mesh mesh2 = MeshPool.humanlikeHeadSet.MeshAt(headFacing);
* GenDraw.DrawMeshNowOrLater(mesh2, a + b, quaternion, material, portrait);
* }
*/
Vector3 loc2 = rootLoc + b;
loc2.y += 0.03105f;
bool flag = false;
/*
* if (!portrait || !Prefs.HatsOnlyOnMap)
* {
* Mesh mesh3 = __instance.graphics.HairMeshSet.MeshAt(headFacing);
* List<ApparelGraphicRecord> apparelGraphics = __instance.graphics.apparelGraphics;
* for (int j = 0; j < apparelGraphics.Count; j++)
* {
* if (apparelGraphics[j].sourceApparel.def.apparel.LastLayer == ApparelLayerDefOf.Overhead)
* {
* if (!apparelGraphics[j].sourceApparel.def.apparel.hatRenderedFrontOfFace)
* {
* flag = true;
* Material material2 = apparelGraphics[j].graphic.MatAt(bodyFacing, null);
* material2 = __instance.graphics.flasher.GetDamagedMat(material2);
* GenDraw.DrawMeshNowOrLater(mesh3, loc2, quaternion, material2, portrait);
* }
* else
* {
* Material material3 = apparelGraphics[j].graphic.MatAt(bodyFacing, null);
* material3 = __instance.graphics.flasher.GetDamagedMat(material3);
* Vector3 loc3 = rootLoc + b;
* loc3.y += ((!(bodyFacing == Rot4.North)) ? 0.03515625f : 0.00390625f);
* GenDraw.DrawMeshNowOrLater(mesh3, loc3, quaternion, material3, portrait);
* }
* }
* }
* }
*/
if (!flag && bodyDrawType != RotDrawMode.Dessicated)
{
#if DEBUG
if (selected)
{
// Log.Message(string.Format("{0}'s rootLoc: {1}, angle: {2}, renderBody: {3}, bodyFacing: {4}, headFacing: {5}, bodyDrawType: {6}, portrait: {7}", pawn.Label, rootLoc, angle, renderBody, bodyFacing.ToStringHuman(), headFacing.ToStringHuman(), bodyDrawType, portrait));
}
#endif
if (!portrait)
{
// Mesh mesh4 = __instance.graphics.HairMeshSet.MeshAt(headFacing);
Material mat = comp.ImplantMaterial(pawn, pawn.RaceProps.Humanlike ? headFacing : bodyFacing);
// GenDraw.DrawMeshNowOrLater(headFacing == Rot4.West ? MeshPool.plane10Flip : MeshPool.plane10, loc2, quaternion, mat, true);
Matrix4x4 matrix = default(Matrix4x4);
matrix.SetTRS(loc2, quaternion, s);
Graphics.DrawMesh((pawn.RaceProps.Humanlike ? headFacing : bodyFacing) == Rot4.West ? MeshPool.plane10Flip : MeshPool.plane10, matrix, mat, 0);
// Graphics.DrawMesh((pawn.RaceProps.Humanlike ? headFacing : bodyFacing) == Rot4.West ? MeshPool.plane10Flip : MeshPool.plane10, matrix, mat, 0);
}
}
/*
* Material matSingle = comp.ImplantMaterial(pawn, rot);
* Matrix4x4 matrix = default(Matrix4x4);
* matrix.SetTRS(drawPos, Quaternion.AngleAxis(angle, Vector3.up), s);
* Graphics.DrawMesh(rot == Rot4.West ? MeshPool.plane10Flip : MeshPool.plane10, matrix, matSingle, 0);
*/
}
public static void DrawBackHairLayer(PawnRenderer __instance,
ref Vector3 rootLoc,
ref float angle,
ref Rot4 headFacing,
ref RotDrawMode bodyDrawType,
ref bool portrait,
ref bool headStump)
{
PawnGraphicSet graphics = __instance.graphics;
if (!graphics.AllResolved)
{
graphics.ResolveAllGraphics();
}
Graphic_Multi_BHair hairGraphicExtended = graphics.hairGraphic as Graphic_Multi_BHair;
//if has head and hair graphics
if (graphics.headGraphic != null && hairGraphicExtended != null)
{
Material hairMat = hairGraphicExtended.BackMatAt(headFacing);
if (hairMat != null)
{
//-------------------------REPLICATED VANILLA CODE-------------------------
Quaternion quaternion = Quaternion.AngleAxis(angle, new Vector3(0f, 1f, 0f));
Vector3 b = quaternion * __instance.BaseHeadOffsetAt(headFacing);
Vector3 loc2 = rootLoc + b;
//-------------------------REPLICATED VANILLA CODE-------------------------
//loc2.y -= 0.0303030312f; //changed from original, used to be +=
bool hideHair = false;
if (!portrait || !Prefs.HatsOnlyOnMap)
{
List <ApparelGraphicRecord> apparelGraphics = graphics.apparelGraphics;
for (int j = 0; j < apparelGraphics.Count; j++)
{
if (apparelGraphics[j].sourceApparel.def.apparel.LastLayer == ApparelLayerDefOf.Overhead)
{
if (!apparelGraphics[j].sourceApparel.def.apparel.hatRenderedFrontOfFace)
{
if (HarmonyPatches_BHair.loadedShowHair)
{
hideHair = Compat_ShowHair.SHCompat_ShouldHideHair(graphics.pawn, apparelGraphics[j].sourceApparel.def, portrait);
}
else if (HarmonyPatches_BHair.loadedHatDisplaySelection)
{
hideHair = Compat_HatDisplaySelection.HDCompat_ShouldHideHair(graphics.pawn, apparelGraphics[j].sourceApparel.def.defName);
}
else
{
hideHair = true;
}
}
}
}
}
if (!hideHair && bodyDrawType != RotDrawMode.Dessicated && !headStump)
{
if (graphics.pawn.IsInvisible())
{
hairMat = InvisibilityMatPool.GetInvisibleMat(hairMat);
}
Material resultMat = graphics.flasher.GetDamagedMat(hairMat);
Mesh hairMesh = null;
if (HarmonyPatches_BHair.loadedAlienRace)
{
//use modified hair mesh after processed by Alien Race/Babies And Children
hairMesh = Patch_AlienRace.ARCompat_GetCopiedMesh();
}
if (HarmonyPatches_BHair.loadedRimWorldChildren)
{
//use modified hair mesh after processed by RimWorldChildren
hairMesh = Patch_RimWorldChildren.RCCompat_GetCopiedMesh();
resultMat = Patch_RimWorldChildren.RCCompat_ModifyHairForChild(resultMat, graphics.pawn);
//alternate calling method for manual calling
//hairMesh = Compat_RimWorldChildren.RCCompat_GetModifiedPawnHairMesh(graphics, graphics.pawn, headFacing);
}
if (hairMesh == null)
{
//default
hairMesh = graphics.HairMeshSet.MeshAt(headFacing);
}
GenDraw.DrawMeshNowOrLater(mesh: hairMesh, mat: resultMat, loc: loc2, quat: quaternion, drawNow: portrait);
}
}
}
}
public static Vector2 ForPawn(Pawn pawn)
{
if (pawn.RaceProps.Humanlike)
{
PawnRenderer renderer = pawn.Drawer.renderer;
PawnGraphicSet graphicSet = renderer.graphics;
if (!graphicSet.AllResolved)
{
graphicSet.ResolveAllGraphics();
}
try
{
if (pawn.IsDessicated() && graphicSet.dessicatedGraphic != null)
{
return(BoundMap(
graphicSet.dessicatedGraphic,
GraphicType.Pawn,
graphicSet.desiccatedHeadGraphic,
new Vector2(renderer.BaseHeadOffsetAt(Rot4.South).x,
renderer.BaseHeadOffsetAt(Rot4.East).z)));
}
return(BoundMap(
graphicSet.nakedGraphic,
GraphicType.Pawn,
graphicSet.headGraphic,
new Vector2(renderer.BaseHeadOffsetAt(Rot4.South).x,
renderer.BaseHeadOffsetAt(Rot4.East).z)));
}
catch (ArgumentException e) { throw new ArgumentException(pawn + ".graphics." + (pawn.IsDessicated() ? "dessicated/dessicatedHead" : "naked/head") + "Graphic", e); }
}
else
{
PawnKindLifeStage lifeStage = pawn.ageTracker.CurKindLifeStage;
try
{
if (pawn.IsDessicated() && lifeStage.dessicatedBodyGraphicData != null)
{
return(Vector2.Scale(BoundMap(lifeStage.dessicatedBodyGraphicData.Graphic, GraphicType.Pawn), lifeStage.dessicatedBodyGraphicData.drawSize));
}
}
catch (ArgumentException e) { throw new ArgumentException(pawn + ".lifeStage[" + pawn.ageTracker.CurLifeStageIndex + "].dessicatedBodyGraphicData", e); }
try
{
if (pawn.gender == Gender.Female && lifeStage.femaleGraphicData != null)
{
return(Vector2.Scale(BoundMap(lifeStage.femaleGraphicData.Graphic, GraphicType.Pawn), lifeStage.femaleGraphicData.drawSize));
}
}
catch (ArgumentException e) { throw new ArgumentException(pawn + ".lifeStage[" + pawn.ageTracker.CurLifeStageIndex + "].femaleGraphicData", e); }
try { if (lifeStage.bodyGraphicData != null)
{
return(Vector2.Scale(BoundMap(lifeStage.bodyGraphicData.Graphic, GraphicType.Pawn), lifeStage.bodyGraphicData.drawSize));
}
}
catch (ArgumentException e) { throw new ArgumentException(pawn + ".lifeStage[" + pawn.ageTracker.CurLifeStageIndex + "].bodyGraphicData", e); }
return(Vector2.zero);
}
}
public static void PawnRenderer_RenderPawnInternal_Postfix(ref PawnRenderer __instance, Vector3 rootLoc, float angle, bool renderBody, Rot4 bodyFacing, Rot4 headFacing, RotDrawMode bodyDrawType = RotDrawMode.Fresh, bool portrait = false, bool headStump = false)
{
if (!__instance.graphics.AllResolved)
{
__instance.graphics.ResolveAllGraphics();
}
Mesh mesh = null;
Quaternion quat = Quaternion.AngleAxis(angle, Vector3.up);
Pawn pawn = Traverse.Create(__instance).Field("pawn").GetValue <Pawn>();
if (AdeptusIntergrationUtil.enabled_AlienRaces)
{
AM_PawnRenderer_RenderPawnInternal_DrawExtras_Patch.AlienRacesPatch(ref __instance, rootLoc, angle, renderBody, bodyFacing, headFacing, out mesh, bodyDrawType, portrait, headStump);
}
else
{
if (pawn.RaceProps.Humanlike)
{
mesh = MeshPool.humanlikeBodySet.MeshAt(bodyFacing);
}
else
{
mesh = __instance.graphics.nakedGraphic.MeshAt(bodyFacing);
}
}
if (renderBody)
{
Vector3 vector = rootLoc;
if (pawn.apparel != null && pawn.apparel.WornApparelCount > 0)
{
for (int k = 0; k < pawn.apparel.WornApparel.Count; k++)
{
if (pawn.apparel.WornApparel[k].TryGetComp <CompPauldronDrawer>() != null)
{
foreach (CompPauldronDrawer Pauldron in pawn.apparel.WornApparel[k].AllComps.Where(x => x.GetType() == typeof(CompPauldronDrawer)))
{
if (!Pauldron.Props.PauldronEntries.NullOrEmpty())
{
if (!Pauldron.pauldronInitialized)
{
if (Rand.Chance(Pauldron.Props.PauldronEntryChance))
{
Pauldron.shoulderPadEntry = Pauldron.Props.PauldronEntries.RandomElementByWeight((ShoulderPadEntry x) => x.commonality);
Pauldron.pauldronGraphicPath = Pauldron.shoulderPadEntry.padTexPath;
Pauldron.useSecondaryColor = Pauldron.shoulderPadEntry.UseSecondaryColor;
Pauldron.padType = Pauldron.shoulderPadEntry.shoulderPadType;
}
Pauldron.pauldronInitialized = true;
}
if (Pauldron.ShouldDrawPauldron(pawn, bodyFacing, out Material pauldronMat))
{
vector.y += Pauldron.GetAltitudeOffset(bodyFacing);
GenDraw.DrawMeshNowOrLater(mesh, vector, quat, pauldronMat, portrait);
// vector.y += CompPauldronDrawer.MinClippingDistance;
}
}
}
}
if (pawn.apparel.WornApparel[k].TryGetComp <CompApparelExtraDrawer>() != null)
{
foreach (CompApparelExtraDrawer Extas in pawn.apparel.WornApparel[k].AllComps.Where(x => x.GetType() == typeof(CompApparelExtraDrawer)))
{
if (!Extas.pprops.ExtrasEntries.NullOrEmpty())
{
if (Extas.ShouldDrawExtra(pawn, pawn.apparel.WornApparel[k], bodyFacing, out Material extraMat))
{
Vector3 drawAt = vector;
if (Extas.onHead)
{
drawAt = vector + __instance.BaseHeadOffsetAt(headFacing);
}
drawAt.y += Extas.GetAltitudeOffset(bodyFacing, Extas.ExtraPartEntry);
GenDraw.DrawMeshNowOrLater(mesh, drawAt, quat, extraMat, portrait);
// vector.y += CompApparelExtaDrawer.MinClippingDistance;
}
}
}
}
Apparel_VisibleAccessory VisibleAccessory;
if (pawn.apparel.WornApparel[k].GetType() == typeof(Apparel_VisibleAccessory))
{
VisibleAccessory = (Apparel_VisibleAccessory)pawn.apparel.WornApparel[k];
}
//ApparelGraphicRecord apparelGraphicRecord = __instance.graphics.apparelGraphics[k];
//if (apparelGraphicRecord.sourceApparel.def.apparel.LastLayer == ApparelLayer.Shell)
//{
// Material material2 = apparelGraphicRecord.graphic.MatAt(bodyFacing, null);
// material2 = __instance.graphics.flasher.GetDamagedMat(material2);
// GenDraw.DrawMeshNowOrLater(mesh, vector, quat, material2, portrait);
//}
}
}
if (!pawn.Dead)
{
for (int l = 0; l < pawn.health.hediffSet.hediffs.Count; l++)
{
Vector3 drawAt = vector;
HediffComp_DrawImplant_AdMech drawer = pawn.health.hediffSet.hediffs[l].TryGetComp <HediffComp_DrawImplant_AdMech>();
if (drawer != null)
{
Material material = null;
if (drawer.implantDrawProps.implantDrawerType != ImplantDrawerType.Head)
{
drawAt.y += 0.005f;
if (bodyFacing == Rot4.South && drawer.implantDrawProps.implantDrawerType == ImplantDrawerType.Backpack)
{
drawAt.y -= 0.3f;
}
material = drawer.ImplantMaterial(pawn, bodyFacing);
// GenDraw.DrawMeshNowOrLater(mesh, drawAt, quat, material, portrait);
}
else
{
if (!pawn.Downed && !pawn.Dead && drawer.implantDrawProps.useHeadOffset)
{
drawAt = vector + __instance.BaseHeadOffsetAt(headFacing);
}
else
{
if (pawn.Downed || pawn.Dead && drawer.implantDrawProps.useHeadOffset)
{
drawAt.y = vector.y + __instance.BaseHeadOffsetAt(headFacing).y;
}
}
drawAt.y += 0.005f;
material = drawer.ImplantMaterial(pawn, headFacing);
// GenDraw.DrawMeshNowOrLater(mesh, drawAt, quat, material, portrait);
}
if (material != null)
{
// GenDraw.DrawMeshNowOrLater(mesh, drawAt , quat, material, portrait);
// Angle calculation to not pick the shortest, taken from Quaternion.Angle and modified
GenDraw.DrawMeshNowOrLater(mesh: mesh, loc: drawAt + drawer.offsetVector().RotatedBy(angle: Mathf.Acos(f: Quaternion.Dot(a: Quaternion.identity, b: quat)) * 2f * 57.29578f),
quat: quat, mat: material, drawNow: portrait);
drawAt.y += HediffComp_DrawImplant_AdMech.MinClippingDistance;
}
}
HediffComp_Shield _Shield;
if ((_Shield = pawn.health.hediffSet.hediffs[l].TryGetComp <HediffComp_Shield>()) != null)
{
_Shield.DrawWornExtras();
}
}
}
}
}
public void DrawImplant()
{// this.Pawn
bool selected = Find.Selector.SelectedObjects.Contains(this.Pawn);
HediffComp_DrawImplant comp = this;
string direction = "";
float angle = 0f;
float offset = 0f;
float yvalue = Pawn.Drawer.DrawPos.y;
Vector3 drawPos = Pawn.Drawer.DrawPos;
drawPos.y = Altitudes.AltitudeFor((AltitudeLayer)17);
Vector3 s = new Vector3(1.5f, 1.5f, 1.5f);
PawnRenderer pawnRenderer = this.Pawn.Drawer.renderer;
Rot4 rot = LayingFacing();
if (Pawn.CarriedBy != null)
{
#if DEBUG
if (selected)
{
Log.Message(string.Format("{0} carried by {1} drawpos {2} modified to {3}", Pawn.Name, Pawn.CarriedBy.Name, drawPos, Pawn.CarriedBy.DrawPos));
}
#endif
drawPos.z = Pawn.CarriedBy.DrawPos.z;
drawPos.x = Pawn.CarriedBy.DrawPos.x;
}
if (Pawn.InBed())
{
if (Pawn.CurrentBed().Rotation == Rot4.South)
{
#if DEBUG
if (selected)
{
Log.Message(string.Format("{0}", Pawn.CurrentBed().Rotation.ToStringHuman()));
}
#endif
drawPos -= pawnRenderer.BaseHeadOffsetAt(Rot4.South);
}
else if (Pawn.CurrentBed().Rotation == Rot4.North)
{
#if DEBUG
if (selected)
{
Log.Message(string.Format("{0}", Pawn.CurrentBed().Rotation.ToStringHuman()));
}
#endif
drawPos -= pawnRenderer.BaseHeadOffsetAt(Rot4.North);
}
else if (Pawn.CurrentBed().Rotation == Rot4.East)
{
#if DEBUG
if (selected)
{
Log.Message(string.Format("{0}", Pawn.CurrentBed().Rotation.ToStringHuman()));
}
#endif
drawPos.x += 0.3f;
}
else if (Pawn.CurrentBed().Rotation == Rot4.West)
{
#if DEBUG
if (selected)
{
Log.Message(string.Format("{0}", Pawn.CurrentBed().Rotation.ToStringHuman()));
}
#endif
drawPos.x -= 0.3f;
}
drawPos.y = yvalue;
#if DEBUG
if (selected)
{
Log.Message(string.Format("{0} in bed {1} drawpos modified to {2}", Pawn.Name, Pawn.InBed(), drawPos));
}
#endif
}
if (offset < 0)
{
drawPos.y -= offset;
}
else
{
drawPos.y += offset;
}
if (Pawn.Downed)
{
angle = pawnRenderer.wiggler.downedAngle;
if (Pawn.CarriedBy != null)
{
#if DEBUG
if (selected)
{
Log.Message(string.Format("{0} carried by {1} angle {2} modified to {3}", Pawn.Name, Pawn.CarriedBy.Name, angle, Pawn.CarriedBy.carryTracker.CarriedThing.Rotation.AsAngle));
}
#endif
angle = Pawn.CarriedBy.carryTracker.CarriedThing.Rotation.AsAngle;
}
if (Pawn.InBed())
{
if (Pawn.CurrentBed().Rotation == Rot4.South)
{
angle = 0f;
}
else if (Pawn.CurrentBed().Rotation == Rot4.North)
{
angle = 180f;
}
else if (Pawn.CurrentBed().Rotation == Rot4.East)
{
angle = 270;
}
else if (Pawn.CurrentBed().Rotation == Rot4.West)
{
angle = 90;
}
// angle = Pawn.CurrentBed().Rotation.AsAngle;
}
if (Pawn.kindDef.race == YautjaDefOf.RRY_Alien_Yautja)
{
s = new Vector3(2f, 1.5f, 2f);
if (rot.ToStringHuman() == "West" || rot == Rot4.West)
{
//drawPos.z -= 0.15f;
// drawPos.x += 0.25f;
}
else
{
// drawPos.x += 0.25f;
}
}
}
#if DEBUG
if (selected)
{
Log.Message(string.Format("{0}'s {1}, Rot:{2}, offset:{3}, x:{4}, z:{5}", Pawn.Label, this.parent.def.label, rot, offset, drawPos.x, drawPos.z));
Log.Message(string.Format("Rot ToStringHuman:{1}, FacingCell:{2}, AsVector2:{3}, AsByte:{4}, AsAngle:{5}", rot, rot.ToStringHuman(), rot.FacingCell, rot.AsVector2, rot.AsByte, rot.AsAngle));
}
#endif
Material matSingle = comp.ImplantMaterial(Pawn, rot);
Matrix4x4 matrix = default(Matrix4x4);
matrix.SetTRS(drawPos, Quaternion.AngleAxis(angle, Vector3.up), s);
Graphics.DrawMesh(rot == Rot4.West ? MeshPool.plane10Flip : MeshPool.plane10, matrix, matSingle, 0);
}
public static void Postfix(PawnRenderer __instance, ref Pawn __state, Vector3 rootLoc, float angle, bool renderBody, Rot4 bodyFacing, Rot4 headFacing, RotDrawMode bodyDrawType, bool portrait, bool headStump)
{
if (__state != null && __instance.graphics.headGraphic != null)
{
#if DEBUG
bool isPawn = false;
if (__state.Faction.def == FactionDefOf.PlayerColony || __state.Faction.def == FactionDefOf.PlayerTribe)
{
isPawn = __state.Name.ToStringShort.Equals("Happy");
}
#endif
Quaternion quad = Quaternion.AngleAxis(angle, Vector3.up);
Vector3 b = quad * __instance.BaseHeadOffsetAt(headFacing);
Vector3 loc2 = rootLoc + b;
bool forceShowHair = false;
bool hideHats = HideHats(portrait);
float hairLoc = 0;
bool flag = false;
List <ApparelGraphicRecord> apparelGraphics = __instance.graphics.apparelGraphics;
for (int j = 0; j < apparelGraphics.Count; j++)
{
Apparel sourceApparel = apparelGraphics[j].sourceApparel;
if (sourceApparel.def.apparel.LastLayer == ApparelLayerDefOf.Overhead)
{
#if DEBUG && T
int i = 10324;
Log.ErrorOnce("---hats:", i);
++i;
foreach (KeyValuePair <ThingDef, bool> kv in Settings.HatsThatHide)
{
Log.ErrorOnce(kv.Key + " " + kv.Value, i);
++i;
}
Log.ErrorOnce("---Hair:", i);
++i;
foreach (KeyValuePair <HairDef, bool> kv in Settings.HairThatShows)
{
Log.ErrorOnce(kv.Key + " " + kv.Value, i);
++i;
}
#endif
#if DEBUG
if (isPawn)
{
if (!Settings.HatsThatHide.TryGetValue(sourceApparel.def, out bool bb))
{
bb = false;
}
Log.Warning("Force no hair --- HatsThatHide[" + sourceApparel.def + "] = " + bb);
}
#endif
if (!hideHats)
{
if (!Settings.HatsThatHide.TryGetValue(sourceApparel.def, out bool force))
{
force = false;
}
forceShowHair = !force;
}
if (!sourceApparel.def.apparel.hatRenderedFrontOfFace)
{
flag = true;
loc2.y += 0.03125f;
hairLoc = loc2.y;
}
else
{
Vector3 loc3 = rootLoc + b;
loc3.y += ((!(bodyFacing == Rot4.North)) ? 0.03515625f : 0.00390625f);
hairLoc = loc3.y;
}
}
}
#if DEBUG && T
if (isPawn && pawn.Name.ToStringShort.Equals("Happy"))
{
Log.Warning(pawn.Name.ToStringShort + " Hair: " + pawn.story.hairDef.defName + " HideAllHats: " + Settings.HideAllHats + " forceShowHair: " + forceShowHair + " flag: " + flag + " bodyDrawType: " + bodyDrawType + " headStump: " + headStump);
}
#endif
if ((!flag && bodyDrawType != RotDrawMode.Dessicated && !headStump) ||
(!hideHats && Settings.HairToHide.TryGetValue(__state.story.hairDef, out bool v) && v))
{
// Hair was already rendered
}
else if ((hideHats || forceShowHair) && hairLoc > 0)
{
if (hairLoc > 0.001f)
{
loc2.y = hairLoc - 0.001f;
Material mat = __instance.graphics.HairMatAt(headFacing);
if (getBodySizeScalingMI != null && getModifiedHairMeshSetMI != null)
{
Vector3 scaledHairLoc = new Vector3(b.x, b.y, b.z);
float scale = (float)getBodySizeScalingMI.Invoke(null, new object[] { __state.ageTracker.CurLifeStage.bodySizeFactor, __state });
scaledHairLoc.x *= scale;
scaledHairLoc.z *= scale;
scaledHairLoc += rootLoc;
scaledHairLoc.y = loc2.y;
GraphicMeshSet meshSet = (GraphicMeshSet)getModifiedHairMeshSetMI.Invoke(null, new object[] { scale, __state });
GenDraw.DrawMeshNowOrLater(meshSet.MeshAt(headFacing), scaledHairLoc, quad, mat, portrait);
}
else
{
GenDraw.DrawMeshNowOrLater(__instance.graphics.HairMeshSet.MeshAt(headFacing), loc2, quad, mat, portrait);
}
}
}
}
}
public static bool Prefix(PawnRenderer __instance, Pawn ___pawn, PawnWoundDrawer ___woundOverlays, PawnHeadOverlays ___statusOverlays,
Vector3 rootLoc, float angle, bool renderBody, Rot4 bodyFacing, Rot4 headFacing, RotDrawMode bodyDrawType, bool portrait, bool headStump, bool invisible)
{
if (___pawn.def is RaceAddonThingDef thingDef)
{
if (!__instance.graphics.AllResolved)
{
__instance.graphics.ResolveAllGraphics();
}
RaceAddonComp racomp = ___pawn.GetComp <RaceAddonComp>();
Quaternion bodyQuat = Quaternion.AngleAxis(angle, Vector3.up);
Quaternion headQuat = bodyQuat;
rootLoc.z -= racomp.cachedDrawLocCorrection;
Vector3 bodyLoc = rootLoc;
Vector3 headLoc = __instance.BaseHeadOffsetAt(bodyFacing);
GetModifiedValue(racomp, ref bodyQuat, ref headQuat, ref bodyLoc, ref headLoc, ___pawn, ref renderBody, ref bodyFacing, ref headFacing, portrait);
// For Resolve Head Targeting Error
Mesh bodyMesh = racomp.raceAddonGraphicSet.bodyMeshSet.MeshAt(bodyFacing);
Mesh headMesh = racomp.raceAddonGraphicSet.headMeshSet.MeshAt(headFacing);
List <ApparelGraphicRecord> apparelGraphics = __instance.graphics.apparelGraphics;
if (renderBody)
{
List <Material> bodyMatList = __instance.graphics.MatsBodyBaseAt(bodyFacing, bodyDrawType);
for (int i = 0; i < bodyMatList.Count; i++)
{
// Draw Body And Apparel
Material mat = OverrideMaterialIfNeeded_NewTemp(__instance.graphics, bodyMatList[i], ___pawn, portrait);
GenDraw.DrawMeshNowOrLater(bodyMesh, bodyLoc.SetLayer((i + 3) * 10), bodyQuat, mat, portrait);
}
if (bodyDrawType == RotDrawMode.Fresh && thingDef.raceAddonSettings.graphicSetting.drawWound)
{
// Draw Wound
___woundOverlays.RenderOverBody(bodyLoc.SetLayer(60), bodyMesh, bodyQuat, portrait);
}
for (int k = 0; k < apparelGraphics.Count; k++)
{
// Draw Shell
if (apparelGraphics[k].sourceApparel.def.apparel.LastLayer == ApparelLayerDefOf.Shell && !apparelGraphics[k].sourceApparel.def.apparel.shellRenderedBehindHead)
{
Material original3 = apparelGraphics[k].graphic.MatAt(bodyFacing);
original3 = OverrideMaterialIfNeeded_NewTemp(__instance.graphics, original3, ___pawn, portrait);
GenDraw.DrawMeshNowOrLater(bodyMesh, bodyLoc.SetLayer(bodyFacing == Rot4.North ? 80 : 70), bodyQuat, original3, portrait);
}
// Draw Pack
if (PawnRenderer.RenderAsPack(apparelGraphics[k].sourceApparel))
{
Material original4 = apparelGraphics[k].graphic.MatAt(bodyFacing);
original4 = OverrideMaterialIfNeeded_NewTemp(__instance.graphics, original4, ___pawn, portrait);
if (apparelGraphics[k].sourceApparel.def.apparel.wornGraphicData != null)
{
Vector2 vector3 = apparelGraphics[k].sourceApparel.def.apparel.wornGraphicData.BeltOffsetAt(bodyFacing, ___pawn.story.bodyType);
Vector2 vector4 = apparelGraphics[k].sourceApparel.def.apparel.wornGraphicData.BeltScaleAt(___pawn.story.bodyType);
Matrix4x4 matrix = Matrix4x4.Translate(bodyLoc.SetLayer(bodyFacing == Rot4.South ? 10 : 90)) * Matrix4x4.Rotate(bodyQuat) * Matrix4x4.Translate(new Vector3(vector3.x, 0f, vector3.y)) * Matrix4x4.Scale(new Vector3(vector4.x, 1f, vector4.y));
GenDraw.DrawMeshNowOrLater_NewTemp(bodyMesh, matrix, original4, portrait);
}
else
{
GenDraw.DrawMeshNowOrLater(bodyMesh, bodyLoc.SetLayer(bodyFacing == Rot4.North ? 80 : 70), bodyQuat, original4, portrait);
}
}
}
//Draw Body Addons
if (bodyDrawType != RotDrawMode.Dessicated && racomp.raceAddonGraphicSet.addonGraphics.FindAll(x => x.data.addonDef.drawingToBody) is var list && list.Count > 0)
{
foreach (var record in list)
{
if (!___pawn.InBed() || ___pawn.InBed() && record.data.addonDef.drawnInBed)
{
Material addonMat = OverrideMaterialIfNeeded_NewTemp(__instance.graphics, record.MatAt(bodyFacing, bodyDrawType), ___pawn, portrait);
if (addonMat != null)
{
Vector3 offset = record.data.addonDef.offsets.GetLoc(bodyFacing);
GenDraw.DrawMeshNowOrLater(bodyMesh, offset + bodyLoc.SetLayer(record.data.addonDef.drawPriority.GetPriority(bodyFacing)), bodyQuat, addonMat, portrait);
}
}
}
}
}
if (__instance.graphics.headGraphic != null)
{
// Draw Head
if (__instance.graphics.HeadMatAt_NewTemp(headFacing, bodyDrawType, headStump, portrait) is var headMat && headMat != null)
{
GenDraw.DrawMeshNowOrLater(headMesh, headLoc.SetLayer(headFacing == Rot4.North ? 70 : 80), headQuat, headMat, portrait);
}
// Draw Hat, Mask
bool hideHair = false;
if (!portrait || !Prefs.HatsOnlyOnMap)
{
for (int j = 0; j < apparelGraphics.Count; j++)
{
if (apparelGraphics[j].sourceApparel.def.apparel.LastLayer == ApparelLayerDefOf.Overhead)
{
hideHair = !apparelGraphics[j].sourceApparel.def.apparel.hatRenderedFrontOfFace;
Material mat = OverrideMaterialIfNeeded_NewTemp(__instance.graphics, apparelGraphics[j].graphic.MatAt(headFacing), ___pawn, portrait);
GenDraw.DrawMeshNowOrLater(headMesh, headLoc.SetLayer(hideHair ? 120 : (bodyFacing == Rot4.North) ? 10 : 110), headQuat, mat, portrait);
}
}
}
if (bodyDrawType != RotDrawMode.Dessicated && !headStump)
{
bool blinkNow = false;
bool winkNow = false;
if (racomp.raceAddonGraphicSet.eyeBlinker != null)
{
blinkNow = racomp.raceAddonGraphicSet.eyeBlinker.BlinkNow;
winkNow = racomp.raceAddonGraphicSet.eyeBlinker.WinkNow;
}
// Draw Upper Face
if (racomp.raceAddonGraphicSet.upperFaceGraphic != null)
{
Material faceMat = OverrideMaterialIfNeeded_NewTemp(__instance.graphics, racomp.raceAddonGraphicSet.upperFaceGraphic.MatAt(headFacing, portrait, blinkNow, winkNow), ___pawn);
GenDraw.DrawMeshNowOrLater(headMesh, headLoc.SetLayer(105), headQuat, faceMat, portrait);
}
// Draw Lower Face
if (racomp.raceAddonGraphicSet.lowerFaceGraphic != null)
{
Material faceMat = OverrideMaterialIfNeeded_NewTemp(__instance.graphics, racomp.raceAddonGraphicSet.lowerFaceGraphic.MatAt(headFacing, portrait, blinkNow, winkNow), ___pawn);
GenDraw.DrawMeshNowOrLater(headMesh, headLoc.SetLayer(85), headQuat, faceMat, portrait);
}
// Draw Upper Hair
if (!hideHair || racomp.raceAddonGraphicSet.drawUpperHair)
{
GenDraw.DrawMeshNowOrLater(headMesh, headLoc.SetLayer(100), headQuat, __instance.graphics.HairMatAt_NewTemp(headFacing, portrait), portrait);
}
// Draw Lower Hair
if (racomp.raceAddonGraphicSet.hairGraphic != null && (!hideHair || racomp.raceAddonGraphicSet.drawLowerHair))
{
if (renderBody || ___pawn.InBed() && (___pawn.story.hairDef as ImprovedHairDef).drawnInBed)
{
Material mat = racomp.raceAddonGraphicSet.hairGraphic.MatAt(headFacing);
mat = OverrideMaterialIfNeeded_NewTemp(__instance.graphics, mat, ___pawn, portrait);
GenDraw.DrawMeshNowOrLater(headMesh, headLoc.SetLayer(20), headQuat, mat, portrait);
}
}
// Draw Head Addons
if (racomp.raceAddonGraphicSet.addonGraphics.FindAll(x => !x.data.addonDef.drawingToBody) is var list && list.Count > 0)
{
foreach (var record in list)
{
if (!___pawn.InBed() || ___pawn.InBed() && record.data.addonDef.drawnInBed)
{
Material addonMat = OverrideMaterialIfNeeded_NewTemp(__instance.graphics, record.MatAt(headFacing, bodyDrawType), ___pawn, portrait);
if (addonMat != null)
{
Vector3 offset = record.data.addonDef.offsets.GetLoc(bodyFacing);
GenDraw.DrawMeshNowOrLater(headMesh, offset + headLoc.SetLayer(record.data.addonDef.drawPriority.GetPriority(headFacing)), headQuat, addonMat, portrait);
}
}
}
}
}
}
/*
* if (!portrait)
* {
* DrawEquipment(rootLoc, ___pawn, racomp.raceAddonGraphicSet.equipmentMeshSet.MeshAt(bodyFacing));
* if (___pawn.apparel != null)
* {
* List<Apparel> wornApparel = ___pawn.apparel.WornApparel;
* for (int l = 0; l < wornApparel.Count; l++)
* {
* wornApparel[l].DrawWornExtras();
* }
* }
* ___statusOverlays.RenderStatusOverlays(bodyLoc.SetLayer(130), bodyQuat, MeshPool.humanlikeHeadSet.MeshAt(headFacing));
* }
* return false;
*/
}
return(true);
}
public static void RenderPawnInternal(this PawnRenderer renderer, Vector3 rootLoc, Quaternion quat, bool renderBody, Rot4 bodyFacing, Rot4 headFacing, RotDrawMode bodyDrawType = RotDrawMode.Fresh, bool portrait = false)
{
Pawn rendererPawn = renderer.GetFieldViaReflection <Pawn>("pawn");
if (!renderer.graphics.AllResolved)
{
renderer.graphics.ResolveAllGraphics();
}
Mesh mesh = null;
if (renderBody)
{
Vector3 loc = rootLoc;
loc.y += 0.005f;
if (bodyDrawType == RotDrawMode.Dessicated && !rendererPawn.RaceProps.Humanlike && renderer.graphics.dessicatedGraphic != null && !portrait)
{
renderer.graphics.dessicatedGraphic.Draw(loc, bodyFacing, rendererPawn);
}
else
{
if (rendererPawn.RaceProps.Humanlike)
{
mesh = MeshPool.humanlikeBodySet.MeshAt(bodyFacing);
}
else
{
mesh = renderer.graphics.nakedGraphic.MeshAt(bodyFacing);
}
List <Material> list = renderer.graphics.MatsBodyBaseAt(bodyFacing, bodyDrawType);
for (int i = 0; i < list.Count; i++)
{
Material damagedMat = renderer.graphics.flasher.GetDamagedMat(list[i]);
GenDraw.DrawMeshNowOrLater(mesh, loc, quat, damagedMat, portrait);
loc.y += 0.005f;
}
if (bodyDrawType == RotDrawMode.Fresh)
{
Vector3 drawLoc = rootLoc;
drawLoc.y += 0.02f;
renderer.GetFieldViaReflection <PawnWoundDrawer>("woundOverlays").RenderOverBody(drawLoc, mesh, quat, portrait);
}
}
}
Vector3 loc2 = rootLoc;
Vector3 a = rootLoc;
if (bodyFacing != Rot4.North)
{
a.y += 0.03f;
loc2.y += 0.0249999985f;
}
else
{
a.y += 0.0249999985f;
loc2.y += 0.03f;
}
if (renderer.graphics.headGraphic != null)
{
Vector3 b = quat * renderer.BaseHeadOffsetAt(headFacing);
Mesh mesh2 = MeshPool.humanlikeHeadSet.MeshAt(headFacing);
Material mat = renderer.graphics.HeadMatAt(headFacing, bodyDrawType);
GenDraw.DrawMeshNowOrLater(mesh2, a + b, quat, mat, portrait);
Vector3 loc3 = rootLoc + b;
loc3.y += 0.035f;
bool flag = false;
if (!portrait)
{
Mesh mesh3 = renderer.graphics.HairMeshSet.MeshAt(headFacing);
List <ApparelGraphicRecord> apparelGraphics = renderer.graphics.apparelGraphics;
for (int j = 0; j < apparelGraphics.Count; j++)
{
if (apparelGraphics[j].sourceApparel.def.apparel.LastLayer == ApparelLayer.Overhead)
{
flag = true;
Material material = apparelGraphics[j].graphic.MatAt(bodyFacing, null);
material = renderer.graphics.flasher.GetDamagedMat(material);
GenDraw.DrawMeshNowOrLater(mesh3, loc3, quat, material, portrait);
}
}
}
if (!flag && bodyDrawType != RotDrawMode.Dessicated)
{
Mesh mesh4 = renderer.graphics.HairMeshSet.MeshAt(headFacing);
Material mat2 = renderer.graphics.HairMatAt(headFacing);
GenDraw.DrawMeshNowOrLater(mesh4, loc3, quat, mat2, portrait);
}
}
if (renderBody)
{
for (int k = 0; k < renderer.graphics.apparelGraphics.Count; k++)
{
ApparelGraphicRecord apparelGraphicRecord = renderer.graphics.apparelGraphics[k];
if (apparelGraphicRecord.sourceApparel.def.apparel.LastLayer == ApparelLayer.Shell)
{
Material material2 = apparelGraphicRecord.graphic.MatAt(bodyFacing, null);
material2 = renderer.graphics.flasher.GetDamagedMat(material2);
GenDraw.DrawMeshNowOrLater(mesh, loc2, quat, material2, portrait);
}
}
}
if (!portrait && rendererPawn.RaceProps.Animal && rendererPawn.inventory != null && rendererPawn.inventory.innerContainer.Count > 0)
{
Graphics.DrawMesh(mesh, loc2, quat, renderer.graphics.packGraphic.MatAt(rendererPawn.Rotation, null), 0);
}
if (!portrait)
{
renderer.CallMethodViaReflection("DrawEquipment", rootLoc);
if (rendererPawn.apparel != null)
{
List <Apparel> wornApparel = rendererPawn.apparel.WornApparel;
for (int l = 0; l < wornApparel.Count; l++)
{
wornApparel[l].DrawWornExtras();
}
}
Vector3 bodyLoc = rootLoc;
bodyLoc.y += 0.0449999981f;
renderer.GetFieldViaReflection <PawnHeadOverlays>("statusOverlays").RenderStatusOverlays(bodyLoc, quat, MeshPool.humanlikeHeadSet.MeshAt(headFacing));
}
}
// Token: 0x0600005A RID: 90 RVA: 0x00004798 File Offset: 0x00002998
public static void Patch_PawnRenderer_RenderPawnInternal(ref PawnRenderer __instance, Vector3 rootLoc, Quaternion quat, bool renderBody, Rot4 bodyFacing, Rot4 headFacing, RotDrawMode bodyDrawType, bool portrait, bool headStump)
{
bool flag = __instance != null && AndroidsModSettings.Instance.androidEyeGlow;
if (flag)
{
Pawn pawn = HarmonyPatches.PawnRenderer_GetPawn_GetPawn(__instance);
bool flag4;
if (pawn != null && pawn.def == ThingDefOf.ChjAndroid && !pawn.Dead && !headStump)
{
bool flag3;
if (!portrait)
{
bool flag2;
if (pawn == null)
{
flag2 = (null != null);
}
else
{
Pawn_JobTracker jobs = pawn.jobs;
flag2 = (((jobs != null) ? jobs.curDriver : null) != null);
}
if (flag2)
{
flag3 = !pawn.jobs.curDriver.asleep;
goto IL_73;
}
}
flag3 = portrait;
IL_73:
flag4 = (flag3 || portrait);
}
else
{
flag4 = false;
}
bool flag5 = flag4;
if (flag5)
{
Vector3 a = rootLoc;
bool flag6 = bodyFacing != Rot4.North;
if (flag6)
{
a.y += 0.0281250011f;
rootLoc.y += 0.0234375f;
}
else
{
a.y += 0.0234375f;
rootLoc.y += 0.0281250011f;
}
Vector3 b = quat * __instance.BaseHeadOffsetAt(headFacing);
Vector3 loc = a + b + new Vector3(0f, 0.01f, 0f);
bool flag7 = headFacing != Rot4.North;
if (flag7)
{
Mesh mesh = MeshPool.humanlikeHeadSet.MeshAt(headFacing);
bool isHorizontal = headFacing.IsHorizontal;
if (isHorizontal)
{
GenDraw.DrawMeshNowOrLater(mesh, loc, quat, EffectTextures.GetEyeGraphic(false, pawn.story.hairColor.SaturationChanged(0.6f)).MatSingle, portrait);
}
else
{
GenDraw.DrawMeshNowOrLater(mesh, loc, quat, EffectTextures.GetEyeGraphic(true, pawn.story.hairColor.SaturationChanged(0.6f)).MatSingle, portrait);
}
}
}
}
}
private static bool Prefix(PawnRenderer __instance, Pawn ___pawn, PawnWoundDrawer ___woundOverlays, PawnHeadOverlays ___statusOverlays,
Vector3 rootLoc, float angle, bool renderBody, Rot4 bodyFacing, Rot4 headFacing, RotDrawMode bodyDrawType, bool portrait, bool headStump, bool invisible)
{
if (___pawn.def is RaceAddonThingDef thingDef)
{
//====================================================================================================
if (!__instance.graphics.AllResolved)
{
__instance.graphics.ResolveAllGraphics();
}
//====================================================================================================
RaceAddonComp racomp = ___pawn.GetComp <RaceAddonComp>();
//====================================================================================================
Quaternion bodyQuat = Quaternion.AngleAxis(angle, Vector3.up);
//====================================================================================================
Quaternion headQuat = bodyQuat;
var flag1 = false;
if (!portrait && ___pawn.Awake())
{
if (racomp.headRotator != null && !___pawn.Drafted)
{
headQuat *= racomp.headRotator.GetQuat();
}
if (racomp.headTargeter != null && !___pawn.Downed)
{
var initialRot = headFacing;
headFacing.Rotate(racomp.headTargeter.RotDirection);
if (initialRot != headFacing)
{
flag1 = true;
}
}
}
//====================================================================================================
Mesh bodyMesh = racomp.bodyMeshSet.MeshAt(bodyFacing);
//====================================================================================================
Mesh headMesh = racomp.headMeshSet.MeshAt(headFacing);
//====================================================================================================
Vector3 bodyLoc = rootLoc;
//bodyLoc.y += 0.022482f;
bodyLoc.y += 0.022482f;
//====================================================================================================
Vector3 headLoc = __instance.BaseHeadOffsetAt(bodyFacing);
if (portrait || renderBody)
{
headLoc.x *= thingDef.raceAddonSettings.graphicSetting.drawSize[racomp.drawSize].headSize.x;
headLoc.z *= thingDef.raceAddonSettings.graphicSetting.drawSize[racomp.drawSize].headSize.y;
}
if (!portrait && flag1)
{
if (headFacing == Rot4.South)
{
headLoc += racomp.savedHeadData.def.headTargetingOffsets.south;
}
else if (headFacing == Rot4.East)
{
headLoc += racomp.savedHeadData.def.headTargetingOffsets.east;
}
else if (headFacing == Rot4.West)
{
headLoc += racomp.savedHeadData.def.headTargetingOffsets.west;
}
else
{
headLoc += racomp.savedHeadData.def.headTargetingOffsets.north;
}
}
headLoc = bodyLoc + (bodyQuat * headLoc);
//====================================================================================================
List <int> shell = new List <int>();
List <int> hat = new List <int>();
List <ApparelGraphicRecord> apparelGraphics = __instance.graphics.apparelGraphics;
for (int i = 0; i < apparelGraphics.Count; i++)
{
if (apparelGraphics[i].sourceApparel.def.apparel.LastLayer == ApparelLayerDefOf.Shell)
{
shell.Add(i);
}
if (apparelGraphics[i].sourceApparel.def.apparel.LastLayer == ApparelLayerDefOf.Overhead)
{
hat.Add(i);
}
}
//====================================================================================================
Vector3 drawLoc = new Vector3();
if (renderBody)
{
//Draw Body, Apparel
drawLoc = DrawLoc(bodyLoc, 0.0002f);
List <Material> list = __instance.graphics.MatsBodyBaseAt(bodyFacing, bodyDrawType);
for (int i = 0; i < list.Count; i++)
{
Material mat = OverrideMaterialIfNeeded(list[i], ___pawn, __instance.graphics);
GenDraw.DrawMeshNowOrLater(bodyMesh, drawLoc, bodyQuat, mat, portrait);
drawLoc.y += 0.0001f;
}
//Draw Shell
if (shell.Count() > 0)
{
drawLoc = DrawLoc(bodyLoc, 0.0009f);
foreach (int i in shell)
{
Material mat = apparelGraphics[i].graphic.MatAt(bodyFacing);
mat = OverrideMaterialIfNeeded(mat, ___pawn, __instance.graphics);
GenDraw.DrawMeshNowOrLater(bodyMesh, drawLoc, bodyQuat, mat, portrait);
}
}
//Draw Wound
drawLoc = DrawLoc(bodyLoc, 0.0020f);
if (bodyDrawType == RotDrawMode.Fresh)
{
___woundOverlays.RenderOverBody(drawLoc, bodyMesh, bodyQuat, portrait);
}
//Draw Body Addons
if (racomp.bodyAddonGraphicSets != null)
{
foreach (var set in racomp.bodyAddonGraphicSets)
{
if (set.draw)
{
drawLoc = bodyLoc;
ResolveAddonLoc(ref drawLoc, set.data.def, bodyFacing);
Material mat = set.MatAt(bodyFacing, bodyDrawType);
if (mat != null)
{
mat = OverrideMaterialIfNeeded(mat, ___pawn, __instance.graphics);
GenDraw.DrawMeshNowOrLater(bodyMesh, drawLoc, bodyQuat, mat, portrait);
}
}
}
}
}
if (__instance.graphics.headGraphic != null)
{
//Draw Head
Material headMat = __instance.graphics.HeadMatAt(headFacing, bodyDrawType, headStump);
if (headMat != null)
{
drawLoc = DrawLoc(headLoc, 0.0011f);
GenDraw.DrawMeshNowOrLater(headMesh, drawLoc, headQuat, headMat, portrait);
}
//Draw Hat or Mask
bool flag2 = false;
if (!portrait || !Prefs.HatsOnlyOnMap)
{
if (hat.Count() > 0 && racomp.drawHat)
{
foreach (int i in hat)
{
if (apparelGraphics[i].sourceApparel.def.apparel.hatRenderedFrontOfFace) //Mask
{
flag2 = true;
drawLoc = headFacing == Rot4.North ? DrawLoc(headLoc, -0.0001f) : DrawLoc(headLoc, 0.0017f);
}
else
{
drawLoc = DrawLoc(headLoc, 0.0015f); //Hat
}
Material mat = apparelGraphics[i].graphic.MatAt(headFacing);
mat = OverrideMaterialIfNeeded(mat, ___pawn, __instance.graphics);
GenDraw.DrawMeshNowOrLater(headMesh, drawLoc, headQuat, mat, portrait);
}
}
}
if (bodyDrawType != RotDrawMode.Dessicated && !headStump)
{
//Draw Face
if (racomp.upperFaceGraphicSet != null)
{
drawLoc = DrawLoc(headLoc, 0.0014f);
Material mat = OverrideMaterialIfNeeded(racomp.upperFaceGraphicSet.MatAt(headFacing, portrait), ___pawn, __instance.graphics);
GenDraw.DrawMeshNowOrLater(headMesh, drawLoc, headQuat, mat, portrait);
}
if (racomp.lowerFaceGraphicSet != null)
{
drawLoc = DrawLoc(headLoc, 0.0012f);
Material mat = OverrideMaterialIfNeeded(racomp.lowerFaceGraphicSet.MatAt(headFacing, portrait), ___pawn, __instance.graphics);
GenDraw.DrawMeshNowOrLater(headMesh, drawLoc, headQuat, mat, portrait);
}
//Draw Hair
if (flag2 || racomp.drawUpperHair)
{
drawLoc = DrawLoc(headLoc, 0.0013f);
Material mat = __instance.graphics.HairMatAt(headFacing);
mat = OverrideMaterialIfNeeded(mat, ___pawn, __instance.graphics);
GenDraw.DrawMeshNowOrLater(headMesh, drawLoc, headQuat, mat, portrait);
}
if (racomp.improvedHairGraphic != null)
{
if (flag2 || racomp.drawLowerHair)
{
if (___pawn.InBed() && ((___pawn.story.hairDef as ImprovedHairDef).drawnInBed) || renderBody)
{
drawLoc = DrawLoc(headLoc, 0.0001f);
Material mat = racomp.improvedHairGraphic.MatAt(headFacing);
mat = OverrideMaterialIfNeeded(mat, ___pawn, __instance.graphics);
GenDraw.DrawMeshNowOrLater(headMesh, drawLoc, headQuat, mat, portrait);
}
}
}
//Draw Head Addons
if (racomp.headAddonGraphicSets != null)
{
foreach (var set in racomp.headAddonGraphicSets)
{
if (set.draw)
{
drawLoc = headLoc;
ResolveAddonLoc(ref drawLoc, set.data.def, headFacing);
Material mat = set.MatAt(headFacing, bodyDrawType);
if (mat != null)
{
mat = OverrideMaterialIfNeeded(mat, ___pawn, __instance.graphics);
GenDraw.DrawMeshNowOrLater(headMesh, drawLoc, headQuat, mat, portrait);
}
}
}
}
}
}
if (!portrait)
{
drawLoc = DrawLoc(bodyLoc, 0.01f);
DrawEquipment(___pawn, racomp.equipmentMeshSet.MeshAt(bodyFacing), drawLoc);
//Draw Apparel Extras
if (___pawn.apparel != null)
{
List <Apparel> wornApparel = ___pawn.apparel.WornApparel;
for (int l = 0; l < wornApparel.Count; l++)
{
wornApparel[l].DrawWornExtras();
}
}
//Draw Overlays
drawLoc = DrawLoc(bodyLoc, 0.02f);
___statusOverlays.RenderStatusOverlays(drawLoc, bodyQuat, headMesh);
}
return(false);
}
return(true);
}
public static bool _RenderPawnInternal(PawnRenderer __instance, Vector3 rootLoc, Quaternion quat, bool renderBody, Rot4 bodyFacing, Rot4 headFacing, RotDrawMode bodyDrawType = 0, bool portrait = false)
{
Log.Message("Calling");
PawnRenderer renderer = __instance;
if (!renderer.graphics.AllResolved)
{
renderer.graphics.ResolveAllGraphics();
}
Mesh mesh = null;
Pawn pawn = (Pawn)HarmonyPatches.pawnInfo.GetValue(renderer);
if (pawn is AlienPawn && (pawn as AlienPawn).bodySet == null)
{
(pawn as AlienPawn).UpdateSets();
}
Corruption.CompPsyker compPsyker = pawn.TryGetComp <CompPsyker>();
List <HediffComp_DrawImplant> implantDrawers = HarmonyPatches.implantDrawers(pawn);
string patronName = "Emperor";
bool drawChaos = false;
if (compPsyker != null)
{
patronName = compPsyker.patronName;
// Log.Message("GettingComp: " + patronName);
if (patronName == "Khorne" || patronName == "Nurgle" || patronName == "Tzeentch" || patronName == "Undivided")
{
// Log.Message("drawChaos");
drawChaos = true;
}
}
if (renderBody || (pawn.InBed() && pawn.ageTracker.CurLifeStageIndex <= 1))
{
if (pawn.RaceProps.Humanlike)
{
if (pawn.ageTracker.CurLifeStageIndex == 2)
{
rootLoc.z -= 0.15f;
}
if (pawn.ageTracker.CurLifeStageIndex < 2 && pawn.InBed() && !portrait)
{
// Undo the offset for babies/toddlers in bed
Building_Bed building_bed = pawn.CurrentBed();
Vector3 offset = new Vector3(0, 0, 0.5f).RotatedBy(building_bed.Rotation.AsAngle);
rootLoc -= offset;
}
}
Vector3 vector = rootLoc;
vector.y += 0.005f;
if (bodyDrawType == RotDrawMode.Dessicated && !pawn.RaceProps.Humanlike && renderer.graphics.dessicatedGraphic != null && !portrait)
{
renderer.graphics.dessicatedGraphic.Draw(vector, bodyFacing, pawn);
}
else
{
bool humanlike = pawn.RaceProps.Humanlike;
if (humanlike)
{
mesh = ((pawn is AlienPawn) ? (pawn as AlienPawn).bodySet : MeshPool.humanlikeBodySet).MeshAt(bodyFacing);
}
else
{
mesh = renderer.graphics.nakedGraphic.MeshAt(bodyFacing);
}
List <Material> list = renderer.graphics.MatsBodyBaseAt(bodyFacing, bodyDrawType);
for (int i = 0; i < list.Count; i++)
{
Material damagedMat = renderer.graphics.flasher.GetDamagedMat(list[i]);
if (pawn.ageTracker.CurLifeStageIndex == 2 && pawn.RaceProps.Humanlike)
{
damagedMat.mainTextureScale = new Vector2(1, 1.3f);
damagedMat.mainTextureOffset = new Vector2(0, -0.2f);
if (bodyFacing == Rot4.West || bodyFacing == Rot4.East)
{
damagedMat.mainTextureOffset = new Vector2(-0.015f, -0.2f);
}
}
GenDraw.DrawMeshNowOrLater(mesh, vector, quat, damagedMat, portrait);
vector.y += 0.003f;
if (i == 0)
{
if (drawChaos)
{
Material markMat = (Corruption.AfflictionDrawerUtility.GetBodyOverlay(pawn.story.bodyType, patronName).MatAt(bodyFacing));
if (pawn.ageTracker.CurLifeStageIndex == 2 && pawn.RaceProps.Humanlike)
{
markMat.mainTextureScale = new Vector2(1, 1.3f);
markMat.mainTextureOffset = new Vector2(0, -0.2f);
if (bodyFacing == Rot4.West || bodyFacing == Rot4.East)
{
markMat.mainTextureOffset = new Vector2(-0.015f, -0.2f);
}
}
GenDraw.DrawMeshNowOrLater(mesh, vector, quat, markMat, portrait);
vector.y += 0.003f;
}
}
}
if (bodyDrawType == 0)
{
Vector3 vector2 = rootLoc;
vector2.y += 0.02f;
((PawnWoundDrawer)HarmonyPatches.woundInfo.GetValue(renderer)).RenderOverBody(vector2, mesh, quat, portrait);
}
}
}
Vector3 vector3 = rootLoc;
Vector3 vector4 = rootLoc;
if (bodyFacing != Rot4.North)
{
vector4.y += 0.03f;
vector3.y += 0.0249999985f;
}
else
{
vector4.y += 0.0249999985f;
vector3.y += 0.03f;
}
if (renderer.graphics.headGraphic != null && pawn.ageTracker.CurLifeStageIndex >= 1)
{
Vector3 vector5 = quat * renderer.BaseHeadOffsetAt(headFacing);
Mesh mesh2 = ((pawn is AlienPawn) ? (pawn as AlienPawn).headSet : MeshPool.humanlikeHeadSet).MeshAt(headFacing);
Material material = renderer.graphics.HeadMatAt(headFacing, bodyDrawType);
GenDraw.DrawMeshNowOrLater(mesh2, vector4 + vector5, quat, material, portrait);
if (drawChaos)
{
Material headMarkMat = (AfflictionDrawerUtility.GetHeadGraphic(pawn, patronName).MatAt(bodyFacing));
vector5.y += 0.005f;
GenDraw.DrawMeshNowOrLater(mesh2, vector4 + vector5, quat, headMarkMat, portrait);
}
Vector3 vector6 = rootLoc + vector5;
vector6.y += 0.035f;
bool flag7 = false;
if (pawn.ageTracker.CurLifeStageIndex >= 2)
{
Mesh mesh3 = HarmonyPatches.HairMeshSet(pawn).MeshAt(headFacing);
List <ApparelGraphicRecord> apparelGraphics = renderer.graphics.apparelGraphics;
for (int j = 0; j < apparelGraphics.Count; j++)
{
if (apparelGraphics[j].sourceApparel.def.apparel.LastLayer == ApparelLayer.Overhead)
{
if ((!pawn.story.hairDef.hairTags.Contains("DrawUnderHat") && !pawn.story.hairDef.hairTags.Contains("Beard")) || pawn.apparel.BodyPartGroupIsCovered(BodyPartGroupDefOf.FullHead))
{
flag7 = true; // flag=true stops the hair from being drawn
}
Material material2 = apparelGraphics[j].graphic.MatAt(bodyFacing, null);
material2 = renderer.graphics.flasher.GetDamagedMat(material2);
if (pawn.ageTracker.CurLifeStageIndex == 2)
{
material2.mainTextureOffset = new Vector2(0, 0.018f);
material2.mainTexture.wrapMode = TextureWrapMode.Clamp;
}
GenDraw.DrawMeshNowOrLater(mesh3, vector6, quat, material2, portrait);
Material detailMat;
if (ApparelDetailDrawer.GetDetailGraphic(pawn, apparelGraphics[j].sourceApparel, bodyFacing, out detailMat))
{
Vector3 vectorDet = vector6;
vectorDet.y += 0.005f;
GenDraw.DrawMeshNowOrLater(mesh3, vectorDet, quat, detailMat, portrait);
}
}
}
}
if (!flag7 && bodyDrawType != RotDrawMode.Dessicated)
{
Mesh mesh4 = HarmonyPatches.HairMeshSet(pawn).MeshAt(headFacing);
Material material3 = renderer.graphics.HairMatAt(headFacing);
// Hopefully stops graphic issues from modifying texture offset/scale
material3.mainTexture.wrapMode = TextureWrapMode.Clamp;
// Scale down the child hair to fit the head
if (pawn.ageTracker.CurLifeStageIndex <= 2)
{
material3.mainTextureScale = new Vector2(1.13f, 1.13f);
material3.mainTextureOffset = new Vector2(-0.065f, -0.045f);
}
// Scale down the toddler hair to fit the head
if (pawn.ageTracker.CurLifeStageIndex == 1)
{
// mat2.mainTextureScale = new Vector2 (1.25f, 1.25f);
material3.mainTextureOffset = new Vector2(-0.07f, 0.12f);
}
GenDraw.DrawMeshNowOrLater(mesh4, vector6, quat, material3, portrait);
}
}
if (renderBody)
{
for (int k = 0; k < renderer.graphics.apparelGraphics.Count; k++)
{
ApparelGraphicRecord apparelGraphicRecord = renderer.graphics.apparelGraphics[k];
if (apparelGraphicRecord.sourceApparel.def.apparel.LastLayer == ApparelLayer.Shell)
{
Material material4 = apparelGraphicRecord.graphic.MatAt(bodyFacing, null);
material4 = renderer.graphics.flasher.GetDamagedMat(material4);
if (pawn.ageTracker.CurLifeStageIndex == 2)
{
material4.mainTextureScale = new Vector2(1.00f, 1.22f);
material4.mainTextureOffset = new Vector2(0, -0.1f);
}
GenDraw.DrawMeshNowOrLater(mesh, vector3, quat, material4, portrait);
}
Material pauldronMat;
if (CompPauldronDrawer.ShouldDrawPauldron(pawn, renderer.graphics.apparelGraphics[k].sourceApparel, bodyFacing, out pauldronMat))
{
if (pawn.ageTracker.CurLifeStageIndex == 2)
{
pauldronMat.mainTextureScale = new Vector2(1.00f, 1.22f);
pauldronMat.mainTextureOffset = new Vector2(0, -0.1f);
}
vector3.y += 0.005f;
GenDraw.DrawMeshNowOrLater(mesh, vector3, quat, pauldronMat, portrait);
}
}
if (!pawn.Dead)
{
for (int l = 0; l < pawn.health.hediffSet.hediffs.Count; l++)
{
HediffComp_DrawImplant drawer;
if ((drawer = pawn.health.hediffSet.hediffs[l].TryGetComp <HediffComp_DrawImplant>()) != null)
{
if (drawer.implantDrawProps.implantDrawerType != ImplantDrawerType.Head)
{
vector3.y += 0.005f;
if (bodyFacing == Rot4.South && drawer.implantDrawProps.implantDrawerType == ImplantDrawerType.Backpack)
{
vector3.y -= 0.3f;
}
Material implantMat = drawer.ImplantMaterial(pawn, bodyFacing);
GenDraw.DrawMeshNowOrLater(mesh, vector3, quat, implantMat, portrait);
vector3.y += 0.005f;
}
}
}
}
}
if (!portrait && pawn.RaceProps.Animal && pawn.inventory != null && pawn.inventory.innerContainer.Count() > 0)
{
Graphics.DrawMesh(mesh, vector3, quat, renderer.graphics.packGraphic.MatAt(pawn.Rotation, null), 0);
}
if (!portrait)
{
HarmonyPatches.equipInfo.Invoke(renderer, new object[]
{
rootLoc
});
if (pawn.apparel != null)
{
List <Apparel> wornApparel = pawn.apparel.WornApparel;
for (int l = 0; l < wornApparel.Count; l++)
{
wornApparel[l].DrawWornExtras();
}
}
Vector3 vector7 = rootLoc;
vector7.y += 0.0449999981f;
((PawnHeadOverlays)HarmonyPatches.statusInfo.GetValue(renderer)).RenderStatusOverlays(vector7, quat, ((pawn is AlienPawn) ? (pawn as AlienPawn).headSet : MeshPool.humanlikeHeadSet).MeshAt(headFacing));
}
return(false);
}
public virtual void DrawInnerThing(Pawn pawn, Vector3 rootLoc, float angle, bool renderBody, Rot4 bodyFacing, Rot4 headFacing, RotDrawMode bodyDrawType, bool portrait, bool headStump)
{
PawnGraphicSet graphics = pawn.Drawer.renderer.graphics;
PawnRenderer renderer = pawn.Drawer.renderer;
if (!graphics.AllResolved)
{
graphics.ResolveAllGraphics();
}
Quaternion quaternion = Quaternion.AngleAxis(angle, Vector3.up);
Mesh mesh = null;
if (renderBody)
{
Vector3 loc = rootLoc;
loc.y += 0.0078125f;
if (bodyDrawType == RotDrawMode.Dessicated && !pawn.RaceProps.Humanlike && graphics.dessicatedGraphic != null && !portrait)
{
graphics.dessicatedGraphic.Draw(loc, bodyFacing, pawn, angle);
}
else
{
if (pawn.RaceProps.Humanlike)
{
mesh = MeshPool.humanlikeBodySet.MeshAt(bodyFacing);
}
else
{
mesh = graphics.nakedGraphic.MeshAt(bodyFacing);
}
List <Material> list = graphics.MatsBodyBaseAt(bodyFacing, bodyDrawType);
for (int i = 0; i < list.Count; i++)
{
Material damagedMat = graphics.flasher.GetDamagedMat(list[i]);
GenDraw.DrawMeshNowOrLater(mesh, loc, quaternion, damagedMat, portrait);
loc.y += 0.00390625f;
}
}
}
Vector3 vector = rootLoc;
Vector3 a = rootLoc;
if (bodyFacing != Rot4.North)
{
a.y += 0.02734375f;
vector.y += 0.0234375f;
}
else
{
a.y += 0.0234375f;
vector.y += 0.02734375f;
}
if (graphics.headGraphic != null)
{
Vector3 b = quaternion * renderer.BaseHeadOffsetAt(headFacing);
Material material = graphics.HeadMatAt(headFacing, bodyDrawType, headStump);
if (material != null)
{
Mesh mesh2 = MeshPool.humanlikeHeadSet.MeshAt(headFacing);
GenDraw.DrawMeshNowOrLater(mesh2, a + b, quaternion, material, portrait);
}
Vector3 loc2 = rootLoc + b;
loc2.y += 0.03125f;
bool flag = false;
if (!portrait || !Prefs.HatsOnlyOnMap)
{
Mesh mesh3 = graphics.HairMeshSet.MeshAt(headFacing);
List <ApparelGraphicRecord> apparelGraphics = graphics.apparelGraphics;
for (int j = 0; j < apparelGraphics.Count; j++)
{
if (apparelGraphics[j].sourceApparel.def.apparel.LastLayer == ApparelLayerDefOf.Overhead)
{
if (!apparelGraphics[j].sourceApparel.def.apparel.hatRenderedFrontOfFace)
{
flag = true;
Material material2 = apparelGraphics[j].graphic.MatAt(bodyFacing, null);
material2 = graphics.flasher.GetDamagedMat(material2);
GenDraw.DrawMeshNowOrLater(mesh3, loc2, quaternion, material2, portrait);
}
else
{
Material material3 = apparelGraphics[j].graphic.MatAt(bodyFacing, null);
material3 = graphics.flasher.GetDamagedMat(material3);
Vector3 loc3 = rootLoc + b;
loc3.y += ((!(bodyFacing == Rot4.North)) ? 0.03515625f : 0.00390625f);
GenDraw.DrawMeshNowOrLater(mesh3, loc3, quaternion, material3, portrait);
}
}
}
}
if (!flag && bodyDrawType != RotDrawMode.Dessicated && !headStump)
{
Mesh mesh4 = graphics.HairMeshSet.MeshAt(headFacing);
Material mat = graphics.HairMatAt(headFacing);
GenDraw.DrawMeshNowOrLater(mesh4, loc2, quaternion, mat, portrait);
}
}
if (renderBody)
{
for (int k = 0; k < graphics.apparelGraphics.Count; k++)
{
ApparelGraphicRecord apparelGraphicRecord = graphics.apparelGraphics[k];
if (apparelGraphicRecord.sourceApparel.def.apparel.LastLayer == ApparelLayerDefOf.Shell)
{
Material material4 = apparelGraphicRecord.graphic.MatAt(bodyFacing, null);
material4 = graphics.flasher.GetDamagedMat(material4);
GenDraw.DrawMeshNowOrLater(mesh, vector, quaternion, material4, portrait);
}
}
}
if (!portrait && pawn.RaceProps.Animal && pawn.inventory != null && pawn.inventory.innerContainer.Count > 0 && graphics.packGraphic != null)
{
Graphics.DrawMesh(mesh, vector, quaternion, graphics.packGraphic.MatAt(bodyFacing, null), 0);
}
if (!portrait)
{
if (pawn.apparel != null)
{
List <Apparel> wornApparel = pawn.apparel.WornApparel;
for (int l = 0; l < wornApparel.Count; l++)
{
wornApparel[l].DrawWornExtras();
}
}
Vector3 bodyLoc = rootLoc;
bodyLoc.y += 0.04296875f;
}
}
static void DrawMark(HediffComp_HunterMark comp, PawnRenderer __instance, Vector3 rootLoc, float angle, bool renderBody, Rot4 bodyFacing, Rot4 headFacing, RotDrawMode bodyDrawType, bool portrait, bool headStump)
{
Pawn pawn = Traverse.Create(__instance).Field("pawn").GetValue <Pawn>();
bool selected = Find.Selector.SelectedObjects.Contains(pawn) && Prefs.DevMode;
Rot4 rot = bodyFacing;
Vector3 vector3 = pawn.RaceProps.Humanlike ? __instance.BaseHeadOffsetAt(headFacing) : new Vector3();
Vector3 s = new Vector3(pawn.BodySize * 1.75f, pawn.BodySize * 1.75f, pawn.BodySize * 1.75f);
bool hasdefext = pawn.def.HasModExtension <MarkOffsetDefExtension>();
if (hasdefext)
{
MarkOffsetDefExtension defExtension = pawn.def.GetModExtension <MarkOffsetDefExtension>() ?? ThingDefOf.Human.GetModExtension <MarkOffsetDefExtension>();
if (defExtension != null)
{
GetAltitudeOffset(pawn, defExtension, comp.parent, rot, out float X, out float Y, out float Z, out float DsX, out float DsZ, out float ang);
vector3.x += X;
vector3.y += Y;
vector3.z += Z;
angle += ang;
s.x = DsX;
s.z = DsZ;
}
}
else
{
if (pawn.RaceProps.Humanlike)
{
vector3.z += 0.25f;
}
}
if (pawn.RaceProps.Humanlike)
{
vector3.x += 0.01f;
vector3.z += -0.35f;
}
Quaternion quaternion = Quaternion.AngleAxis(angle, Vector3.up);
Vector3 b = quaternion * vector3;
Vector3 vector = rootLoc;
Vector3 a = rootLoc;
if (bodyFacing != Rot4.North)
{
a.y += 0.02734375f;
vector.y += 0.0234375f;
}
else
{
a.y += 0.0234375f;
vector.y += 0.02734375f;
}
Vector3 loc2 = rootLoc + b;
loc2.y += 0.03105f;
bool flag = false;
if (!flag && bodyDrawType != RotDrawMode.Dessicated)
{
// Mesh mesh4 = __instance.graphics.HairMeshSet.MeshAt(headFacing);
Material mat = comp.ImplantMaterial(pawn, pawn.RaceProps.Humanlike ? headFacing : bodyFacing);
// GenDraw.DrawMeshNowOrLater(headFacing == Rot4.West ? MeshPool.plane10Flip : MeshPool.plane10, loc2, quaternion, mat, true);
Matrix4x4 matrix = default(Matrix4x4);
matrix.SetTRS(loc2, quaternion, s);
Graphics.DrawMesh((pawn.RaceProps.Humanlike ? headFacing : bodyFacing) == Rot4.West ? MeshPool.plane10Flip : MeshPool.plane10, matrix, mat, 0);
}
}
// RenderPawnInternal detour
internal static void _RenderPawnInternal(this PawnRenderer _this, Vector3 rootLoc, Quaternion quat, bool renderBody, Rot4 bodyFacing, Rot4 headFacing, RotDrawMode bodyDrawType = RotDrawMode.Fresh, bool portrait = false, bool headStump = false)
{
// Allows accessing private fields from the original class
Pawn _pawn = _pawnRPI(_this);
if (!_this.graphics.AllResolved)
{
_this.graphics.ResolveAllGraphics();
}
Mesh mesh = null;
// Make sure to render toddlers and babies in bed
if (renderBody || (_pawn.InBed() && _pawn.ageTracker.CurLifeStageIndex <= 1))
{
if (_pawn.RaceProps.Humanlike)
{
if (_pawn.ageTracker.CurLifeStageIndex == 2)
{
rootLoc.z -= 0.15f;
}
if (_pawn.ageTracker.CurLifeStageIndex < 2 && _pawn.InBed() && !portrait)
{
// Undo the offset for babies/toddlers in bed
Building_Bed building_bed = _pawn.CurrentBed();
Vector3 offset = new Vector3(0, 0, 0.5f).RotatedBy(building_bed.Rotation.AsAngle);
rootLoc -= offset;
}
}
Vector3 loc = rootLoc;
loc.y += 0.0046875f;
if (bodyDrawType == RotDrawMode.Dessicated && !_pawn.RaceProps.Humanlike && _this.graphics.dessicatedGraphic != null && !portrait)
{
_this.graphics.dessicatedGraphic.Draw(loc, bodyFacing, _pawn);
}
else
{
if (_pawn.RaceProps.Humanlike)
{
mesh = MeshPool.humanlikeBodySet.MeshAt(bodyFacing);
}
else
{
mesh = _this.graphics.nakedGraphic.MeshAt(bodyFacing);
}
// Draw body and apparel
List <Material> list = _this.graphics.MatsBodyBaseAt(bodyFacing, bodyDrawType);
for (int i = 0; i < list.Count; i++)
{
Material damagedMat = _this.graphics.flasher.GetDamagedMat(list [i]);
// Scale apparel graphics to fit child body
if (_pawn.ageTracker.CurLifeStageIndex == 2 && _pawn.RaceProps.Humanlike)
{
damagedMat.mainTextureScale = new Vector2(1, 1.3f);
damagedMat.mainTextureOffset = new Vector2(0, -0.2f);
if (bodyFacing == Rot4.West || bodyFacing == Rot4.East)
{
damagedMat.mainTextureOffset = new Vector2(-0.015f, -0.2f);
}
}
GenDraw.DrawMeshNowOrLater(mesh, loc, quat, damagedMat, portrait);
loc.y += 0.0046875f;
}
if (bodyDrawType == RotDrawMode.Fresh)
{
Vector3 drawLoc = rootLoc;
drawLoc.y += 0.01875f;
PawnWoundDrawer _woundOverlays = _pwdRPI(_this);
_woundOverlays.RenderOverBody(drawLoc, mesh, quat, portrait);
}
}
}
Vector3 vector = rootLoc;
Vector3 a = rootLoc;
if (bodyFacing != Rot4.North)
{
a.y += 0.028125f;
vector.y += 0.0234375f;
}
else
{
a.y += 0.0234375f;
vector.y += 0.028125f;
}
// Does our pawn have a visible head?
// Only draw head if child or older
if (_this.graphics.headGraphic != null && _pawn.ageTracker.CurLifeStageIndex >= 1)
{
Vector3 b = quat * _this.BaseHeadOffsetAt(headFacing);
// Hair or helmet location
Vector3 loc2 = rootLoc + b;
// Raise it up in the stack
loc2.y += 0.0328125f;
bool flag = false;
// Is the pawn a child or older?
if (_pawn.ageTracker.CurLifeStageIndex >= 2)
{
Mesh mesh2 = MeshPool.humanlikeHeadSet.MeshAt(headFacing);
Material mat = _this.graphics.HeadMatAt(headFacing, bodyDrawType);
// Draw the pawn's head
GenDraw.DrawMeshNowOrLater(mesh2, a + b, quat, mat, portrait);
// Find the mesh we want to use for the current direction it's facing
Mesh mesh3 = _this.graphics.HairMeshSet.MeshAt(headFacing);
// Populate a list of all apparel
if (!portrait || !Prefs.HatsOnlyOnMap)
{
List <ApparelGraphicRecord> apparelGraphics = _this.graphics.apparelGraphics;
for (int j = 0; j < apparelGraphics.Count; j++)
{
// If the apparel is on the head, let's draw it!
if (apparelGraphics [j].sourceApparel.def.apparel.LastLayer == ApparelLayer.Overhead)
{
if ((!_pawn.story.hairDef.hairTags.Contains("DrawUnderHat") && !_pawn.story.hairDef.hairTags.Contains("Beard")) || _pawn.apparel.BodyPartGroupIsCovered(BodyPartGroupDefOf.FullHead))
{
flag = true; // flag=true stops the hair from being drawn
}
Material material = apparelGraphics [j].graphic.MatAt(bodyFacing, null);
material = _this.graphics.flasher.GetDamagedMat(material);
if (_pawn.ageTracker.CurLifeStageIndex == 2)
{
material.mainTextureOffset = new Vector2(0, 0.018f);
material.mainTexture.wrapMode = TextureWrapMode.Clamp;
}
GenDraw.DrawMeshNowOrLater(mesh3, loc2 + new Vector3(0, 0.035f, 0), quat, material, portrait);
}
}
}
}
// Otherwise let's draw the hair instead
if (!flag && bodyDrawType != RotDrawMode.Dessicated && _pawn.ageTracker.AgeBiologicalYears >= 2 && !headStump)
{
Mesh mesh4 = _this.graphics.HairMeshSet.MeshAt(headFacing);
Material mat2 = _this.graphics.HairMatAt(headFacing);
// Hopefully stops graphic issues from modifying texture offset/scale
mat2.mainTexture.wrapMode = TextureWrapMode.Clamp;
// Scale down the child hair to fit the head
if (_pawn.ageTracker.CurLifeStageIndex <= 2)
{
mat2.mainTextureScale = new Vector2(1.13f, 1.13f);
mat2.mainTextureOffset = new Vector2(-0.065f, -0.045f);
}
// Scale down the toddler hair to fit the head
if (_pawn.ageTracker.CurLifeStageIndex == 1)
{
// mat2.mainTextureScale = new Vector2 (1.25f, 1.25f);
mat2.mainTextureOffset = new Vector2(-0.07f, 0.12f);
}
GenDraw.DrawMeshNowOrLater(mesh4, loc2, quat, mat2, portrait);
}
}
if (renderBody)
{
for (int k = 0; k < _this.graphics.apparelGraphics.Count; k++)
{
ApparelGraphicRecord apparelGraphicRecord = _this.graphics.apparelGraphics [k];
// Draw the uppermost piece of apparel
if (apparelGraphicRecord.sourceApparel.def.apparel.LastLayer == ApparelLayer.Shell)
{
Material material2 = apparelGraphicRecord.graphic.MatAt(bodyFacing, null);
material2 = _this.graphics.flasher.GetDamagedMat(material2);
// Draw apparel differently for children
if (_pawn.ageTracker.CurLifeStageIndex == 2)
{
material2.mainTextureScale = new Vector2(1.00f, 1.22f);
material2.mainTextureOffset = new Vector2(0, -0.1f);
}
GenDraw.DrawMeshNowOrLater(mesh, vector, quat, material2, portrait);
}
}
}
if (!portrait && _pawn.RaceProps.Animal && _pawn.inventory != null && _pawn.inventory.innerContainer.Count > 0)
{
Graphics.DrawMesh(mesh, vector, quat, _this.graphics.packGraphic.MatAt(_pawn.Rotation, null), 0);
}
if (!portrait)
{
//_this.DrawEquipment (rootLoc);
MethodInfo drawEquip = _this.GetType().GetMethod("DrawEquipment", BindingFlags.NonPublic | BindingFlags.Instance);
drawEquip.Invoke(_this, new object[] { rootLoc });
if (_pawn.apparel != null)
{
List <Apparel> wornApparel = _pawn.apparel.WornApparel;
for (int l = 0; l < wornApparel.Count; l++)
{
wornApparel [l].DrawWornExtras();
}
}
Vector3 bodyLoc = rootLoc;
bodyLoc.y += 0.0421875f;
var _statusOverlays = typeof(PawnRenderer).GetField("statusOverlays", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(_this);
MethodInfo rso = typeof(PawnHeadOverlays).GetMethod("RenderStatusOverlays");
rso.Invoke(_statusOverlays, new object[] { bodyLoc, quat, MeshPool.humanlikeHeadSet.MeshAt(headFacing) });
//_statusOverlays.RenderStatusOverlays (bodyLoc, quat, MeshPool.humanlikeHeadSet.MeshAt (headFacing));
}
}
public static void Listener(ref PawnRenderer __instance, Vector3 rootLoc, float angle, bool renderBody, Rot4 bodyFacing, Rot4 headFacing, RotDrawMode bodyDrawType,
bool portrait, bool headStump, bool invisible, Pawn ___pawn)
{
try
{
var state = false;
CompAndroidState cas = null;
if (___pawn != null)
{
cas = ___pawn.TryGetComp <CompAndroidState>();
}
if (___pawn != null &&
(___pawn.def.defName == Utils.TX2 ||
___pawn.def.defName == Utils.TX2I ||
___pawn.def.defName == Utils.TX2KI ||
___pawn.def.defName == Utils.TX3I ||
___pawn.def.defName == Utils.TX4I ||
___pawn.def.defName == Utils.TX2K && (cas.TXHurtedHeadSet || cas.TXHurtedHeadSet2) ||
___pawn.def.defName == Utils.TX3 && (cas.TXHurtedHeadSet || cas.TXHurtedHeadSet2) ||
___pawn.def.defName == Utils.TX4 && (cas.TXHurtedHeadSet || cas.TXHurtedHeadSet2)) &&
!___pawn.Dead && !headStump)
{
if (!portrait)
{
var jobs = ___pawn.jobs;
if (jobs?.curDriver != null)
{
state = !___pawn.jobs.curDriver.asleep;
}
}
else
{
state = true;
}
}
if (!state)
{
return;
}
var quaternion = Quaternion.AngleAxis(angle, Vector3.up);
var a = rootLoc;
if (bodyFacing != Rot4.North)
{
a.y += 0.0281250011f;
rootLoc.y += 0.0234375f;
}
else
{
a.y += 0.0234375f;
rootLoc.y += 0.0281250011f;
}
var b = quaternion * __instance.BaseHeadOffsetAt(headFacing);
var loc = a + b + new Vector3(0f, 0.01f, 0f);
if (headFacing == Rot4.North)
{
return;
}
var mesh = MeshPool.humanlikeHeadSet.MeshAt(headFacing);
var isHorizontal = headFacing.IsHorizontal;
var type = 1;
if (cas.TXHurtedHeadSet)
{
type = 2;
}
else if (cas.TXHurtedHeadSet2 || ___pawn.def.defName == Utils.TX2I || ___pawn.def.defName == Utils.TX2KI || ___pawn.def.defName == Utils.TX3I ||
___pawn.def.defName == Utils.TX4I)
{
type = 3;
}
var color = new Color(0.9450f, 0.76862f, 0.05882f);
if (___pawn.def.defName == Utils.TX3 || ___pawn.def.defName == Utils.TX4 || ___pawn.def.defName == Utils.TX3I || ___pawn.def.defName == Utils.TX4I)
{
color = new Color(0f, 0.972549f, 0.972549f);
}
if (___pawn.Drafted || ___pawn.Faction != null && ___pawn.Faction.HostileTo(Faction.OfPlayer) || ___pawn.def.defName == Utils.TX2K ||
___pawn.def.defName == Utils.TX2KI)
{
color = new Color(0.75f, 0f, 0f, 1f);
}
var gender = "M";
if (___pawn.gender == Gender.Female)
{
gender = "F";
}
GenDraw.DrawMeshNowOrLater(mesh, loc, quaternion,
isHorizontal ? Tex.getEyeGlowEffect(color, gender, type, 0).MatSingle : Tex.getEyeGlowEffect(color, gender, type, 1).MatSingle, portrait);
}
catch (Exception e)
{
Log.Message("[ATPP] PawnRenderer.RenderPawnInternal " + e.Message + " " + e.StackTrace);
}
}
public static void Listener(ref PawnRenderer __instance, Vector3 rootLoc, float angle, bool renderBody, Rot4 bodyFacing, Rot4 headFacing, RotDrawMode bodyDrawType, bool portrait, bool headStump, bool invisible, Pawn ___pawn)
{
try
{
bool state = false;
CompAndroidState cas = null;
if (___pawn != null)
{
cas = ___pawn.TryGetComp <CompAndroidState>();
}
if (___pawn != null &&
(___pawn.def.defName == Utils.TX2 ||
___pawn.def.defName == Utils.TX2I ||
___pawn.def.defName == Utils.TX2KI ||
___pawn.def.defName == Utils.TX3I ||
___pawn.def.defName == Utils.TX4I ||
(___pawn.def.defName == Utils.TX2K && (cas.TXHurtedHeadSet || cas.TXHurtedHeadSet2)) ||
(___pawn.def.defName == Utils.TX3 && (cas.TXHurtedHeadSet || cas.TXHurtedHeadSet2)) ||
(___pawn.def.defName == Utils.TX4 && (cas.TXHurtedHeadSet || cas.TXHurtedHeadSet2))) &&
!___pawn.Dead && !headStump)
{
if (!portrait)
{
if (___pawn != null)
{
Pawn_JobTracker jobs = ___pawn.jobs;
if ((((jobs != null) ? jobs.curDriver : null) != null))
{
state = !___pawn.jobs.curDriver.asleep;
}
}
}
else
{
state = portrait;
}
}
if (state)
{
Quaternion quaternion = Quaternion.AngleAxis(angle, Vector3.up);
Vector3 a = rootLoc;
if (bodyFacing != Rot4.North)
{
a.y += 0.0281250011f;
rootLoc.y += 0.0234375f;
}
else
{
a.y += 0.0234375f;
rootLoc.y += 0.0281250011f;
}
Vector3 b = quaternion * __instance.BaseHeadOffsetAt(headFacing);
Vector3 loc = a + b + new Vector3(0f, 0.01f, 0f);
if (headFacing != Rot4.North)
{
Mesh mesh = MeshPool.humanlikeHeadSet.MeshAt(headFacing);
bool isHorizontal = headFacing.IsHorizontal;
int type = 1;
if (cas.TXHurtedHeadSet)
{
type = 2;
}
else if (cas.TXHurtedHeadSet2 || ___pawn.def.defName == Utils.TX2I || ___pawn.def.defName == Utils.TX2KI || ___pawn.def.defName == Utils.TX3I || ___pawn.def.defName == Utils.TX4I)
{
type = 3;
}
//Couleur yeux standard TX2
Color color = new Color(0.9450f, 0.76862f, 0.05882f);
//Couleur yeux TX3/TX4 standard (bleu cyan)
if (___pawn.def.defName == Utils.TX3 || ___pawn.def.defName == Utils.TX4 || ___pawn.def.defName == Utils.TX3I || ___pawn.def.defName == Utils.TX4I)
{
color = new Color(0f, 0.972549f, 0.972549f);
}
// yeux rouges si drafté OU ennemis OU TX2K
if (___pawn.Drafted || (___pawn.Faction != null && ___pawn.Faction.HostileTo(Faction.OfPlayer)) || ___pawn.def.defName == Utils.TX2K || ___pawn.def.defName == Utils.TX2KI)
{
color = new Color(0.75f, 0f, 0f, 1f);
}
string gender = "M";
if (___pawn.gender == Gender.Female)
{
gender = "F";
}
if (isHorizontal)
{
GenDraw.DrawMeshNowOrLater(mesh, loc, quaternion, Tex.getEyeGlowEffect(color, gender, type, 0).MatSingle, portrait);
}
else
{
GenDraw.DrawMeshNowOrLater(mesh, loc, quaternion, Tex.getEyeGlowEffect(color, gender, type, 1).MatSingle, portrait);
}
}
}
}
catch (Exception e)
{
Log.Message("[ATPP] PawnRenderer.RenderPawnInternal " + e.Message + " " + e.StackTrace);
}
}
private static void RenderPawnInternal(PawnRenderer __instance, Vector3 rootLoc, Quaternion quat, bool renderBody, Rot4 bodyFacing, Rot4 headFacing, RotDrawMode bodyDrawType = RotDrawMode.Fresh, bool portrait = false)
{
Pawn pawn = Traverse.Create(__instance).Field("pawn").GetValue <Pawn>();
if (!pawn.def.race.Humanlike)
{
return;
}
Corruption.CompPsyker compPsyker = pawn.TryGetComp <CompPsyker>();
List <HediffComp_DrawImplant> implantDrawers = HarmonyPatches.implantDrawers(pawn);
string patronName = "Emperor";
bool drawChaos = false;
if (compPsyker != null)
{
patronName = compPsyker.patronName;
// Log.Message("GettingComp: " + patronName);
if (patronName == "Khorne" || patronName == "Nurgle" || patronName == "Tzeentch" || patronName == "Undivided")
{
// Log.Message("drawChaos");
drawChaos = true;
}
}
if (!__instance.graphics.AllResolved)
{
__instance.graphics.ResolveAllGraphics();
}
Mesh mesh = null;
if (renderBody)
{
Vector3 loc = rootLoc;
loc.y += 0.005f;
if (bodyDrawType == RotDrawMode.Dessicated && !pawn.RaceProps.Humanlike && __instance.graphics.dessicatedGraphic != null && !portrait)
{
__instance.graphics.dessicatedGraphic.Draw(loc, bodyFacing, pawn);
}
else
{
ThingDef_AlienRace alienDef = pawn.def as ThingDef_AlienRace;
if (alienDef != null)
{
Mesh mesh2;
if (bodyDrawType == RotDrawMode.Rotting)
{
if (__instance.graphics.dessicatedGraphic.ShouldDrawRotated)
{
mesh2 = MeshPool.GridPlane(portrait ? alienDef.alienRace.generalSettings.alienPartGenerator.CustomPortraitDrawSize : alienDef.alienRace.generalSettings.alienPartGenerator.CustomDrawSize);
}
else
{
Vector2 size = portrait ? alienDef.alienRace.generalSettings.alienPartGenerator.CustomPortraitDrawSize : alienDef.alienRace.generalSettings.alienPartGenerator.CustomDrawSize;
if (bodyFacing.IsHorizontal)
{
size = size.Rotated();
}
if (bodyFacing == Rot4.West && (__instance.graphics.dessicatedGraphic.data == null || __instance.graphics.dessicatedGraphic.data.allowFlip))
{
mesh = MeshPool.GridPlaneFlip(size);
}
mesh = MeshPool.GridPlane(size);
}
}
else
{
mesh = (portrait ? alienDef.alienRace.generalSettings.alienPartGenerator.bodyPortraitSet.MeshAt(bodyFacing) : alienDef.alienRace.generalSettings.alienPartGenerator.bodySet.MeshAt(bodyFacing));
}
}
else
{
if (pawn.RaceProps.Humanlike)
{
mesh = MeshPool.humanlikeBodySet.MeshAt(bodyFacing);
}
else
{
mesh = __instance.graphics.nakedGraphic.MeshAt(bodyFacing);
}
}
List <Material> list = __instance.graphics.MatsBodyBaseAt(bodyFacing, bodyDrawType);
for (int i = 0; i < list.Count; i++)
{
// Material damagedMat = __instance.graphics.flasher.GetDamagedMat(list[i]);
// GenDraw.DrawMeshNowOrLater(mesh, loc, quat, damagedMat, portrait);
loc.y += 0.005f;
if (i == 0)
{
if (drawChaos)
{
Material markMat = (Corruption.AfflictionDrawerUtility.GetBodyOverlay(pawn.story.bodyType, patronName).MatAt(bodyFacing));
if (pawn.ageTracker.CurLifeStageIndex == 2 && pawn.RaceProps.Humanlike)
{
markMat.mainTextureScale = new Vector2(1, 1.3f);
markMat.mainTextureOffset = new Vector2(0, -0.2f);
if (bodyFacing == Rot4.West || bodyFacing == Rot4.East)
{
markMat.mainTextureOffset = new Vector2(-0.015f, -0.2f);
}
}
GenDraw.DrawMeshNowOrLater(mesh, loc, quat, markMat, portrait);
loc.y += 0.005f;
}
}
if (bodyDrawType == RotDrawMode.Fresh)
{
Vector3 drawLoc = rootLoc;
drawLoc.y += 0.02f;
// Traverse.Create(__instance).Field("woundOverlays").GetValue<PawnWoundDrawer>().RenderOverBody(drawLoc, mesh, quat, portrait);
}
}
}
Vector3 vector = rootLoc;
Vector3 a = rootLoc;
if (bodyFacing != Rot4.North)
{
a.y += 0.03f;
vector.y += 0.0249999985f;
}
else
{
a.y += 0.0249999985f;
vector.y += 0.03f;
}
if (__instance.graphics.headGraphic != null)
{
Vector3 b = quat * __instance.BaseHeadOffsetAt(headFacing);
Mesh mesh2 = MeshPool.humanlikeHeadSet.MeshAt(headFacing);
Material mat = __instance.graphics.HeadMatAt(headFacing, bodyDrawType);
// GenDraw.DrawMeshNowOrLater(mesh2, a + b, quat, mat, portrait);
if (drawChaos)
{
Material headMarkMat = (AfflictionDrawerUtility.GetHeadGraphic(pawn, patronName).MatAt(bodyFacing));
// vector.y += 0.005f;
GenDraw.DrawMeshNowOrLater(mesh2, a + b + new Vector3(0f, 0.004f, 0f), quat, headMarkMat, portrait);
}
Vector3 loc2 = rootLoc + b;
loc2.y += 0.035f;
bool flag = false;
Mesh mesh3 = __instance.graphics.HairMeshSet.MeshAt(headFacing);
List <ApparelGraphicRecord> apparelGraphics = __instance.graphics.apparelGraphics;
for (int j = 0; j < apparelGraphics.Count; j++)
{
if (apparelGraphics[j].sourceApparel.def.apparel.LastLayer == ApparelLayer.Overhead)
{
flag = true;
Material material = apparelGraphics[j].graphic.MatAt(bodyFacing, null);
material = __instance.graphics.flasher.GetDamagedMat(material);
// GenDraw.DrawMeshNowOrLater(mesh3, loc2, quat, material, portrait);
}
if (!flag && bodyDrawType != RotDrawMode.Dessicated)
{
Mesh mesh4 = __instance.graphics.HairMeshSet.MeshAt(headFacing);
Material mat2 = __instance.graphics.HairMatAt(headFacing);
// GenDraw.DrawMeshNowOrLater(mesh4, loc2, quat, mat2, portrait);
}
}
if (renderBody)
{
for (int k = 0; k < __instance.graphics.apparelGraphics.Count; k++)
{
Material pauldronMat;
if (CompPauldronDrawer.ShouldDrawPauldron(pawn, __instance.graphics.apparelGraphics[k].sourceApparel, bodyFacing, out pauldronMat))
{
if (pawn.ageTracker.CurLifeStageIndex == 2)
{
pauldronMat.mainTextureScale = new Vector2(1.00f, 1.22f);
pauldronMat.mainTextureOffset = new Vector2(0, -0.1f);
}
vector.y += 0.035f;
GenDraw.DrawMeshNowOrLater(mesh, vector, quat, pauldronMat, portrait);
}
ApparelGraphicRecord apparelGraphicRecord = __instance.graphics.apparelGraphics[k];
if (apparelGraphicRecord.sourceApparel.def.apparel.LastLayer == ApparelLayer.Shell)
{
// Material material2 = apparelGraphicRecord.graphic.MatAt(bodyFacing, null);
// material2 = __instance.graphics.flasher.GetDamagedMat(material2);
// GenDraw.DrawMeshNowOrLater(mesh, vector, quat, material2, portrait);
}
if (!pawn.Dead)
{
for (int l = 0; l < pawn.health.hediffSet.hediffs.Count; l++)
{
HediffComp_DrawImplant drawer;
if ((drawer = pawn.health.hediffSet.hediffs[l].TryGetComp <HediffComp_DrawImplant>()) != null)
{
if (drawer.implantDrawProps.implantDrawerType != ImplantDrawerType.Head)
{
vector.y += 0.005f;
if (bodyFacing == Rot4.South && drawer.implantDrawProps.implantDrawerType == ImplantDrawerType.Backpack)
{
vector.y -= 0.3f;
}
Material implantMat = drawer.ImplantMaterial(pawn, bodyFacing);
GenDraw.DrawMeshNowOrLater(mesh, vector, quat, implantMat, portrait);
vector.y += 0.005f;
}
}
}
}
}
}
}
}
}
public static bool Prefix(PawnRenderer __instance,
ref Vector3 rootLoc,
float angle,
bool renderBody,
Rot4 bodyFacing,
Rot4 headFacing,
RotDrawMode bodyDrawType,
bool portrait,
bool headStump)
{
// Pawn pawn = (Pawn)PawnFieldInfo?.GetValue(__instance);
PawnGraphicSet graphics = __instance.graphics;
Pawn pawn = graphics.pawn;
if (!pawn.RaceProps.Humanlike && !Controller.settings.UsePaws)
{
return(true);
}
if (!graphics.AllResolved)
{
graphics.ResolveAllGraphics();
}
CompFace compFace = pawn.GetCompFace();
bool hasFace = compFace != null;
// Let vanilla do the job if no FacePawn or pawn not a teenager or any other known mod accessing the renderer
if (hasFace)
{
if (compFace.IsChild || compFace.Deactivated)
{
return(true);
}
}
CompBodyAnimator compAnim = pawn.GetCompAnim();
bool showFeet = compAnim != null && Controller.settings.UseFeet;
// No face, no animator, return
if (!hasFace && compAnim == null)
{
return(true);
}
PawnWoundDrawer woundDrawer = (PawnWoundDrawer)WoundOverlayFieldInfo?.GetValue(__instance);
// if (Patches2.Plants)
// {
// if (pawn.Spawned)
// {
// Plant plant = (pawn.Position + IntVec3.South).GetPlant(pawn.Map);
// if (plant != null && Patches2.plantMoved.Contains(plant))
// {
// rootLoc.y = plant.DrawPos.y - (Patches2.steps / 2);
// }
// }
// }
// Try to move the y position behind while another pawn is standing near
if (compAnim != null && (!portrait && pawn.Spawned && !compAnim.IsRider))
{
RecalcRootLocY(ref rootLoc, pawn, compAnim);
}
Vector3 baseDrawLoc = rootLoc;
// Let's save the basic location for later
Vector3 footPos = baseDrawLoc;
// No face => must be animal, simplify it
Quaternion quat = Quaternion.AngleAxis(angle, Vector3.up);
Quaternion bodyQuat = quat;
Quaternion footQuat = bodyQuat;
if (MainTabWindow_WalkAnimator.IsOpen)
{
bodyFacing = MainTabWindow_BaseAnimator.BodyRot;
headFacing = MainTabWindow_BaseAnimator.HeadRot;
}
compFace?.TickDrawers(bodyFacing, headFacing, graphics);
compAnim?.TickDrawers(bodyFacing, graphics);
// Use the basic quat
Quaternion headQuat = bodyQuat;
// Rotate head if possible and wobble around
if (!portrait || MainTabWindow_WalkAnimator.IsOpen)
{
if (showFeet)
{
compAnim.ApplyBodyWobble(ref baseDrawLoc, ref footPos, ref bodyQuat);
}
// Reset the quat as it has been changed
headQuat = bodyQuat;
compFace?.ApplyHeadRotation(renderBody, ref headQuat);
}
// Regular FacePawn rendering 14+ years
// Render body
// if (renderBody)
compAnim?.DrawBody(baseDrawLoc, bodyQuat, bodyDrawType, woundDrawer, renderBody, portrait);
Vector3 bodyPos = baseDrawLoc;
Vector3 headPos = baseDrawLoc;
if (bodyFacing == Rot4.North)
{
headPos.y += YOffset_Shell;
bodyPos.y += YOffset_Head;
}
else
{
headPos.y += YOffset_Head;
bodyPos.y += YOffset_Shell;
}
if (graphics.headGraphic != null)
{
// Rendererd pawn faces
Vector3 offsetAt = !hasFace
? __instance.BaseHeadOffsetAt(bodyFacing)
: compFace.BaseHeadOffsetAt(portrait);
Vector3 b = bodyQuat * offsetAt;
Vector3 headDrawLoc = headPos + b;
if (!hasFace)
{
Material material = graphics.HeadMatAt(headFacing, bodyDrawType, headStump);
if (material != null)
{
Mesh mesh2 = MeshPool.humanlikeHeadSet.MeshAt(headFacing);
GenDraw.DrawMeshNowOrLater(mesh2, headDrawLoc, quat, material, portrait);
}
}
else
{
compFace.DrawBasicHead(out bool headDrawn, bodyDrawType, portrait, headStump, headDrawLoc, headQuat);
if (headDrawn)
{
if (bodyDrawType != RotDrawMode.Dessicated && !headStump)
{
if (compFace.Props.hasWrinkles)
{
Vector3 wrinkleLoc = headDrawLoc;
wrinkleLoc.y += YOffset_Wrinkles;
compFace.DrawWrinkles(bodyDrawType, wrinkleLoc, headQuat, portrait);
}
if (compFace.Props.hasEyes)
{
Vector3 eyeLoc = headDrawLoc;
eyeLoc.y += YOffset_Eyes;
compFace.DrawNaturalEyes(eyeLoc, portrait, headQuat);
Vector3 browLoc = headDrawLoc;
browLoc.y += YOffset_Brows;
// the brow above
compFace.DrawBrows(browLoc, headQuat, portrait);
// and now the added eye parts
Vector3 unnaturalEyeLoc = headDrawLoc;
unnaturalEyeLoc.y += YOffset_UnnaturalEyes;
compFace.DrawUnnaturalEyeParts(unnaturalEyeLoc, headQuat, portrait);
}
// Portrait obviously ignores the y offset, thus render the beard after the body apparel (again)
if (compFace.Props.hasBeard)
{
Vector3 beardLoc = headDrawLoc;
Vector3 tacheLoc = headDrawLoc;
beardLoc.y += headFacing == Rot4.North ? -YOffset_Head - YOffset_Beard : YOffset_Beard;
tacheLoc.y += headFacing == Rot4.North ? -YOffset_Head - YOffset_Tache : YOffset_Tache;
compFace.DrawBeardAndTache(beardLoc, tacheLoc, portrait, headQuat);
}
if (compFace.Props.hasMouth)
{
Vector3 mouthLoc = headDrawLoc;
mouthLoc.y += YOffset_Mouth;
compFace.DrawNaturalMouth(mouthLoc, portrait, headQuat);
}
// Deactivated, looks kinda crappy ATM
// if (pawn.Dead)
// {
// Material deadEyeMat = faceComp.DeadEyeMatAt(headFacing, bodyDrawType);
// if (deadEyeMat != null)
// {
// GenDraw.DrawMeshNowOrLater(mesh2, locFacialY, headQuat, deadEyeMat, portrait);
// locFacialY.y += YOffsetInterval_OnFace;
// }
// }
// else
}
}
}
if (!headStump)
{
Vector3 overHead = baseDrawLoc + b;
overHead.y += YOffset_OnHead;
Vector3 hairLoc = overHead;
Vector3 headgearLoc = overHead;
Vector3 hatInFrontOfFace = baseDrawLoc + b;
hairLoc.y += YOffset_HairOnHead;
headgearLoc.y += YOffset_GearOnHead;
hatInFrontOfFace.y += ((!(headFacing == Rot4.North)) ? YOffset_PostHead : YOffset_Behind);
compFace?.DrawHairAndHeadGear(hairLoc, headgearLoc,
bodyDrawType,
portrait,
renderBody,
headQuat, hatInFrontOfFace);
compFace?.DrawAlienHeadAddons(headPos, portrait, headQuat, overHead);
}
}
if (!portrait)
{
// Traverse.Create(__instance).Method("DrawEquipment", rootLoc).GetValue();
DrawEquipmentMethodInfo?.Invoke(__instance, new object[] { baseDrawLoc });
}
if (!portrait)
{
if (pawn.apparel != null)
{
List <Apparel> wornApparel = pawn.apparel.WornApparel;
foreach (Apparel ap in wornApparel)
{
DrawPos_Patch.offset = baseDrawLoc;
DrawPos_Patch.offsetEnabled = true;
ap.DrawWornExtras();
DrawPos_Patch.offsetEnabled = false;
}
}
Vector3 bodyLoc = baseDrawLoc;
bodyLoc.y += YOffset_Status;
PawnHeadOverlays headOverlays = (PawnHeadOverlays)PawnHeadOverlaysFieldInfo?.GetValue(__instance);
if (headOverlays != null)
{
compFace?.DrawHeadOverlays(headOverlays, bodyLoc, headQuat);
}
}
compAnim?.DrawApparel(bodyQuat, bodyPos, portrait, renderBody);
compAnim?.DrawAlienBodyAddons(bodyQuat, bodyPos, portrait, renderBody, bodyFacing);
if (!portrait && pawn.RaceProps.Animal && pawn.inventory != null && pawn.inventory.innerContainer.Count > 0 &&
graphics.packGraphic != null)
{
Mesh mesh = graphics.nakedGraphic.MeshAt(bodyFacing);
Graphics.DrawMesh(mesh, bodyPos, quat, graphics.packGraphic.MatAt(bodyFacing), 0);
}
// No wobble for equipment, looks funnier - nah!
// Vector3 equipPos = rootLoc;
// equipPos.y = drawPos.y;
//compAnim.DrawEquipment(drawPos, portrait);
bool showHands = Controller.settings.UseHands;
Vector3 handPos = bodyPos;
if (renderBody || Controller.settings.IgnoreRenderBody)
{
if (showHands)
{
// Reset the position for the hands
handPos.y = baseDrawLoc.y;
compAnim?.DrawHands(bodyQuat, handPos, portrait);
}
if (showFeet)
{
compAnim.DrawFeet(bodyQuat, footQuat, footPos, portrait);
}
}
return(false);
}
// Verse.PawnRenderer
/// <summary>
/// Render a character in a place.
/// </summary>
public static bool CutoffBody(PawnRenderer __instance, Vector3 rootLoc, Quaternion quat, bool renderBody,
Rot4 bodyFacing, Rot4 headFacing, RotDrawMode bodyDrawType, bool portrait, bool headStump)
{
//Log.Message("1");
var Daniel = Traverse.Create(__instance).Field("pawn").GetValue <Pawn>();
//Log.Message("2");
/////////////////////// Log.Message("Matthew teacher is wearing glassessssssssssssssss");
if (Daniel == null || !(Daniel.PositionHeld is IntVec3 vec) || !vec.IsValid ||
!(vec.GetTerrain(Daniel.MapHeld) is TerrainDef def))
{
return(true);
}
//Log.Message("3");
try
{
if (!Find.TickManager.Paused)
{
//Log.Message("4");
DrowningCheck(Daniel,
def); //j,hvkftyjdyfyfytetjyuhfdgtgvhjmb,nkjutvhrtrgtbhnmb,gu,j6yhdtgexwssr 5nhyj6ujhm,k.u,jhbyrhd4t3cy 7m6ki,l;kiu7yr5f43243rghy67ujklu;k'loi;i9hynt7g6rfvdcr4v3fr4tyu6i7kl8;9[p;kujhygtrfew2e45efr6ghbjnmkl,;.lkjnhgvf6cxd45fc6gv7bh8njukm0il,k0mjnhy8gvfr6gyvthyjuk0iujyhtgrvfcet5rgthyjukil,kujyhtgrvfecdwefrgyujnilmky애국가1.동해물과 백두산이 마르고 닳도록 하느님이 보우하 우리나라 만세 무궁화 삼천리 화려강산 대한사람 대한으로 길이 보전하세.
//Log.Message("5");
}
if (def.IsDeep())
{
renderBody = false;
if (!__instance.graphics.AllResolved)
{
__instance.graphics.ResolveAllGraphics();
}
Mesh mesh = null;
Vector3 vector = rootLoc;
var a = rootLoc;
if (bodyFacing != Rot4.North)
{
a.y += 0.0281250011f;
vector.y += 0.0234375f;
}
else
{
a.y += 0.0234375f;
vector.y += 0.0281250011f;
}
if (__instance.graphics.headGraphic != null)
{
var b = quat * __instance.BaseHeadOffsetAt(headFacing);
var material = __instance.graphics.HeadMatAt(headFacing, bodyDrawType, headStump);
if (material != null)
{
var mesh2 = MeshPool.humanlikeHeadSet.MeshAt(headFacing);
GenDraw.DrawMeshNowOrLater(mesh2, a + b, quat, material, portrait);
}
var loc2 = rootLoc + b;
loc2.y += 0.0328125022f;
var flag = false;
if (!portrait || !Prefs.HatsOnlyOnMap)
{
var mesh3 = __instance.graphics.HairMeshSet.MeshAt(headFacing);
var apparelGraphics = __instance.graphics.apparelGraphics;
for (var j = 0; j < apparelGraphics.Count; j++)
{
if (apparelGraphics[j].sourceApparel.def.apparel.LastLayer != ApparelLayer.Overhead)
{
continue;
}
flag = true;
var material2 = apparelGraphics[j].graphic.MatAt(bodyFacing, null);
material2 = __instance.graphics.flasher.GetDamagedMat(material2);
GenDraw.DrawMeshNowOrLater(mesh3, loc2, quat, material2, portrait);
}
}
if (!flag && bodyDrawType != RotDrawMode.Dessicated && !headStump)
{
var mesh4 = __instance.graphics.HairMeshSet.MeshAt(headFacing);
var mat = __instance.graphics.HairMatAt(headFacing);
GenDraw.DrawMeshNowOrLater(mesh4, loc2, quat, mat, portrait);
}
}
if (!portrait && Daniel.RaceProps.Animal && Daniel.inventory != null &&
Daniel.inventory.innerContainer.Count > 0)
{
Graphics.DrawMesh(mesh, vector, quat,
__instance.graphics.packGraphic.MatAt(Daniel.Rotation, null), 0);
}
if (!portrait && Daniel.RaceProps.Animal)
{
var req = new MaterialRequest
(ContentFinder <Texture2D> .Get("WaterShadow"));
Vector3 s = new Vector3(2.0f, 1f, 2.0f);
Matrix4x4 matrix = default(Matrix4x4);
matrix.SetTRS(vector, Quaternion.identity, s);
Graphics.DrawMesh(MeshPool.plane10, matrix, MaterialPool.MatFrom(req), 0);
}
if (portrait)
{
return(false);
}
AccessTools.Method(typeof(PawnRenderer), "DrawEquipment")
.Invoke(__instance, new object[] { rootLoc });
//__instance.DrawEquipment(rootLoc);
if (Daniel.apparel != null)
{
var wornApparel = Daniel.apparel.WornApparel;
for (var l = 0; l < wornApparel.Count; l++)
{
wornApparel[l].DrawWornExtras();
}
}
var bodyLoc = rootLoc;
bodyLoc.y += 0.0421875f;
var Tweety = Traverse.Create(__instance).Field("statusOverlays").GetValue <PawnHeadOverlays>();
Tweety.RenderStatusOverlays(bodyLoc, quat, MeshPool.humanlikeHeadSet.MeshAt(headFacing));
return(false);
}
}
catch
{
}
return(true);
}
