public override void OnSingleClick(ProceduralObject obj)
{
if (legacyAndProjectedVertices != null)
{
if (legacyAndProjectedVertices.Keys.Contains(obj))
{
return;
}
}
if (obj.isRootOfGroup && logic.selectedGroup == null)
{
if (objectsAsColliders.ContainsKey(obj))
{
obj.group.objects.ForEach(o => { RemoveObjectAsCollider(o); });
}
else
{
obj.group.objects.ForEach(o => { AddObjectAsCollider(o); });
}
}
else
{
if (objectsAsColliders.ContainsKey(obj))
{
RemoveObjectAsCollider(obj);
}
else
{
AddObjectAsCollider(obj);
}
}
}
public void Edit(ProceduralObject obj, Vector2 position)
{
editingObject = obj;
scrollParams = Vector2.zero;
scrollTex = Vector2.zero;
movingField = -1;
dragTexPos = Vector2.zero;
windowRect.position = position;
Texture tex = ProceduralUtils.GetOriginalTexture(obj);
originalTex = new Texture2D(tex.width, tex.height, TextureFormat.RGBA32, false);
originalTex.SetPixels(((Texture2D)tex).GetPixels());
windowTex = (Texture2D)GameObject.Instantiate(originalTex);
// load stored data if it exists
if (editingObject.m_textParameters == null)
{
parameters = new TextParameters();
parametersOld = new TextParameters();
}
else
{
parameters = editingObject.m_textParameters;
parametersOld = TextParameters.Clone(editingObject.m_textParameters, false);
windowTex = parameters.ApplyParameters(originalTex);
editingObject.m_material.mainTexture = windowTex as Texture;
}
updateTimer = 0f;
dragTimer = 0f;
zoomFactor = 1f;
if (!showWindow)
{
showWindow = true;
}
}
public void BuildData(ProceduralObject obj)
{
data = new Dictionary <SerializableVector3, List <int> >();
var original = obj.baseInfoType == "PROP" ? obj._baseProp.m_mesh.vertices : obj._baseBuilding.m_mesh.vertices;
for (int i = 0; i < obj.vertices.Length; i++)
{
var v = obj.vertices[i];
if (v.Position == original[v.Index])
{
continue;
}
List <int> list;
if (data.TryGetValue(v.Position, out list))
{
list.Add(v.Index);
}
else
{
list = new List <int>();
list.Add(v.Index);
data.Add(v.Position, list);
}
}
}
public void ApplyDataToObject(ProceduralObject obj)
{
if (data == null)
{
return;
}
if (data.Count == 0)
{
return;
}
var vertices = obj.m_mesh.vertices;
foreach (var kvp in data)
{
if (kvp.Value == null)
{
return;
}
if (kvp.Value.Count == 0)
{
return;
}
for (int i = 0; i < kvp.Value.Count; i++)
{
vertices[kvp.Value[i]] = kvp.Key;
}
}
obj.m_mesh.SetVertices(new List <Vector3>(vertices));
}
public ProceduralObjectContainer(ProceduralObject baseObject)
{
id = baseObject.id;
basePrefabName = baseObject.basePrefabName;
objectType = baseObject.baseInfoType;
// meshStatus = baseObject.meshStatus;
renderDistance = baseObject.renderDistance;
position = new SerializableVector3(baseObject.m_position);
rotation = new SerializableQuaternion(baseObject.m_rotation);
scale = 1f;
// if (meshStatus > 0)
vertices = SerializableVector3.ToSerializableArray(baseObject.m_mesh.vertices);
hasCustomTexture = baseObject.customTexture != null;
visibility = baseObject.m_visibility;
disableRecalculation = baseObject.disableRecalculation;
layerId = (baseObject.layer == null) ? 0 : baseObject.layer.m_id;
// flipFaces = baseObject.flipFaces;
tilingFactor = baseObject.tilingFactor;
if (baseObject.m_textParameters != null)
{
textParam = TextParameters.Clone(baseObject.m_textParameters, false);
for (int i = 0; i < textParam.Count(); i++)
{
textParam[i].serializableColor = null;
}
}
if (hasCustomTexture == true)
{
customTextureName = baseObject.customTexture.name;
}
else
{
customTextureName = string.Empty;
}
}
public override void OnSingleClick(ProceduralObject obj)
{
var height = obj.m_position.y;
foreach (var po in selection)
{
if (po.isRootOfGroup && logic.selectedGroup == null)
{
float diffToApply = po.m_position.y - height;
foreach (var o in po.group.objects)
{
o.historyEditionBuffer.InitializeNewStep(EditingStep.StepType.position, null);
o.SetPosition(new Vector3(o.m_position.x, o.m_position.y - diffToApply, o.m_position.z));
o.historyEditionBuffer.ConfirmNewStep(null);
}
}
else
{
po.historyEditionBuffer.InitializeNewStep(EditingStep.StepType.position, null);
po.SetPosition(new Vector3(po.m_position.x, height, po.m_position.z));
po.historyEditionBuffer.ConfirmNewStep(null);
}
}
ExitAction();
}
public void CloseWindow()
{
CloseCharTable();
showWindow = false;
editingObject = null;
originalTex = null;
windowTex = null;
parameters = null;
parametersOld = null;
colorPickerSelected = null;
if (selectedField != null)
{
selectedField.expandFontsSelector = false;
selectedField.scrollFontsPos = Vector2.zero;
selectedField = null;
}
scrollParams = Vector2.zero;
scrollTex = Vector2.zero;
updateTimer = 0f;
dragTimer = 0f;
placingText = false;
placingRect = false;
_justPlacedTextNowFocusField = false;
placingRectFirstpoint = Vector2.down;
zoomFactor = 1f;
movingField = -1;
dragTexPos = Vector2.zero;
// GUIUtils.SetMouseScrolling(true);
}
public override void OnSingleClick(ProceduralObject obj)
{
foreach (var po in selection)
{
if (po.isRootOfGroup && logic.selectedGroup == null)
{
Quaternion diff = obj.m_rotation * Quaternion.Inverse(po.m_rotation);
foreach (var o in po.group.objects)
{
o.historyEditionBuffer.InitializeNewStep(EditingStep.StepType.moveTo, null);
o.SetRotation(diff * o.m_rotation);
if (o != po)
{
o.SetPosition(VertexUtils.RotatePointAroundPivot(o.m_position, po.m_position, diff));
}
o.historyEditionBuffer.ConfirmNewStep(null);
}
}
else
{
po.historyEditionBuffer.InitializeNewStep(EditingStep.StepType.rotation, null);
po.SetRotation(obj.m_rotation);
po.historyEditionBuffer.ConfirmNewStep(null);
}
}
ExitAction();
}
public List <POModule> CloneModuleList(List <POModule> modules, ProceduralObject obj)
{
if (modules == null)
{
return(new List <POModule>());
}
if (modules.Count == 0)
{
return(new List <POModule>());
}
var list = new List <POModule>();
foreach (var m in modules)
{
POModule clone;
try { clone = m.Clone(); }
catch (Exception e)
{
Debug.LogError("[ProceduralObjects] Error inside module Clone() method!\n" + e);
continue;
}
list.Add(clone);
ModuleManager.instance.modules.Add(clone);
if (clone.enabled)
{
ModuleManager.instance.enabledModules.Add(clone);
}
clone.parentObject = obj;
try { clone.OnModuleCreated(ProceduralObjectsLogic.instance); }
catch (Exception e) { Debug.LogError("[ProceduralObjects] Error inside module OnModuleCreated() method!\n" + e); }
}
return(list);
}
public void DeleteAllModules(ProceduralObject obj)
{
if (obj.m_modules == null)
{
return;
}
if (obj.m_modules.Count == 0)
{
return;
}
if (obj == selectedObject && showWindow)
{
CloseWindow(true);
}
foreach (var m in obj.m_modules)
{
if (!modules.Contains(m))
{
continue;
}
try { m.OnModuleRemoved(logic); }
catch (Exception e) { Debug.LogError("[ProceduralObjects] Error inside module OnModuleRemoved() method!\n" + e); }
modules.Remove(m);
if (enabledModules.Contains(m))
{
enabledModules.Remove(m);
}
}
obj.m_modules.Clear();
}
public void Pick(ProceduralObject obj)
{
if (!pickerPrefabNames.Contains(obj.basePrefabName))
{
pickerPrefabNames.Add(obj.basePrefabName);
}
DisableAll();
c_picker = true;
}
public bool FiltersAllow(ProceduralObject obj)
{
if (ProceduralObjectsLogic.instance.selectedGroup == null)
{
if (obj.isRootOfGroup)
{
if (c_groups)
{
return(true);
}
else
{
return(false);
}
}
}
if (c_picker)
{
if (pickerPrefabNames.Count > 0)
{
if (pickerPrefabNames.Any(s => s == obj.basePrefabName))
{
return(true);
}
}
}
if (obj.baseInfoType == "PROP")
{
if (c_decals)
{
if (obj._baseProp.m_isDecal)
{
return(true);
}
}
if (c_surfaces)
{
if (obj.isPloppableAsphalt)
{
return(true);
}
}
if (c_props)
{
if (!obj._baseProp.m_isDecal && !obj.isPloppableAsphalt)
{
return(true);
}
}
}
if (c_buildings && obj.baseInfoType == "BUILDING")
{
return(true);
}
return(false);
}
public static RotationWizardData GetCurrentRotationData(ProceduralObject obj)
{
var data = new RotationWizardData();
data.initialMousePosition = Input.mousePosition;
data.initialRotation = obj.m_rotation;
data._initMousePosXGUI = data.initialMousePosition.x;
data.clickTime = 0f;
return(data);
}
public POSerializableMeshData(ProceduralObject obj)
{
if (obj.meshStatus == 1)
{
data = null;
}
else
{
this.BuildData(obj);
}
}
public override void OnSingleClick(ProceduralObject obj)
{
if (firstPointSet)
{
AlignBetween2Points(obj.m_position);
ExitAction();
}
else
{
firstPoint = obj.m_position;
firstPointSet = true;
}
}
public POModule AddModule(POModuleType type, ProceduralObject obj)
{
POModule module = (POModule)Activator.CreateInstance(type.ModuleType);
module.ModuleType = type;
module.parentObject = obj;
obj.m_modules.Add(module);
module.enabled = true;
modules.Add(module);
enabledModules.Add(module);
try { module.OnModuleCreated(logic); }
catch (Exception e) { Debug.LogError("[ProceduralObjects] Error inside module OnModuleCreated() method!\n" + e); }
return(module);
}
void RemoveObjectAsCollider(ProceduralObject obj)
{
if (objectsAsColliders == null)
{
objectsAsColliders = new Dictionary <ProceduralObject, GameObject>();
return;
}
if (!objectsAsColliders.ContainsKey(obj))
{
return;
}
UnityEngine.Object.Destroy(objectsAsColliders[obj]);
objectsAsColliders.Remove(obj);
CalculateProjection();
ApplyProjection(projectionForce);
}
public override void Process(uint seed)
{
List <ProceduralObject> proceduralObjects = ((WorldSetup)SingletonComponent <WorldSetup> .Instance).ProceduralObjects;
if (!World.Cached)
{
for (int index = 0; index < proceduralObjects.Count; ++index)
{
ProceduralObject proceduralObject = proceduralObjects[index];
if (Object.op_Implicit((Object)proceduralObject))
{
proceduralObject.Process();
}
}
}
proceduralObjects.Clear();
}
public static void FlattenSelection(ProceduralObject obj, List <int> editingVertexIndex, Vertex[] buffer)
{
obj.historyEditionBuffer.InitializeNewStep(EditingStep.StepType.vertices, buffer);
var bounds = new Bounds(buffer.First(v => v.Index == editingVertexIndex[0]).Position, Vector3.zero);
var vertices = buffer.Where(v => (editingVertexIndex.Contains(v.Index) || (v.IsDependent && editingVertexIndex.Contains(v.DependencyIndex))));
foreach (Vertex v in vertices)
{
bounds.Encapsulate(v.Position);
}
foreach (Vertex v in vertices)
{
v.Position.y = bounds.center.y;
}
obj.historyEditionBuffer.ConfirmNewStep(buffer);
}
public override void Process(uint seed)
{
List <ProceduralObject> proceduralObjects = SingletonComponent <WorldSetup> .Instance.ProceduralObjects;
if (!World.Cached)
{
for (int i = 0; i < proceduralObjects.Count; i++)
{
ProceduralObject item = proceduralObjects[i];
if (item)
{
item.Process();
}
}
}
proceduralObjects.Clear();
}
public void CloseWindow()
{
CloseCharTable();
showWindow = false;
editingObject = null;
originalTex = null;
windowTex = null;
parameters = null;
parametersOld = null;
scrollParams = Vector2.zero;
scrollTex = Vector2.zero;
updateTimer = 0f;
dragTimer = 0f;
zoomFactor = 1f;
movingField = -1;
dragTexPos = Vector2.zero;
// GUIUtils.SetMouseScrolling(true);
}
private static void HandleRemove(ProceduralObject obj)
{
var ast = obj as ProceduralAsteroid;
if (ast?.VoxelMap == null || ast.VoxelMap.Save)
{
return;
}
lock (ast)
{
if (!ast.m_removeQueued)
{
ast.Module.m_asteroidsToRemove.Enqueue(ast);
}
ast.m_spawnQueued = false;
ast.m_removeQueued = true;
}
}
// move vertices
public void ApplyToNewPosition(Vector3 newHitPoint, ProceduralObject obj)
{
if (relativePositions == null)
{
return;
}
if (relativePositions.Count == 0)
{
return;
}
var referencial = VertexUtils.RotatePointAroundPivot(newHitPoint, originHitPoint, Quaternion.Inverse(obj.m_rotation));
foreach (KeyValuePair <Vertex, Vector3> kvp in relativePositions)
{
var newpos = kvp.Value + referencial;
kvp.Key.Position = new Vector3(newpos.x, kvp.Key.Position.y, newpos.z);
}
}
void AddObjectAsCollider(ProceduralObject obj)
{
if (objectsAsColliders == null)
{
objectsAsColliders = new Dictionary <ProceduralObject, GameObject>();
}
GameObject go = new GameObject("PO_ColliderProject_" + obj.id.ToString());
go.transform.position = obj.m_position;
go.transform.rotation = obj.m_rotation;
var collider = go.AddComponent <MeshCollider>();
collider.convex = false;
collider.isTrigger = false;
collider.sharedMesh = obj.overlayRenderMesh;
objectsAsColliders.Add(obj, go);
CalculateProjection();
ApplyProjection(projectionForce);
}
public override void OnSingleClick(ProceduralObject obj)
{
if (!selection.Contains(obj))
{
return;
}
if (clickedCenter)
{
maxObjects = new KeyValuePair <ProceduralObject, ProceduralObject>(maxObjects.Key, obj);
}
else
{
maxObjects = new KeyValuePair <ProceduralObject, ProceduralObject>(obj, maxObjects.Value);
}
clickedCenter = !clickedCenter;
UpdateGradient();
}
public void ShowModulesWindow(ProceduralObject obj)
{
ProceduralObjectsLogic.PlaySound();
windowRect.position = new Vector2(logic.window.xMax, logic.window.y);
if (openedUIModules == null)
{
openedUIModules = new List <POModule>();
}
else
{
closeModulesThatAreRequired();
}
if (obj.m_modules == null)
{
obj.m_modules = new List <POModule>();
}
searchTextfield = "";
UpdateSearchResults();
selectedObject = obj;
showWindow = true;
}
public void ActionButton(Rect rect, ProceduralObject obj, List <int> selected, Vertex[] buffer, Action apply)
{
GUI.BeginGroup(rect);
var count = selected.Count;
if ((ctActionType == POActionType.Selection && count <= 1) || (ctActionType == POActionType.SingleSelAtLeast && count == 0))
{
GUI.color = Color.gray;
GUI.Box(new Rect(0, 0, rect.width, 24), string.Empty);
if (icon != null)
{
GUI.Label(new Rect(3, 2, 20, 20), icon);
}
GUI.Label(new Rect(24, 2, rect.width - 29, 22), "<i>" + LocalizationManager.instance.current["CTA_" + identifier] + "</i>");
GUI.color = Color.white;
}
else
{
if (GUI.Button(new Rect(0, 0, rect.width, 24), string.Empty))
{
ProceduralObjectsLogic.PlaySound();
if (ctActionType == POActionType.Selection || ctActionType == POActionType.SingleSelAtLeast)
{
SelectionAction.Invoke(obj, selected, buffer);
}
else if (ctActionType == POActionType.Global)
{
GlobalAction.Invoke(obj, buffer);
}
apply.Invoke();
}
if (icon != null)
{
GUI.Label(new Rect(4, 2, 20, 20), icon);
}
GUI.Label(new Rect(23, 2, rect.width - 28, 22), LocalizationManager.instance.current["CTA_" + identifier]);
}
GUI.EndGroup();
}
public ProceduralObjectContainer(ProceduralObject baseObject)
{
id = baseObject.id;
basePrefabName = baseObject.basePrefabName;
objectType = baseObject.baseInfoType;
renderDistance = baseObject.renderDistance;
renderDistLocked = baseObject.renderDistLocked;
position = new SerializableVector3(baseObject.m_position);
rotation = new SerializableQuaternion(baseObject.m_rotation);
scale = 1f;
if (baseObject.group != null)
{
belongsToGroup = true;
if (baseObject.isRootOfGroup)
{
groupRootId = -1; // = we are a group root
}
else
{
groupRootId = baseObject.group.root.id;
}
}
else
{
belongsToGroup = false; // we don't have a group
}
color = baseObject.m_color;
// if (meshStatus > 0)
meshStatus = baseObject.meshStatus;
if (meshStatus != 1)
{
/*
* try
* {
* serializedMeshData = new POSerializableMeshData(baseObject);
* vertices = null;
* }
* catch (Exception e)
* {
* Debug.LogWarning("[ProceduralObjects] Warning : error while compressing Mesh data for object #" + baseObject.id + " (" + baseObject.baseInfoType + ", " + baseObject.basePrefabName + "). Saving uncompressed raw data instead\n" + e);
*
*
* */
vertices = SerializableVector3.ToSerializableArray(baseObject.m_mesh.vertices);
serializedMeshData = null;
// }
}
else
{
serializedMeshData = null;
vertices = null;
}
hasCustomTexture = baseObject.customTexture != null;
visibility = baseObject.m_visibility;
disableRecalculation = baseObject.disableRecalculation;
normalsRecalculation = baseObject.normalsRecalcMode;
layerId = (baseObject.layer == null) ? 0 : baseObject.layer.m_id;
flipFaces = baseObject.flipFaces;
disableCastShadows = baseObject.disableCastShadows;
// recalculateNormals = baseObject.recalculateNormals;
tilingFactor = baseObject.tilingFactor;
if (baseObject.m_textParameters != null)
{
textParam = TextParameters.Clone(baseObject.m_textParameters, false);
for (int i = 0; i < textParam.Count(); i++)
{
textParam[i].serializableColor = null;
}
}
if (hasCustomTexture == true)
{
customTextureName = baseObject.customTexture.name;
}
else
{
customTextureName = string.Empty;
}
modulesData = new List <Dictionary <string, string> >();
if (baseObject.m_modules != null)
{
foreach (POModule m in baseObject.m_modules)
{
modulesData.Add(m._get_data(true));
}
}
}
public static List <POModule> LoadModulesFromData(List <Dictionary <string, string> > modulesData, bool fromSaveGame, ProceduralObject obj)
{
var modules = new List <POModule>();
if (modulesData != null)
{
if (modulesData.Count > 0)
{
foreach (var data in modulesData)
// LOAD DATA FROM MODULES
{
if (data.Count == 0)
{
Debug.LogError("[ProceduralObjects] Couldn't find any data for a module");
continue;
}
if (!ModuleManager.CanLoadModule(data))
{
Debug.LogError("[ProceduralObjects] Couldn't find Module Type for the module. Maybe you are missing a PO Module mod ?");
continue;
}
try
{
var m = ModuleManager.LoadModule(data, fromSaveGame);
if (fromSaveGame)
{
ModuleManager.instance.modules.Add(m);
if (m.enabled)
{
ModuleManager.instance.enabledModules.Add(m);
}
m.parentObject = obj;
try { m.OnModuleCreated(ProceduralObjectsLogic.instance); }
catch (Exception e) { Debug.LogError("[ProceduralObjects] Error inside module OnModuleCreated() method!\n" + e); }
}
modules.Add(m);
}
catch (Exception e)
{
Debug.LogError("[ProceduralObjects] Failed to load a module. " + e);
}
}
}
}
return(modules);
}
public override void OnSingleClick(ProceduralObject obj)
{
ProceduralObjectsLogic.PlaySound(2);
ExitAction();
}
