public override void RenderExtraStuff(ushort vehicleID, ref Vehicle vehicleData, RenderManager.CameraInfo cameraInfo, InstanceID id, Vector3 position, Quaternion rotation, Vector4 tyrePosition, Vector4 lightState, Vector3 scale, Vector3 swayPosition, bool underground, bool overground)
{
VehicleManager instance = Singleton <VehicleManager> .instance;
Vehicle.Flags flags = instance.m_vehicles.m_buffer[vehicleID].m_flags;
if (m_info != null && m_info.m_vehicleAI != null && m_info.m_subMeshes != null)
{
Matrix4x4 bodyMatrix = m_info.m_vehicleAI.CalculateBodyMatrix(flags, ref position, ref rotation, ref scale, ref swayPosition);
Matrix4x4 value = m_info.m_vehicleAI.CalculateTyreMatrix(flags, ref position, ref rotation, ref scale, ref bodyMatrix);
if ((flags & Vehicle.Flags.Inverted) != 0)
{
tyrePosition.x = 0f - tyrePosition.x;
tyrePosition.y = 0f - tyrePosition.y;
}
MaterialPropertyBlock materialBlock = instance.m_materialBlock;
materialBlock.Clear();
materialBlock.SetMatrix(instance.ID_TyreMatrix, value);
materialBlock.SetVector(instance.ID_TyrePosition, tyrePosition);
materialBlock.SetVector(instance.ID_LightState, lightState);
for (int i = 0; i < m_info.m_subMeshes.Length; i++)
{
VehicleInfo.MeshInfo meshInfo = m_info.m_subMeshes[i];
RenderPoleMesh(vehicleID, ref vehicleData, position, rotation, swayPosition, underground, overground, instance, meshInfo, materialBlock);
}
}
base.RenderExtraStuff(vehicleID, ref vehicleData, cameraInfo, id, position, rotation, tyrePosition, lightState, scale, swayPosition, underground, overground);
}
internal static object CustomDeserialize(Package p, Type t, PackageReader r)
{
// Props and trees in buildings and parks.
if (t == typeof(BuildingInfo.Prop))
{
PropInfo pi = Get <PropInfo>(r.ReadString()); // old name format (without package name) is possible
TreeInfo ti = Get <TreeInfo>(r.ReadString()); // old name format (without package name) is possible
if (instance.report && UsedAssets.instance.GotAnyContainer())
{
if (pi != null)
{
string n = pi.gameObject.name;
if (!string.IsNullOrEmpty(n) && n.IndexOf('.') >= 0)
{
UsedAssets.instance.IndirectProps.Add(n);
}
}
if (ti != null)
{
string n = ti.gameObject.name;
if (!string.IsNullOrEmpty(n) && n.IndexOf('.') >= 0)
{
UsedAssets.instance.IndirectTrees.Add(n);
}
}
}
return(new BuildingInfo.Prop
{
m_prop = pi,
m_tree = ti,
m_position = r.ReadVector3(),
m_angle = r.ReadSingle(),
m_probability = r.ReadInt32(),
m_fixedHeight = r.ReadBoolean()
});
}
// Paths (nets) in buildings.
if (t == typeof(BuildingInfo.PathInfo))
{
string fullName = r.ReadString();
NetInfo ni = Get <NetInfo>(fullName);
BuildingInfo.PathInfo path = new BuildingInfo.PathInfo();
path.m_netInfo = ni;
path.m_nodes = r.ReadVector3Array();
path.m_curveTargets = r.ReadVector3Array();
path.m_invertSegments = r.ReadBoolean();
path.m_maxSnapDistance = r.ReadSingle();
if (p.version >= 5)
{
path.m_forbidLaneConnection = r.ReadBooleanArray();
path.m_trafficLights = (BuildingInfo.TrafficLights[])(object) r.ReadInt32Array();
path.m_yieldSigns = r.ReadBooleanArray();
}
return(path);
}
if (t == typeof(Package.Asset))
{
return(r.ReadAsset(p));
}
// It seems that trailers are listed in the save game so this is not necessary. Better to be safe however
// because a missing trailer reference is fatal for the simulation thread.
if (t == typeof(VehicleInfo.VehicleTrailer))
{
string name = r.ReadString();
string fullName = p.packageName + "." + name;
VehicleInfo vi = Get <VehicleInfo>(p, fullName, name, false);
VehicleInfo.VehicleTrailer trailer;
trailer.m_info = vi;
trailer.m_probability = r.ReadInt32();
trailer.m_invertProbability = r.ReadInt32();
return(trailer);
}
if (t == typeof(NetInfo.Lane))
{
return(new NetInfo.Lane
{
m_position = r.ReadSingle(),
m_width = r.ReadSingle(),
m_verticalOffset = r.ReadSingle(),
m_stopOffset = r.ReadSingle(),
m_speedLimit = r.ReadSingle(),
m_direction = (NetInfo.Direction)r.ReadInt32(),
m_laneType = (NetInfo.LaneType)r.ReadInt32(),
m_vehicleType = (VehicleInfo.VehicleType)r.ReadInt32(),
m_stopType = (VehicleInfo.VehicleType)r.ReadInt32(),
m_laneProps = GetNetLaneProps(p, r),
m_allowConnect = r.ReadBoolean(),
m_useTerrainHeight = r.ReadBoolean(),
m_centerPlatform = r.ReadBoolean(),
m_elevated = r.ReadBoolean()
});
}
if (t == typeof(NetInfo.Segment))
{
NetInfo.Segment segment = new NetInfo.Segment();
string checksum = r.ReadString();
segment.m_mesh = string.IsNullOrEmpty(checksum) ? null : Sharing.instance.GetMesh(checksum, p, true);
checksum = r.ReadString();
segment.m_material = string.IsNullOrEmpty(checksum) ? null : Sharing.instance.GetMaterial(checksum, p, true);
checksum = r.ReadString();
segment.m_lodMesh = string.IsNullOrEmpty(checksum) ? null : Sharing.instance.GetMesh(checksum, p, false);
checksum = r.ReadString();
segment.m_lodMaterial = string.IsNullOrEmpty(checksum) ? null : Sharing.instance.GetMaterial(checksum, p, false);
segment.m_forwardRequired = (NetSegment.Flags)r.ReadInt32();
segment.m_forwardForbidden = (NetSegment.Flags)r.ReadInt32();
segment.m_backwardRequired = (NetSegment.Flags)r.ReadInt32();
segment.m_backwardForbidden = (NetSegment.Flags)r.ReadInt32();
segment.m_emptyTransparent = r.ReadBoolean();
segment.m_disableBendNodes = r.ReadBoolean();
return(segment);
}
if (t == typeof(NetInfo.Node))
{
NetInfo.Node node = new NetInfo.Node();
string checksum = r.ReadString();
node.m_mesh = string.IsNullOrEmpty(checksum) ? null : Sharing.instance.GetMesh(checksum, p, true);
checksum = r.ReadString();
node.m_material = string.IsNullOrEmpty(checksum) ? null : Sharing.instance.GetMaterial(checksum, p, true);
checksum = r.ReadString();
node.m_lodMesh = string.IsNullOrEmpty(checksum) ? null : Sharing.instance.GetMesh(checksum, p, false);
checksum = r.ReadString();
node.m_lodMaterial = string.IsNullOrEmpty(checksum) ? null : Sharing.instance.GetMaterial(checksum, p, false);
node.m_flagsRequired = (NetNode.Flags)r.ReadInt32();
node.m_flagsForbidden = (NetNode.Flags)r.ReadInt32();
node.m_connectGroup = (NetInfo.ConnectGroup)r.ReadInt32();
node.m_directConnect = r.ReadBoolean();
node.m_emptyTransparent = r.ReadBoolean();
return(node);
}
if (t == typeof(NetInfo))
{
string name = r.ReadString();
CustomAssetMetaData.Type type = AssetLoader.instance.GetMetaType(AssetLoader.instance.Current);
if (type == CustomAssetMetaData.Type.Road || type == CustomAssetMetaData.Type.RoadElevation)
{
return(Get <NetInfo>(p, name));
}
else
{
return(Get <NetInfo>(name));
}
}
if (t == typeof(BuildingInfo))
{
string name = r.ReadString();
CustomAssetMetaData.Type type = AssetLoader.instance.GetMetaType(AssetLoader.instance.Current);
if (type == CustomAssetMetaData.Type.Road || type == CustomAssetMetaData.Type.RoadElevation)
{
return(Get <BuildingInfo>(p, name));
}
else
{
return(Get <BuildingInfo>(name));
}
}
// Sub-buildings in buildings.
if (t == typeof(BuildingInfo.SubInfo))
{
string name = r.ReadString();
string fullName = p.packageName + "." + name;
BuildingInfo bi = null;
if (fullName == AssetLoader.instance.Current.fullName || name == AssetLoader.instance.Current.fullName)
{
Util.DebugPrint("Warning:", fullName, "wants to be a sub-building for itself");
}
else
{
bi = Get <BuildingInfo>(p, fullName, name, true);
}
BuildingInfo.SubInfo subInfo = new BuildingInfo.SubInfo();
subInfo.m_buildingInfo = bi;
subInfo.m_position = r.ReadVector3();
subInfo.m_angle = r.ReadSingle();
subInfo.m_fixedHeight = r.ReadBoolean();
return(subInfo);
}
// Prop variations in props.
if (t == typeof(PropInfo.Variation))
{
string name = r.ReadString();
string fullName = p.packageName + "." + name;
PropInfo pi = null;
if (fullName == AssetLoader.instance.Current.fullName)
{
Util.DebugPrint("Warning:", fullName, "wants to be a prop variation for itself");
}
else
{
pi = Get <PropInfo>(p, fullName, name, false);
}
return(new PropInfo.Variation
{
m_prop = pi,
m_probability = r.ReadInt32()
});
}
// Tree variations in trees.
if (t == typeof(TreeInfo.Variation))
{
string name = r.ReadString();
string fullName = p.packageName + "." + name;
TreeInfo ti = null;
if (fullName == AssetLoader.instance.Current.fullName)
{
Util.DebugPrint("Warning:", fullName, "wants to be a tree variation for itself");
}
else
{
ti = Get <TreeInfo>(p, fullName, name, false);
}
return(new TreeInfo.Variation
{
m_tree = ti,
m_probability = r.ReadInt32()
});
}
if (t == typeof(VehicleInfo.MeshInfo))
{
VehicleInfo.MeshInfo meshinfo = new VehicleInfo.MeshInfo();
string checksum = r.ReadString();
if (!string.IsNullOrEmpty(checksum))
{
Package.Asset asset = p.FindByChecksum(checksum);
GameObject go = AssetDeserializer.Instantiate(asset) as GameObject;
meshinfo.m_subInfo = go.GetComponent <VehicleInfoBase>();
go.SetActive(false);
if (meshinfo.m_subInfo.m_lodObject != null)
{
meshinfo.m_subInfo.m_lodObject.SetActive(false);
}
}
else
{
meshinfo.m_subInfo = null;
}
meshinfo.m_vehicleFlagsForbidden = (Vehicle.Flags)r.ReadInt32();
meshinfo.m_vehicleFlagsRequired = (Vehicle.Flags)r.ReadInt32();
meshinfo.m_parkedFlagsForbidden = (VehicleParked.Flags)r.ReadInt32();
meshinfo.m_parkedFlagsRequired = (VehicleParked.Flags)r.ReadInt32();
return(meshinfo);
}
return(PackageHelper.CustomDeserialize(p, t, r));
}
protected override Matrix4x4 RenderMesh(VehicleInfo info, BoardTextDescriptorGeneralXml[] textDescriptors, Vector3 position, Quaternion rotation, Vector3 scale, Matrix4x4 sourceMatrix, out Color targetColor, ref int defaultCallsCounter)
{
targetColor = WTSDynamicTextRenderingRules.GetPropColor(0, 0, 0, m_defaultInstance, null, out _);
VehicleManager instance2 = Singleton <VehicleManager> .instance;
Matrix4x4 matrix = Matrix4x4.TRS(position, rotation, scale) * sourceMatrix;
Matrix4x4 value = info.m_vehicleAI.CalculateTyreMatrix(Vehicle.Flags.Created, ref position, ref rotation, ref scale, ref matrix);
MaterialPropertyBlock materialBlock = instance2.m_materialBlock;
materialBlock.Clear();
materialBlock.SetMatrix(instance2.ID_TyreMatrix, value);
materialBlock.SetVector(instance2.ID_TyrePosition, Vector3.zero);
materialBlock.SetVector(instance2.ID_LightState, Vector3.zero);
materialBlock.SetColor(instance2.ID_Color, targetColor * new Color(1, 1, 1, 0));
instance2.m_drawCallData.m_batchedCalls += 1;
info.m_material.SetVectorArray(instance2.ID_TyreLocation, info.m_generatedInfo.m_tyres);
defaultCallsCounter++;
Graphics.DrawMesh(GetMesh(info), matrix, GetMaterial(info), info.m_prefabDataLayer, m_camera, 0, materialBlock, true, true);
for (int j = 0; j < info.m_subMeshes.Length; j++)
{
VehicleInfo.MeshInfo meshInfo = info.m_subMeshes[j];
var subInfo = meshInfo.m_subInfo as VehicleInfoSub;
if (subInfo != null && (meshInfo.m_vehicleFlagsRequired & Vehicle.Flags.LeftHandDrive) == 0)
{
VehicleManager.instance.m_drawCallData.m_batchedCalls = VehicleManager.instance.m_drawCallData.m_batchedCalls + 1;
subInfo.m_material.SetVectorArray(VehicleManager.instance.ID_TyreLocation, subInfo.m_generatedInfo.m_tyres);
defaultCallsCounter++;
Graphics.DrawMesh(subInfo.m_mesh, matrix, subInfo.m_material, info.m_prefabDataLayer, null, 0, materialBlock);
}
}
////Vector3 one = Vector3.one;
////float magnitude = info.m_mesh.bounds.extents.magnitude;
////float num = magnitude + 16f;
////float num2 = magnitude * 3f;
////m_camera.transform.position = Vector3.forward * num2;
////m_camera.transform.rotation = Quaternion.AngleAxis(180f, Vector3.up);
////m_camera.nearClipPlane = Mathf.Max(num2 - num * 1.5f, 0.01f);
////m_camera.farClipPlane = num2 + num * 1.5f;
////Quaternion quaternion = Quaternion.Euler(20f, 0f, 0f)* rotation;
////Vector3 pos = quaternion * -info.m_mesh.bounds.center;
////VehicleManager instance2 = Singleton<VehicleManager>.instance;
////Matrix4x4 matrix = Matrix4x4.TRS(pos, quaternion, Vector3.one);
////Matrix4x4 value = info.m_vehicleAI.CalculateTyreMatrix(Vehicle.Flags.Created, ref pos, ref quaternion, ref one, ref matrix);
////MaterialPropertyBlock materialBlock = instance2.m_materialBlock;
////materialBlock.Clear();
////materialBlock.SetMatrix(instance2.ID_TyreMatrix, value);
////materialBlock.SetVector(instance2.ID_TyrePosition, Vector3.zero);
////materialBlock.SetVector(instance2.ID_LightState, Vector3.zero);
////materialBlock.SetColor(instance2.ID_VehicleColor, targetColor);
////instance2.m_drawCallData.m_batchedCalls = instance2.m_drawCallData.m_batchedCalls + 1;
////info.m_material.SetVectorArray(instance2.ID_TyreLocation, info.m_generatedInfo.m_tyres);
///defaultCallsCounter++;
////Graphics.DrawMesh(info.m_mesh, matrix, info.m_material, 0, m_camera, 0, materialBlock, true, true);
////m_camera.Render();
return(matrix);
}
private Matrix4x4 CalculatePoleMatrix(ushort vehicleID, ref Vehicle vehicleData, Vector3 position, Quaternion rotation, Vector3 swayPosition, VehicleInfo.MeshInfo meshInfo, VehicleInfoBase subInfo, bool assetEditor)
{
Vehicle.Flags flags = meshInfo.m_vehicleFlagsRequired & (Vehicle.Flags.TakingOff | Vehicle.Flags.Landing);
VehicleInfo.VehicleType wireType = GetWireType(vehicleData.m_flags, flags);
float poleLength = m_poleLength;
Quaternion rhs = Quaternion.Euler(swayPosition.z * 57.29578f, 0f, swayPosition.x * -57.29578f);
Vector3 a = (flags != Vehicle.Flags.TakingOff) ? Vector3.left : Vector3.right;
Vector3 vector = position + rotation * rhs * (a * m_offsetX + Vector3.back * m_offsetZ + Vector3.up * m_offsetY);
Vector3 poleEnd = position + rotation * rhs * (a * m_offsetX + Vector3.back * (m_offsetZ + poleLength) + Vector3.up * m_offsetY);
Vector3 wireAttachmentPosition;
if (!assetEditor)
{
TrolleybusReversePatch.FindWireConnection(vehicleID, ref vehicleData, wireType, poleLength, vector, poleEnd, out wireAttachmentPosition);
}
else
{
wireAttachmentPosition = position + rotation * rhs * (a * m_offsetX + Vector3.back * (m_offsetZ + poleLength) + Vector3.up * 4.55f);
}
Matrix4x4 result = default(Matrix4x4);
result.SetTRS(vector, Quaternion.LookRotation(vector - wireAttachmentPosition, Vector3.up), Vector3.one);
return(result);
}
private void RenderPoleMesh(ushort vehicleID, ref Vehicle vehicleData, Vector3 position, Quaternion rotation, Vector3 swayPosition, bool underground, bool overground, VehicleManager vehicleManager, VehicleInfo.MeshInfo meshInfo, MaterialPropertyBlock materialBlock)
{
VehicleInfoBase subInfo = meshInfo.m_subInfo;
bool flag = Singleton <ToolManager> .instance.m_properties.m_mode == ItemClass.Availability.AssetEditor;
if ((flag && !BuildingDecoration.IsSubMeshRendered(subInfo)) || (meshInfo.m_vehicleFlagsRequired & (Vehicle.Flags.TakingOff | Vehicle.Flags.Landing)) == 0 || !(subInfo != null))
{
return;
}
Matrix4x4 matrix = CalculatePoleMatrix(vehicleID, ref vehicleData, position, rotation, swayPosition, meshInfo, subInfo, flag);
vehicleManager.m_drawCallData.m_defaultCalls++;
if (underground)
{
if (subInfo.m_undergroundMaterial == null && subInfo.m_material != null)
{
VehicleProperties properties = vehicleManager.m_properties;
if (properties != null)
{
subInfo.m_undergroundMaterial = new Material(properties.m_undergroundShader);
subInfo.m_undergroundMaterial.CopyPropertiesFromMaterial(subInfo.m_material);
}
}
Graphics.DrawMesh(subInfo.m_mesh, matrix, subInfo.m_undergroundMaterial, vehicleManager.m_undergroundLayer, null, 0, materialBlock);
}
if (overground)
{
Graphics.DrawMesh(subInfo.m_mesh, matrix, subInfo.m_material, m_info.m_prefabDataLayer, null, 0, materialBlock);
}
}
// Run before the original method. Skip the original one if the vehicle is a cable car
public static bool Prefix(RenderManager.CameraInfo cameraInfo, VehicleInfo info, Vector3 position, ref Quaternion rotation, Vector3 swayPosition, Vector4 lightState, Vector4 tyrePosition, Vector3 velocity, float acceleration, Color color, Vehicle.Flags flags, int variationMask, InstanceID id, bool underground, bool overground)
{
// if the vehicle is not a cable car, skip and use the original method
if ((int)info.m_vehicleType != 0x1000)
{
return(true);
}
// limit rotation along the x and z axes for all meshes except submesh1
// submesh1 would rotate in the original way(along with the cable)
Quaternion originalRotation = rotation;
rotation.x = 0.0f;
rotation.z = 0.0f;
// change how cable cars sway
// so they don't move up and down on the cables as if they're ships moving in sea waves
swayPosition.y = 0.0f;
if ((cameraInfo.m_layerMask & (1 << info.m_prefabDataLayer)) == 0)
{
// return false to skip the original method
return(false);
}
Vector3 scale = Vector3.one;
if ((flags & Vehicle.Flags.Inverted) != 0)
{
scale = new Vector3(-1f, 1f, -1f);
Vector4 vector = lightState;
lightState.x = vector.y;
lightState.y = vector.x;
lightState.z = vector.w;
lightState.w = vector.z;
}
info.m_vehicleAI.RenderExtraStuff(id.Vehicle, ref Singleton <VehicleManager> .instance.m_vehicles.m_buffer[id.Vehicle], cameraInfo, id, position, rotation, tyrePosition, lightState, scale, swayPosition, underground, overground);
if (cameraInfo.CheckRenderDistance(position, info.m_lodRenderDistance))
{
VehicleManager instance = Singleton <VehicleManager> .instance;
Matrix4x4 bodyMatrix = info.m_vehicleAI.CalculateBodyMatrix(flags, ref position, ref rotation, ref scale, ref swayPosition);
Matrix4x4 originalBodyMatrix = info.m_vehicleAI.CalculateBodyMatrix(flags, ref position, ref originalRotation, ref scale, ref swayPosition);
Matrix4x4 value = info.m_vehicleAI.CalculateTyreMatrix(flags, ref position, ref rotation, ref scale, ref bodyMatrix);
if (Singleton <InfoManager> .instance.CurrentMode == InfoManager.InfoMode.None)
{
RenderGroup.MeshData effectMeshData = info.m_vehicleAI.GetEffectMeshData();
EffectInfo.SpawnArea area = new EffectInfo.SpawnArea(bodyMatrix, effectMeshData, info.m_generatedInfo.m_tyres, info.m_lightPositions);
if (info.m_effects != null)
{
for (int i = 0; i < info.m_effects.Length; i++)
{
VehicleInfo.Effect effect = info.m_effects[i];
if (((effect.m_vehicleFlagsRequired | effect.m_vehicleFlagsForbidden) & flags) == effect.m_vehicleFlagsRequired && effect.m_parkedFlagsRequired == VehicleParked.Flags.None)
{
effect.m_effect.RenderEffect(id, area, velocity, acceleration, 1f, -1f, Singleton <SimulationManager> .instance.m_simulationTimeDelta, cameraInfo);
}
}
}
}
if ((flags & Vehicle.Flags.Inverted) != 0)
{
tyrePosition.x = 0f - tyrePosition.x;
tyrePosition.y = 0f - tyrePosition.y;
}
MaterialPropertyBlock materialBlock = instance.m_materialBlock;
materialBlock.Clear();
materialBlock.SetMatrix(instance.ID_TyreMatrix, value);
materialBlock.SetVector(instance.ID_TyrePosition, tyrePosition);
materialBlock.SetVector(instance.ID_LightState, lightState);
bool flag = Singleton <ToolManager> .instance.m_properties.m_mode == ItemClass.Availability.AssetEditor;
if (!flag)
{
materialBlock.SetColor(instance.ID_Color, color);
}
bool flag2 = true;
if (flag)
{
flag2 = BuildingDecoration.IsMainMeshRendered();
}
if (info.m_subMeshes != null)
{
for (int j = 0; j < info.m_subMeshes.Length; j++)
{
VehicleInfo.MeshInfo meshInfo = info.m_subMeshes[j];
VehicleInfoBase subInfo = meshInfo.m_subInfo;
if ((!flag && ((meshInfo.m_vehicleFlagsRequired | meshInfo.m_vehicleFlagsForbidden) & flags) == meshInfo.m_vehicleFlagsRequired && (meshInfo.m_variationMask & variationMask) == 0 && meshInfo.m_parkedFlagsRequired == VehicleParked.Flags.None) || (flag && BuildingDecoration.IsSubMeshRendered(subInfo)))
{
if (!(subInfo != null))
{
continue;
}
instance.m_drawCallData.m_defaultCalls++;
if (underground)
{
if (subInfo.m_undergroundMaterial == null && subInfo.m_material != null)
{
VehicleProperties properties = instance.m_properties;
if (properties != null)
{
subInfo.m_undergroundMaterial = new Material(properties.m_undergroundShader);
subInfo.m_undergroundMaterial.CopyPropertiesFromMaterial(subInfo.m_material);
}
}
subInfo.m_undergroundMaterial.SetVectorArray(instance.ID_TyreLocation, subInfo.m_generatedInfo.m_tyres);
if (j == 1)
{
Graphics.DrawMesh(subInfo.m_mesh, originalBodyMatrix, subInfo.m_undergroundMaterial, instance.m_undergroundLayer, null, 0, materialBlock);
}
else
{
Graphics.DrawMesh(subInfo.m_mesh, bodyMatrix, subInfo.m_undergroundMaterial, instance.m_undergroundLayer, null, 0, materialBlock);
}
}
if (overground)
{
subInfo.m_material.SetVectorArray(instance.ID_TyreLocation, subInfo.m_generatedInfo.m_tyres);
if (j == 1)
{
Graphics.DrawMesh(subInfo.m_mesh, originalBodyMatrix, subInfo.m_material, info.m_prefabDataLayer, null, 0, materialBlock);
}
else
{
Graphics.DrawMesh(subInfo.m_mesh, bodyMatrix, subInfo.m_material, info.m_prefabDataLayer, null, 0, materialBlock);
}
}
}
else if (subInfo == null)
{
flag2 = false;
}
}
}
if (!flag2)
{
// return false to skip the original method
return(false);
}
instance.m_drawCallData.m_defaultCalls++;
if (underground)
{
if (info.m_undergroundMaterial == null && info.m_material != null)
{
VehicleProperties properties2 = instance.m_properties;
if (properties2 != null)
{
info.m_undergroundMaterial = new Material(properties2.m_undergroundShader);
info.m_undergroundMaterial.CopyPropertiesFromMaterial(info.m_material);
}
}
info.m_undergroundMaterial.SetVectorArray(instance.ID_TyreLocation, info.m_generatedInfo.m_tyres);
Graphics.DrawMesh(info.m_mesh, bodyMatrix, info.m_undergroundMaterial, instance.m_undergroundLayer, null, 0, materialBlock);
}
if (overground)
{
info.m_material.SetVectorArray(instance.ID_TyreLocation, info.m_generatedInfo.m_tyres);
Graphics.DrawMesh(info.m_mesh, bodyMatrix, info.m_material, info.m_prefabDataLayer, null, 0, materialBlock);
}
// return false to skip the original method
return(false);
}
Matrix4x4 bodyMatrix2 = info.m_vehicleAI.CalculateBodyMatrix(flags, ref position, ref rotation, ref scale, ref swayPosition);
Matrix4x4 originalBodyMatrix2 = info.m_vehicleAI.CalculateBodyMatrix(flags, ref position, ref originalRotation, ref scale, ref swayPosition);
if (Singleton <ToolManager> .instance.m_properties.m_mode == ItemClass.Availability.AssetEditor)
{
Matrix4x4 value2 = info.m_vehicleAI.CalculateTyreMatrix(flags, ref position, ref rotation, ref scale, ref bodyMatrix2);
VehicleManager instance2 = Singleton <VehicleManager> .instance;
MaterialPropertyBlock materialBlock2 = instance2.m_materialBlock;
materialBlock2.Clear();
materialBlock2.SetMatrix(instance2.ID_TyreMatrix, value2);
materialBlock2.SetVector(instance2.ID_TyrePosition, tyrePosition);
materialBlock2.SetVector(instance2.ID_LightState, lightState);
Mesh mesh = null;
Material material = null;
if (info.m_lodObject != null)
{
MeshFilter component = info.m_lodObject.GetComponent <MeshFilter>();
if (component != null)
{
mesh = component.sharedMesh;
}
Renderer component2 = info.m_lodObject.GetComponent <Renderer>();
if (component2 != null)
{
material = component2.sharedMaterial;
}
}
if (mesh != null && material != null)
{
materialBlock2.SetVectorArray(instance2.ID_TyreLocation, info.m_generatedInfo.m_tyres);
Graphics.DrawMesh(mesh, bodyMatrix2, material, info.m_prefabDataLayer, null, 0, materialBlock2);
}
}
else if (Singleton <InfoManager> .instance.CurrentMode == InfoManager.InfoMode.None)
{
RenderGroup.MeshData effectMeshData2 = info.m_vehicleAI.GetEffectMeshData();
EffectInfo.SpawnArea area2 = new EffectInfo.SpawnArea(bodyMatrix2, effectMeshData2, info.m_generatedInfo.m_tyres, info.m_lightPositions);
if (info.m_effects != null)
{
for (int k = 0; k < info.m_effects.Length; k++)
{
VehicleInfo.Effect effect2 = info.m_effects[k];
if (((effect2.m_vehicleFlagsRequired | effect2.m_vehicleFlagsForbidden) & flags) == effect2.m_vehicleFlagsRequired && effect2.m_parkedFlagsRequired == VehicleParked.Flags.None)
{
effect2.m_effect.RenderEffect(id, area2, velocity, acceleration, 1f, -1f, Singleton <SimulationManager> .instance.m_simulationTimeDelta, cameraInfo);
}
}
}
}
bool flag3 = true;
if (info.m_subMeshes != null)
{
for (int l = 0; l < info.m_subMeshes.Length; l++)
{
VehicleInfo.MeshInfo meshInfo2 = info.m_subMeshes[l];
VehicleInfoBase subInfo2 = meshInfo2.m_subInfo;
if (((meshInfo2.m_vehicleFlagsRequired | meshInfo2.m_vehicleFlagsForbidden) & flags) == meshInfo2.m_vehicleFlagsRequired && (meshInfo2.m_variationMask & variationMask) == 0 && meshInfo2.m_parkedFlagsRequired == VehicleParked.Flags.None)
{
if (!(subInfo2 != null))
{
continue;
}
if (underground)
{
if (l == 1)
{
subInfo2.m_undergroundLodTransforms[subInfo2.m_undergroundLodCount] = originalBodyMatrix2;
}
else
{
subInfo2.m_undergroundLodTransforms[subInfo2.m_undergroundLodCount] = bodyMatrix2;
}
subInfo2.m_undergroundLodLightStates[subInfo2.m_undergroundLodCount] = lightState;
subInfo2.m_undergroundLodColors[subInfo2.m_undergroundLodCount] = color.linear;
subInfo2.m_undergroundLodMin = Vector3.Min(subInfo2.m_undergroundLodMin, position);
subInfo2.m_undergroundLodMax = Vector3.Max(subInfo2.m_undergroundLodMax, position);
if (++subInfo2.m_undergroundLodCount == subInfo2.m_undergroundLodTransforms.Length)
{
Vehicle.RenderUndergroundLod(cameraInfo, subInfo2);
}
}
if (overground)
{
if (l == 1)
{
subInfo2.m_lodTransforms[subInfo2.m_lodCount] = originalBodyMatrix2;
}
else
{
subInfo2.m_lodTransforms[subInfo2.m_lodCount] = bodyMatrix2;
}
subInfo2.m_lodLightStates[subInfo2.m_lodCount] = lightState;
subInfo2.m_lodColors[subInfo2.m_lodCount] = color.linear;
subInfo2.m_lodMin = Vector3.Min(subInfo2.m_lodMin, position);
subInfo2.m_lodMax = Vector3.Max(subInfo2.m_lodMax, position);
if (++subInfo2.m_lodCount == subInfo2.m_lodTransforms.Length)
{
Vehicle.RenderLod(cameraInfo, subInfo2);
}
}
}
else if (subInfo2 == null)
{
flag3 = false;
}
}
}
if (!flag3)
{
return(false);
}
if (underground)
{
info.m_undergroundLodTransforms[info.m_undergroundLodCount] = bodyMatrix2;
info.m_undergroundLodLightStates[info.m_undergroundLodCount] = lightState;
info.m_undergroundLodColors[info.m_undergroundLodCount] = color.linear;
info.m_undergroundLodMin = Vector3.Min(info.m_undergroundLodMin, position);
info.m_undergroundLodMax = Vector3.Max(info.m_undergroundLodMax, position);
if (++info.m_undergroundLodCount == info.m_undergroundLodTransforms.Length)
{
Vehicle.RenderUndergroundLod(cameraInfo, info);
}
}
if (overground)
{
info.m_lodTransforms[info.m_lodCount] = bodyMatrix2;
info.m_lodLightStates[info.m_lodCount] = lightState;
info.m_lodColors[info.m_lodCount] = color.linear;
info.m_lodMin = Vector3.Min(info.m_lodMin, position);
info.m_lodMax = Vector3.Max(info.m_lodMax, position);
if (++info.m_lodCount == info.m_lodTransforms.Length)
{
Vehicle.RenderLod(cameraInfo, info);
}
}
// return false to skip the original method
return(false);
}
