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(); }