public VehicleRenderer(VehiclePawn vehicle)
{
this.vehicle = vehicle;
statusOverlays = new PawnHeadOverlays(vehicle);
woundOverlays = new PawnWoundDrawer(vehicle);
graphics = new VehicleGraphicSet(vehicle);
effecters = new VehicleStatusEffecters(vehicle);
}
public virtual void DrawHeadOverlays(PawnHeadOverlays headOverlays, Vector3 bodyLoc, Quaternion headQuat)
{
headOverlays?.RenderStatusOverlays(bodyLoc, headQuat, this.GetPawnMesh(false, false));
}
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 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);
}
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);
}
