private static SceneObjectIdentifier CreateObjectID(IExportContainer container, Object asset)
{
long lid = asset == null ? 0 : container.GetExportID(asset);
SceneObjectIdentifier soId = new SceneObjectIdentifier(lid, 0);
return(soId);
}
private void SetExportData(IExportContainer container)
{
// if < 3.0.0 this asset doesn't exist
// 3.0.0 to 5.5.0 this asset is created by culling settings so it has set data already
if (OcclusionCullingSettings.IsReadPVSData(container.Version))
{
return;
}
// if >= 5.5.0 and !Release this asset containts renderer data
if (IsReadStaticRenderers(container.Flags))
{
return;
}
// if >= 5.5.0 and Release this asset doesn't containt renderers data so we need to create it
List <OcclusionCullingSettings> cullingSettings = new List <OcclusionCullingSettings>();
foreach (Object asset in File.Collection.FetchAssets())
{
if (asset.ClassID == ClassIDType.OcclusionCullingSettings)
{
OcclusionCullingSettings cullingSetting = (OcclusionCullingSettings)asset;
if (cullingSetting.OcclusionCullingData.IsAsset(cullingSetting.File, this))
{
cullingSettings.Add(cullingSetting);
}
}
}
int maxRenderer = Scenes.Max(j => j.IndexRenderers + j.SizeRenderers);
m_staticRenderers = new SceneObjectIdentifier[maxRenderer];
int maxPortal = Scenes.Max(j => j.IndexPortals + j.SizePortals);
m_portals = new SceneObjectIdentifier[maxPortal];
foreach (OcclusionCullingSettings cullingSetting in cullingSettings)
{
int sceneIndex = Scenes.IndexOf(t => t.Scene == cullingSetting.SceneGUID);
if (sceneIndex == -1)
{
Logger.Log(LogType.Error, LogCategory.Export, $"Unable to find scene data with GUID {cullingSetting.SceneGUID} in {ValidName}");
continue;
}
OcclusionScene scene = Scenes[sceneIndex];
if (scene.SizeRenderers != cullingSetting.StaticRenderers.Count)
{
throw new Exception($"Scene renderer count {scene.SizeRenderers} doesn't match with given {cullingSetting.StaticRenderers.Count}");
}
if (scene.SizePortals != cullingSetting.Portals.Count)
{
throw new Exception($"Scene portal count {scene.SizePortals} doesn't match with given {cullingSetting.Portals.Count}");
}
SetIDs(container, cullingSetting, scene);
}
}
private static SceneObjectIdentifier CreateObjectID(IExportContainer container, Object asset)
{
string id = container.GetExportID(asset);
long lid = long.Parse(id);
SceneObjectIdentifier soId = new SceneObjectIdentifier(lid, 0);
return(soId);
}
private void SetExportData(IExportContainer container)
{
// if < 3.0.0 this asset doesn't exist
// 3.0.0 to 5.5.0 this asset is created by culling settings so it has set data already
if (OcclusionCullingSettings.IsReadPVSData(container.Version))
{
return;
}
// if >= 5.5.0 and !Release this asset containts renderer data
if (IsReadStaticRenderers(container.Flags))
{
return;
}
// if >= 5.5.0 and Release this asset doesn't containt renderers data so we need to create it
List <OcclusionCullingSettings> cullingSettings = new List <OcclusionCullingSettings>();
foreach (ISerializedFile file in File.Collection.Files)
{
foreach (Object asset in file.FetchAssets())
{
if (asset.ClassID == ClassIDType.OcclusionCullingSettings)
{
OcclusionCullingSettings cullingSetting = (OcclusionCullingSettings)asset;
if (Scenes.Any(t => t.Scene == cullingSetting.SceneGUID))
{
cullingSettings.Add(cullingSetting);
}
}
}
}
int maxRenderer = Scenes.Max(j => j.IndexRenderers);
OcclusionScene rscene = Scenes.First(t => t.IndexRenderers == maxRenderer);
m_staticRenderers = new SceneObjectIdentifier[rscene.IndexRenderers + rscene.SizeRenderers];
int maxPortal = Scenes.Max(j => j.IndexPortals);
OcclusionScene pscene = Scenes.First(t => t.IndexPortals == maxPortal);
m_portals = new SceneObjectIdentifier[pscene.IndexPortals + pscene.SizePortals];
foreach (OcclusionCullingSettings cullingSetting in cullingSettings)
{
OcclusionScene scene = Scenes.First(t => t.Scene == cullingSetting.SceneGUID);
if (scene.SizeRenderers != cullingSetting.StaticRenderers.Count)
{
throw new Exception($"Scene renderer count {scene.SizeRenderers} doesn't match with given {cullingSetting.StaticRenderers.Count}");
}
if (scene.SizePortals != cullingSetting.Portals.Count)
{
throw new Exception($"Scene portal count {scene.SizePortals} doesn't match with given {cullingSetting.Portals.Count}");
}
SetIDs(container, cullingSetting, scene);
}
}
private static SceneObjectIdentifier CreateObjectID(IExportContainer container, Object asset)
{
long lid = 0;
if (asset != null)
{
lid = (long)container.GetExportID(asset);
}
SceneObjectIdentifier soId = new SceneObjectIdentifier(lid, 0);
return(soId);
}
public void Initialize(IExportContainer container, OcclusionCullingSettings cullingSetting)
{
m_PVSData = (byte[])cullingSetting.PVSData;
int renderCount = cullingSetting.StaticRenderers.Count;
int portalCount = cullingSetting.Portals.Count;
OcclusionScene scene = new OcclusionScene(cullingSetting.SceneGUID, renderCount, portalCount);
m_scenes = new OcclusionScene[] { scene };
m_staticRenderers = new SceneObjectIdentifier[scene.SizeRenderers];
m_portals = new SceneObjectIdentifier[scene.SizePortals];
SetIDs(container, cullingSetting, scene);
}
public void SetIDs(IExportContainer container,
UtinyGUID guid, IReadOnlyList <PPtr <Renderer> > renderers, IReadOnlyList <PPtr <OcclusionPortal> > portals)
{
if (m_staticRenderers.Length == 0 && renderers.Count != 0 || m_portals.Length == 0 && portals.Count != 0)
{
int maxRenderer = Scenes.Max(j => j.IndexRenderers);
OcclusionScene rscene = Scenes.First(t => t.IndexRenderers == maxRenderer);
m_staticRenderers = new SceneObjectIdentifier[rscene.IndexRenderers + rscene.SizeRenderers];
int maxPortal = Scenes.Max(j => j.IndexPortals);
OcclusionScene pscene = Scenes.First(t => t.IndexPortals == maxPortal);
m_portals = new SceneObjectIdentifier[pscene.IndexPortals + pscene.SizePortals];
}
OcclusionScene curScene = Scenes.First(t => t.Scene == guid);
if (curScene.SizeRenderers != renderers.Count)
{
throw new Exception($"Scene renderer count {curScene.SizeRenderers} doesn't match with given {renderers.Count}");
}
if (curScene.SizePortals != portals.Count)
{
throw new Exception($"Scene portal count {curScene.SizeRenderers} doesn't match with given {renderers.Count}");
}
for (int i = 0; i < renderers.Count; i++)
{
PPtr <Renderer> prenderer = renderers[i];
Renderer renderer = prenderer.FindObject(container);
m_staticRenderers[curScene.IndexRenderers + i] = CreateObjectID(container, renderer);
}
m_portals = new SceneObjectIdentifier[portals.Count];
for (int i = 0; i < portals.Count; i++)
{
PPtr <OcclusionPortal> pportal = portals[i];
OcclusionPortal portal = pportal.FindObject(container);
m_portals[i] = CreateObjectID(container, portal);
}
}
public static void GetRootObjects(List <Collider> colliders, List <GameObject> results)
{
results.Clear();
for (int i = 0; i < colliders.Count; i++)
{
GameObject gameObject = colliders[i].gameObject;
GameObject gameObject2 = UWE.Utils.GetEntityRoot(gameObject);
if (gameObject2 == null)
{
SceneObjectIdentifier componentInParent = gameObject.GetComponentInParent <SceneObjectIdentifier>();
if (componentInParent != null)
{
gameObject2 = componentInParent.gameObject;
}
}
gameObject = ((gameObject2 != null) ? gameObject2 : gameObject);
if (!results.Contains(gameObject))
{
results.Add(gameObject);
}
}
}
public static bool LateUpdatePrefix(PlaceTool __instance)
{
if (__instance.usingPlayer == null || !SnapBuilder.Config.Snapping.Enabled)
{
Inventory.main.quickSlots.SetIgnoreHotkeyInput(false);
return(true);
}
Inventory.main.quickSlots.SetIgnoreHotkeyInput(__instance.rotationEnabled && SnapBuilder.Config.ToggleRotation.Enabled);
Transform aimTransform = Builder.GetAimTransform();
RaycastHit hit;
bool bHit = Physics.Raycast(aimTransform.position, aimTransform.forward, out hit, 5f, PlaceTool.placeLayerMask, QueryTriggerInteraction.Ignore);
Vector3 position = __instance.ghostModel.transform.position;
Quaternion rotation = __instance.ghostModel.transform.rotation;
SnapBuilder.ApplyAdditiveRotation(ref __instance.additiveRotation, out var _);
if (bHit)
{
bHit = SnapBuilder.TryGetSnappedHitPoint(PlaceTool.placeLayerMask, out hit, out Vector3 snappedHitPoint, out Vector3 snappedHitNormal);
if (bHit)
{
position = snappedHitPoint;
PlaceTool.SurfaceType surfaceType = PlaceTool.SurfaceType.Floor;
if (Mathf.Abs(hit.normal.y) < 0.3f)
{
surfaceType = PlaceTool.SurfaceType.Wall;
}
else if (hit.normal.y < 0f)
{
surfaceType = PlaceTool.SurfaceType.Ceiling;
}
if (__instance.rotationEnabled)
{ // New calculation of the rotation
rotation = SnapBuilder.CalculateRotation(ref __instance.additiveRotation, hit, snappedHitPoint, snappedHitNormal, true);
}
else
{ // Calculate rotation in the same manner as the original method
Vector3 forward;
if (__instance.alignWithSurface || surfaceType == PlaceTool.SurfaceType.Wall)
{
forward = hit.normal;
}
else
{
forward = new Vector3(-aimTransform.forward.x, 0f, -aimTransform.forward.z).normalized;
}
rotation = Quaternion.LookRotation(forward, Vector3.up);
if (__instance.rotationEnabled)
{
rotation *= Quaternion.AngleAxis(__instance.additiveRotation, Vector3.up);
}
}
switch (surfaceType)
{
case PlaceTool.SurfaceType.Floor:
__instance.validPosition = __instance.allowedOnGround;
break;
case PlaceTool.SurfaceType.Wall:
__instance.validPosition = __instance.allowedOnWalls;
break;
case PlaceTool.SurfaceType.Ceiling:
__instance.validPosition = __instance.allowedOnCeiling;
break;
}
}
}
if (!bHit)
{ // If there is no new hit, then the position we're snapping to isn't valid
position = aimTransform.position + aimTransform.forward * 1.5f;
rotation = Quaternion.LookRotation(-aimTransform.forward, Vector3.up);
if (__instance.rotationEnabled)
{
rotation *= Quaternion.AngleAxis(__instance.additiveRotation, Vector3.up);
}
}
__instance.ghostModel.transform.position = position;
__instance.ghostModel.transform.rotation = rotation;
if (bHit)
{
Rigidbody componentInParent = hit.collider.gameObject.GetComponentInParent <Rigidbody>();
__instance.validPosition = (__instance.validPosition &&
(componentInParent == null || componentInParent.isKinematic || __instance.allowedOnRigidBody));
}
SubRoot currentSub = Player.main.GetCurrentSub();
bool isInside = Player.main.IsInsideWalkable();
if (bHit && hit.collider.gameObject.CompareTag("DenyBuilding"))
{
__instance.validPosition = false;
}
#if BELOWZERO
if (!__instance.allowedUnderwater && hit.point.y < 0)
{
__instance.validPosition = false;
}
#endif
if (bHit && ((__instance.allowedInBase && isInside) || (__instance.allowedOutside && !isInside)))
{
GameObject root = UWE.Utils.GetEntityRoot(hit.collider.gameObject);
if (!root)
{
SceneObjectIdentifier identifier = hit.collider.GetComponentInParent <SceneObjectIdentifier>();
if (identifier)
{
root = identifier.gameObject;
}
else
{
root = hit.collider.gameObject;
}
}
if (currentSub == null)
{
__instance.validPosition &= Builder.ValidateOutdoor(root);
}
if (!__instance.allowedOnConstructable)
{
__instance.validPosition &= root.GetComponentInParent <Constructable>() == null;
}
__instance.validPosition &= Builder.CheckSpace(position, rotation, PlaceTool.localBounds, PlaceTool.placeLayerMask, hit.collider);
}
else
{
__instance.validPosition = false;
}
MaterialExtensions.SetColor(__instance.renderers, ShaderPropertyID._Tint,
__instance.validPosition ? PlaceTool.placeColorAllow : PlaceTool.placeColorDeny);
if (__instance.hideInvalidGhostModel)
{
__instance.ghostModel.SetActive(__instance.validPosition);
}
return(false);
}
