public static void Scale(this ProceduralObject obj, Vertex[] vertices, float scaleFactor)
{
foreach (Vertex v in vertices)
{
v.Position = new Vector3(v.Position.x * scaleFactor, v.Position.y * scaleFactor, v.Position.z * scaleFactor);
}
}
private static void conformSelection(ProceduralObject obj, List <int> editingVertexIndex, Vertex[] buffer, bool andNetBuildings)
{
obj.historyEditionBuffer.InitializeNewStep(EditingStep.StepType.vertices, buffer);
var bounds = new Bounds(ProceduralUtils.VertexWorldPosition(buffer.First(v => v.Index == editingVertexIndex[0]).Position, obj), Vector3.zero);
var vertices = buffer.Where(v => (editingVertexIndex.Contains(v.Index) || (v.IsDependent && editingVertexIndex.Contains(v.DependencyIndex))));
foreach (Vertex v in vertices)
{
bounds.Encapsulate(ProceduralUtils.VertexWorldPosition(v.Position, obj));
}
Vector3 bottomPoint = bounds.center;
bottomPoint.y -= bounds.extents.y;
var boundsOffset = new Vector3(0, bounds.size.y, 0);
foreach (Vertex v in vertices)
{
var worldPos = ProceduralUtils.VertexWorldPosition(v, obj);
var yDiff = worldPos.y - bottomPoint.y;
worldPos = ProceduralUtils.NearestGroundPointVertical(worldPos + boundsOffset, andNetBuildings);
worldPos.y += yDiff;
v.Position = Quaternion.Inverse(obj.m_rotation) * (worldPos - obj.m_position);
if (obj.isPloppableAsphalt)
{
v.Position = v.Position.RevertPloppableAsphaltPosition();
}
}
obj.historyEditionBuffer.ConfirmNewStep(buffer);
}
public static void ClearVertexSelection(ProceduralObject obj)
{
foreach (Vertex v in obj.vertices)
{
v._selected = false;
}
}
public void Remove(ProceduralObjectsLogic logic, ProceduralObject po)
{
if (!objects.Contains(po))
{
return;
}
po.group = null;
po.isRootOfGroup = false;
if (objects.Count == 1)
{
logic.groups.Remove(this);
if (logic.selectedGroup == this)
{
logic.selectedGroup = null;
}
return;
}
if (objects.Contains(po))
{
objects.Remove(po);
}
if (root == po)
{
ChooseFirstAsRoot();
}
}
public static void LoadContainerData(this ProceduralObjectsLogic logic, ProceduralObjectContainer[] containerArray)
{
logic.proceduralObjects = new List <ProceduralObject>();
if (logic.availableProceduralInfos == null)
{
logic.availableProceduralInfos = CreateProceduralInfosList();
}
if (logic.availableProceduralInfos.Count < 0)
{
logic.availableProceduralInfos = CreateProceduralInfosList();
}
foreach (var c in containerArray)
{
try
{
var obj = new ProceduralObject(c, logic.basicTextures, logic.layerManager);
if (obj.RequiresUVRecalculation && !obj.disableRecalculation)
{
obj.m_mesh.uv = Vertex.RecalculateUVMap(obj, Vertex.CreateVertexList(obj));
}
if (!obj.isPloppableAsphalt)
{
obj.m_mesh.RecalculateNormals(60);
obj.m_mesh.RecalculateBounds();
}
logic.proceduralObjects.Add(obj);
}
catch (Exception e)
{
Debug.LogError("[ProceduralObjects] Failed to load a Procedural Object : \n" + e.GetType().ToString() + " : " + e.Message + "\n" + e.StackTrace);
}
}
}
public bool CanRenderSingle(ProceduralObject obj, bool nightTime)
{
if (obj.m_modules != null)
{
if (obj.m_modules.Count != 0)
{
foreach (var module in obj.m_modules)
{
if (module.enabled)
{
try
{
if (!module.RenderParentThisFrame(ProceduralObjectsLogic.instance))
{
return(false);
}
}
catch (Exception e) { Debug.LogError("[ProceduralObjects] Error inside module RenderParentThisFrame() method!\n" + e); }
}
}
}
}
if (obj.m_visibility == ProceduralObjectVisibility.Always)
{
return(true);
}
return((obj.m_visibility == ProceduralObjectVisibility.NightOnly && nightTime) || (obj.m_visibility == ProceduralObjectVisibility.DayOnly && !nightTime));
}
public float CalculateRenderDistance(ProceduralObject obj, bool resetIfNotDynamic)
{
if (obj.renderDistLocked)
{
return(obj.renderDistance);
}
if (!calculateDynamically)
{
if (resetIfNotDynamic)
{
return((obj.baseInfoType == "PROP") ? ProceduralObjectsMod.PropRenderDistance.value : ProceduralObjectsMod.BuildingRenderDistance.value);
}
return(obj.renderDistance);
}
float multiplier = ProceduralObjectsMod.DynamicRDMultiplier.value;
float supp = 200f;
float threshold = ProceduralObjectsMod.DynamicRDMinThreshold.value;
var size = obj.m_mesh.bounds.size;
float max1 = Mathf.Max(size.x, size.y, size.z);
float max2 = SecondMax(size.x, size.y, size.z);
return(Mathf.Clamp(Mathf.Ceil((multiplier * (max1 + max2) + supp) / 10f) * 10f, threshold, 16000));
}
public static Vector3 VertexWorldPosition(Vertex vertex, ProceduralObject obj)
{
if (obj.isPloppableAsphalt)
{
return(obj.m_rotation * vertex.Position.PloppableAsphaltPosition() + obj.m_position);
}
return(obj.m_rotation * vertex.Position + obj.m_position);
}
public static void CallPOCloning(ProceduralObject src)
{
if (queuedCloning.Contains(src))
{
return;
}
queuedCloning.Add(src);
}
public static Vector3 VertexWorldPosition(Vector3 localPos, ProceduralObject obj)
{
if (obj.isPloppableAsphalt)
{
return(obj.m_rotation * localPos.PloppableAsphaltPosition() + obj.m_position);
}
return(obj.m_rotation * localPos + obj.m_position);
}
public void AddToGroup(ProceduralObject po)
{
if (objects.Contains(po))
{
return;
}
objects.Add(po);
po.group = this;
}
public static POGroup CreateGroupWithRoot(ProceduralObject root)
{
var group = new POGroup();
group.objects.Add(root);
root.isRootOfGroup = true;
root.group = group;
group.root = root;
return(group);
}
public HistoryBuffer(ProceduralObject obj)
{
stepsDone = new List <EditingStep>();
stepsUndone = new List <EditingStep>();
this.obj = obj;
prevTempBuffer = null;
prevTempPos = Vector3.zero;
prevTempRot = Quaternion.identity;
currentStepType = EditingStep.StepType.none;
}
public static bool IsPloppableAsphalt(this ProceduralObject obj)
{
string name = "";
try { name = obj._baseProp.m_mesh.name; }
catch { return(false); }
return((name == "ploppableasphalt-prop") ||
(name == "ploppablecliffgrass") ||
(name == "ploppablegravel"));
}
public static void ResetOriginalMesh(this ProceduralObject obj)
{
var originalVertices = (obj.baseInfoType == "PROP") ? obj._baseProp.m_mesh.vertices : obj._baseBuilding.m_mesh.vertices;
for (int i = 0; i < obj.vertices.Length; i++)
{
obj.vertices[i].Position = originalVertices[i];
}
obj.ApplyModelChange();
}
public static Texture GetOriginalTexture(ProceduralObject obj)
{
if (obj.customTexture)
{
return(obj.customTexture as Texture);
}
else
{
return(GetBasePrefabMainTex(obj));
}
}
public void RedoPosRotMoveTo(ProceduralObject obj)
{
if (type == StepType.position || type == StepType.moveTo)
{
obj.SetPosition(positions.Value);
}
if (type == StepType.rotation || type == StepType.moveTo)
{
obj.SetRotation(rotations.Value);
}
}
public void RedoPosRotMoveTo(ProceduralObject obj)
{
if (type == StepType.position || type == StepType.moveTo)
{
obj.m_position = positions.Value;
}
if (type == StepType.rotation || type == StepType.moveTo)
{
obj.m_rotation = rotations.Value;
}
}
public static Vector2[] DefaultUVMap(ProceduralObject po)
{
if (po.baseInfoType == "PROP")
{
return(Resources.FindObjectsOfTypeAll <PropInfo>().FirstOrDefault(p => p.name == po.basePrefabName).m_mesh.uv);
}
else
{
return(Resources.FindObjectsOfTypeAll <BuildingInfo>().FirstOrDefault(b => b.name == po.basePrefabName).m_mesh.uv);
}
}
public static Texture GetBasePrefabMainTex(ProceduralObject obj)
{
if (obj.baseInfoType == "PROP")
{
return(obj._baseProp.m_material.mainTexture);
}
else
{
return(obj._baseBuilding.m_material.mainTexture);
}
}
public AdvancedEditionManager(ProceduralObject obj, Action undo, Action redo, Action apply)
{
m_object = obj;
oldTilingFactor = obj.tilingFactor;
winRect = new Rect(555, 100, 400, 326);
stretchFactor = 10;
showWindow = false;
this.undo = undo;
this.redo = redo;
this.apply = apply;
}
public static void AddPOToMIVisibleObj(ProceduralObject obj)
{
var mi_obj = t_MIPOobj.GetConstructor(new Type[] { typeof(object) }).Invoke(new object[] { obj });
uint mi_id = (uint)(obj.id + 1);
var visibleObjects = t_MIPOManager.GetField("visibleObjects", flags).GetValue(MIPOManager);
visibleObjects.GetType().GetMethod("Add").Invoke(visibleObjects, new object[] { mi_id, mi_obj });
var visibleIds = t_MIPOManager.GetField("visibleIds", flags).GetValue(MIPOManager);
visibleIds.GetType().GetMethod("Add").Invoke(visibleIds, new object[] { mi_id });
}
public static bool TryRetrieveClone(ProceduralObject src, out ProceduralObject clone, out uint cloneId)
{
if (queuedCloning.Contains(src) || !doneCloning.ContainsKey(src))
{
clone = null;
cloneId = 0;
return(false);
}
clone = doneCloning[src];
cloneId = (uint)clone.id;
doneCloning.Remove(src);
return(true);
}
public static void InitializeAsPO(InstanceID target, ProceduralObject po)
{
if (po.meshStatus != 1)
{
if (po.RequiresUVRecalculation && !po.disableRecalculation)
{
po.m_mesh.uv = Vertex.RecalculateUVMap(po, Vertex.CreateVertexList(po));
}
}
po.RecalculateBoundsNormalsExtras(po.meshStatus);
AddPOToMIVisibleObj(po);
t_MIPOLogic.GetMethod("Paste").Invoke(MIPOLogic, new object[] { null, target, po.id });
}
public static void AlignVertices(ProceduralObject obj, List <int> editingVertexIndex, Vertex[] buffer)
{
obj.historyEditionBuffer.InitializeNewStep(EditingStep.StepType.vertices, buffer);
var vertices = buffer.Where(v => (editingVertexIndex.Contains(v.Index) || (v.IsDependent && editingVertexIndex.Contains(v.DependencyIndex))));
var outmost = OutmostPoints(vertices.ToArray());
Vector3 diffVector = outmost.Value - outmost.Key;
foreach (var v in vertices)
{
v.Position = outmost.Key + Vector3.Project(v.Position - outmost.Key, diffVector);
}
obj.historyEditionBuffer.ConfirmNewStep(buffer);
}
public void ChooseAsRoot(ProceduralObject obj)
{
if (!objects.Contains(obj))
{
return;
}
if (obj.isRootOfGroup && obj.group == this && root == obj)
{
return;
}
root.isRootOfGroup = false;
root = obj;
obj.isRootOfGroup = true;
}
public static void MirrorZ(Vertex[] vertices, ProceduralObject obj)
{
for (int i = 0; i < vertices.Length; i++)
{
vertices[i].Position.z = -vertices[i].Position.z;
}
obj.flipFaces = !obj.flipFaces;
VertexUtils.flipFaces(obj);
if (obj.normalsRecalcMode == NormalsRecalculation.None && !obj.IsPloppableAsphalt())
{
obj.normalsRecalcMode = NormalsRecalculation.Default;
}
obj.RecalculateNormals();
}
public static Vector2[] RecalculateUVMap(ProceduralObject po, Vertex[] vertices)
{
if (po.basePrefabName.Contains("Cube"))
{
// works all good
Vector2[] uvmap = new Vector2[] {
Vector2.zero,
new Vector2(Vector3.Distance(vertices[2].Position, vertices[1].Position) / po.tilingFactor, Vector3.Distance(vertices[3].Position, vertices[1].Position) / po.tilingFactor),
new Vector2(0, Vector3.Distance(vertices[0].Position, vertices[2].Position) / po.tilingFactor),
new Vector2(Vector3.Distance(vertices[0].Position, vertices[3].Position) / po.tilingFactor, 0),
new Vector2(0, Vector3.Distance(vertices[9].Position, vertices[4].Position) / po.tilingFactor),
new Vector2(Vector3.Distance(vertices[4].Position, vertices[5].Position) / po.tilingFactor, Vector3.Distance(vertices[8].Position, vertices[5].Position) / po.tilingFactor),
new Vector2(Vector3.Distance(vertices[11].Position, vertices[6].Position) / po.tilingFactor, Vector3.Distance(vertices[6].Position, vertices[14].Position) / po.tilingFactor),
new Vector2(Vector3.Distance(vertices[17].Position, vertices[7].Position) / po.tilingFactor, Vector3.Distance(vertices[7].Position, vertices[15].Position) / po.tilingFactor),
new Vector2(Vector3.Distance(vertices[9].Position, vertices[8].Position) / po.tilingFactor, 0), //8
Vector2.zero, //9
Vector2.zero, //10
new Vector2(0, Vector3.Distance(vertices[10].Position, vertices[11].Position) / po.tilingFactor),
new Vector2(0, Vector3.Distance(vertices[12].Position, vertices[22].Position) / po.tilingFactor),
new Vector2(Vector3.Distance(vertices[12].Position, vertices[13].Position) / po.tilingFactor, Vector3.Distance(vertices[13].Position, vertices[23].Position) / po.tilingFactor),
new Vector2(Vector3.Distance(vertices[10].Position, vertices[14].Position) / po.tilingFactor, 0),
new Vector2(Vector3.Distance(vertices[16].Position, vertices[15].Position) / po.tilingFactor, 0),
Vector2.zero, //16
new Vector2(0, Vector3.Distance(vertices[16].Position, vertices[17].Position) / po.tilingFactor),
new Vector2(Vector3.Distance(vertices[21].Position, vertices[18].Position) / po.tilingFactor, Vector3.Distance(vertices[19].Position, vertices[18].Position) / po.tilingFactor),
new Vector2(Vector3.Distance(vertices[20].Position, vertices[19].Position) / po.tilingFactor, 0),
Vector2.zero, //20
new Vector2(0, Vector3.Distance(vertices[20].Position, vertices[21].Position) / po.tilingFactor),
Vector2.zero, //22
new Vector2(Vector3.Distance(vertices[22].Position, vertices[23].Position) / po.tilingFactor, 0)
};
return(uvmap);
}
else
{
// not really the best thing ever made
Vector2[] uvmap = new Vector2[] {
Vector2.zero,
new Vector2(Vector3.Distance(vertices[2].Position, vertices[1].Position) / po.tilingFactor, Vector3.Distance(vertices[3].Position, vertices[1].Position) / po.tilingFactor),
new Vector2(0, Vector3.Distance(vertices[0].Position, vertices[2].Position) / po.tilingFactor),
new Vector2(Vector3.Distance(vertices[0].Position, vertices[3].Position) / po.tilingFactor, 0),
Vector2.zero,
new Vector2(Vector3.Distance(vertices[6].Position, vertices[7].Position) / po.tilingFactor, Vector3.Distance(vertices[5].Position, vertices[7].Position) / po.tilingFactor),
new Vector2(0, Vector3.Distance(vertices[6].Position, vertices[4].Position) / po.tilingFactor),
new Vector2(Vector3.Distance(vertices[4].Position, vertices[7].Position) / po.tilingFactor, 0)
};
return(uvmap);
}
}
public static Texture GetOriginalTexture(ProceduralObject obj)
{
if (obj.customTexture)
{
return(obj.customTexture as Texture);
}
if (obj.baseInfoType == "PROP")
{
return(obj._baseProp.m_material.mainTexture);
}
else
{
return(obj._baseBuilding.m_material.mainTexture);
}
}
public static void flipFaces(ProceduralObject obj)
{
for (int m = 0; m < obj.m_mesh.subMeshCount; m++)
{
int[] triangles = obj.m_mesh.GetTriangles(m);
for (int i = 0; i < triangles.Length; i += 3)
{
int temp = triangles[i];
triangles[i] = triangles[i + 1];
triangles[i + 1] = temp;
}
obj.m_mesh.SetTriangles(triangles, m);
}
obj.RecalculateNormals();
}
