void OnEnable()
        {
            CSArray bm = (CSArray)target;

            banner = Resources.Load("CSHeader") as Texture;
            bm.AwakeMe();
            bm.UpdateElements();
        }
Example #2
0
        public void UpdateCity()
        {
            if (useFloorLimiting)
            {
                LimitFloors();
            }
            if (gameObject.activeInHierarchy)
            {
                CheckParents();

                // if (cityRandomizerParent == null) cityRandomizerParent = GameObject.Find("CScape City").GetComponent<CityRandomizer>() as CityRandomizer;
                if (cityRandomizerParent == null && isInRoot)
                {
                    cityRandomizerParent = gameObject.transform.parent.transform.parent.GetComponent <CityRandomizer>() as CityRandomizer;
                }
                if (gameObject.GetComponent <CSRooftops>() != null)
                {
                    hasRooftops = true;
                }

                advertising = gameObject.GetComponent <CSAdvertising>();
                if (advertising != null)
                {
                    hasAdvertising             = true;
                    advertising.useAdvertising = useAdvertising;
                }

                balcony = gameObject.GetComponent <CSArray>();
                if (balcony != null)
                {
                    hasBalcony             = true;
                    balcony.useAdvertising = useAdvertising;
                }
                else
                {
                    hasBalcony = false;
                }

                floorDetails = gameObject.GetComponent <CSFloorDetails>();
                if (floorDetails != null)
                {
                    hasFloorDetails = true;
                }
                else
                {
                    hasFloorDetails = false;
                }

                ModifyBuilding();
                //  Thread olix = new Thread(ModifyBuilding);
            }
        }
        public void OnSceneGUI()
        {
            CSArray bm = (CSArray)target;

            if (bm.rooftopHolder[0] != null)
            {
                for (int x = 0; x < bm.numberOfModifiers; x++)
                {
                    bm.rooftopHolder[x].transform.position = bm.gameObject.transform.position;
                    bm.rooftopHolder[x].transform.rotation = bm.gameObject.transform.rotation;
                }
            }
        }
Example #4
0
        public void OnDestroy()
        {
            if (!dontDestroyChildren)
            {
                if (Application.isEditor && !Application.isPlaying)
                {
                    if (useAdvertising)
                    {
                        if (advertising != null)
                        {
                            DestroyImmediate(advertising.rooftopHolder);
                        }
                    }

                    if (hasBalcony)
                    {
                        CSArray CSArray = balcony;
                        for (int x = 0; x < CSArray.numberOfModifiers; x++)
                        {
                            DestroyImmediate(CSArray.rooftopHolder[x]);
                        }
                    }
                    if (hasRooftops)
                    {
                        CSRooftops csRooftops = rooftops;
                        if (csRooftops && csRooftops.rooftopHolder)
                        {
                            DestroyImmediate(csRooftops.rooftopHolder);
                        }
                    }

                    if (hasFloorDetails)
                    {
                        CSFloorDetails csRooftops = floorDetails;
                        if (floorDetails && floorDetails.rooftopHolder)
                        {
                            DestroyImmediate(floorDetails.rooftopHolder);
                        }
                    }
                }
            }
        }
        public override void OnInspectorGUI()
        {
            CSArray bm = (CSArray)target;

            GUILayout.Box(banner, GUILayout.ExpandWidth(true));

            GUILayout.BeginVertical();
            for (int x = 0; x < bm.numberOfModifiers; x++)
            {
                //if (GUILayout.Button("Update Template"))
                //{
                //    bm.Awake();
                //    bm.UpdateElements();
                //}
                bm.modifierType[x] = (CScape.CSArray.ModifierType)EditorGUILayout.EnumPopup("Type", bm.modifierType[x]);
                bm.alignTo[x]      = (CScape.CSArray.Alignement)EditorGUILayout.EnumPopup("Start from", bm.alignTo[x]);
                bm.useAdvertising  = EditorGUILayout.Toggle("Use Advertising Panels", bm.useAdvertising);
                bm.lodDistance     = EditorGUILayout.Slider("Culling Distance", bm.lodDistance, 0f, 1f);
                bm.instancesX      = EditorGUILayout.IntField("Max number of vertical instances", bm.instancesX);
                bm.instancesZ      = EditorGUILayout.IntField("Max number of horizontal instances", bm.instancesZ);
                bm.randomSeed      = EditorGUILayout.IntField("Random seed", bm.randomSeed);
                bm.upStart[x]      = EditorGUILayout.IntField("Top offset start", bm.upStart[x]);

                bm.leftSideStart[x]  = EditorGUILayout.IntField("Left offset start", bm.leftSideStart[x]);
                bm.rightSideStart[x] = EditorGUILayout.IntField("Right offset start", bm.rightSideStart[x]);

                bm.downStart[x] = EditorGUILayout.IntField("Down Offset start", bm.downStart[x]);

                bm.skipX[x]        = EditorGUILayout.IntSlider("Skip Columns", bm.skipX[x], 1, 5);
                bm.skipY[x]        = EditorGUILayout.IntSlider("Skip Rows", bm.skipY[x], 1, 5);
                bm.sparseRemove[x] = EditorGUILayout.Toggle("Sparse Remove", bm.sparseRemove[x]);
                bm.sparseRandom[x] = EditorGUILayout.IntField("Sparse remove seed", bm.sparseRandom[x]);
                bm.greebleMat[x]   = EditorGUILayout.ObjectField("Rooftop Material", bm.greebleMat[x], typeof(Material), true) as Material;
                bm.placingDepth[x] = EditorGUILayout.FloatField("Z Depth", bm.placingDepth[x]);



                GUILayout.BeginVertical();

                bm.rooftopElements[x] = EditorGUILayout.ObjectField(bm.rooftopElements[x], typeof(GameObject), true) as GameObject;
                EditorGUILayout.LabelField("", GUI.skin.horizontalSlider);
            }


            GUILayout.EndVertical();

            GUILayout.EndVertical();

            GUILayout.BeginHorizontal("Box");
            if (GUILayout.Button("-", "Label", GUILayout.Width(20), GUILayout.Height(15)))
            {
                bm.numberOfModifiers--;
            }
            if (GUILayout.Button("+", "Label", GUILayout.Width(20), GUILayout.Height(15)))
            {
                bm.numberOfModifiers++;
            }

            GUILayout.EndHorizontal();



            if (GUI.changed)
            {
                bm.AwakeMe();
                bm.UpdateElements();
                EditorUtility.SetDirty(bm);
            }
        }
Example #6
0
        public void ModifyBuilding()
        {
            if (gameObject.activeInHierarchy)
            {
                if (gameObject.GetComponent <CSRooftops>() != null)
                {
                    hasRooftops = true;
                }
                else
                {
                    hasRooftops = false;
                }

                if (gameObject.GetComponent <CSAdvertising>() != null)
                {
                    hasAdvertising = true;
                }
                else
                {
                    hasAdvertising = false;
                }

                balcony = gameObject.GetComponent <CSArray>();
                if (balcony != null)
                {
                    hasBalcony             = true;
                    balcony.useAdvertising = useAdvertising;
                }
                else
                {
                    hasBalcony = false;
                }

                floorDetails = gameObject.GetComponent <CSFloorDetails>();
                if (floorDetails != null)
                {
                    hasFloorDetails = true;
                }
                else
                {
                    hasFloorDetails = false;
                }

                id1.x = CompressIDs(materialId1);
                id2.x = CompressIDs(materialId2);
                id3.x = CompressIDs(materialId3);
                id4.x = CompressIDs(materialId4);


                //originalVertices = meshOriginal.vertices;
                //originalColors = meshOriginal.colors;
                //originalUVs = meshOriginal.uv;
                transform.localScale = new Vector3(1, 1, 1);
                //mesh = GetComponent<MeshFilter>().mesh;
                Vector4[] vColorsFloat = new Vector4[mesh.uv.Length];
                Vector3[] vertices     = mesh.vertices;
                Vector2[] uV           = mesh.uv;
                vertexColor = mesh.colors32;

                Vector3[] transformVertices = mesh.vertices;
                Vector2[] transformUV       = mesh.uv;

                Vector3[] normals = mesh.normals;

                lightVec  = Mathf.FloorToInt(colorVariation.x) + Mathf.FloorToInt(colorVariation.y) * 0.1f + Mathf.FloorToInt(colorVariation.z) * 0.01f + Mathf.FloorToInt(colorVariation.w) * 0.001f + Mathf.FloorToInt(lightsOnOff) * 0.0001f + 0.00002f;
                lightVec2 = Mathf.FloorToInt(colorVariation2.x) + Mathf.FloorToInt(colorVariation2.y) * 0.1f + Mathf.FloorToInt(colorVariation2.z) * 0.01f + Mathf.FloorToInt(colorVariation2.w) * 0.001f + Mathf.FloorToInt(lightsOnOff2) * 0.0001f + 0.00002f;
                lightVec3 = Mathf.FloorToInt(colorVariation3.x) * 0.01f + Mathf.FloorToInt(colorVariation3.y) * 0.001f + lightnessFront * 0.0001f + 0.00002f;
                lightVec6 = Mathf.FloorToInt(colorVariation3.x) * 0.01f + Mathf.FloorToInt(colorVariation3.y) * 0.001f + lightnessFront * 0.0001f + 0.00002f;

                lightVec4 = Mathf.FloorToInt(windowOpen) + Mathf.FloorToInt(colorVariation4.x) * 0.1f + (materialId5) * 0.001f + borderCol * 0.0001f + 0.00002f;
                lightVec5 = Mathf.FloorToInt(windowOpen) + Mathf.FloorToInt(colorVariation4.x) * 0.1f + (0) * 0.001f + borderCol * 0.0001f + 0.00002f;

                lightVec7 = Mathf.FloorToInt(colorVariation5.x) * 0.01f + Mathf.FloorToInt(colorVariation5.y) * 0.001f + lightnessSide * 0.0001f + 0.00002f;
                lightVec8 = Mathf.FloorToInt(colorVariation5.x) * 0.01f + Mathf.FloorToInt(colorVariation5.y) * 0.001f + lightnessSide * 0.0001f + 0.00002f;


                //   Debug.Log(lightVec);
                int i = 0;
                while (i < vertices.Length)
                {
                    transformVertices[i] = new Vector3(0, 0, 0);
                    transformUV[i]       = new Vector2(0, 0);
                    vColors[i]           = new Vector4(id1.x + lightVec3, id1.y, lightVec2, lightVec) * 0.1f;
                    Vector3 invNormal = normals[i] * -1;

                    if (originalVertices[i].y > lowFloorBound.y)
                    {
                        if (floorNumber < prefabFloors)
                        {
                            floorNumber = prefabFloors;
                        }
                        transformVertices[i].y = (floorNumber - prefabFloors) * floorHeight;
                        transformUV[i].y       = floorNumber - prefabFloors;
                    }
                    ////
                    if (thresholdResizeY != 0 && (lowFloorBound.y - (thresholdResizeY / 2f)) < originalVertices[i].y && (lowFloorBound.y + (thresholdResizeY / 2f)) > originalVertices[i].y)
                    {
                        if (floorNumber < prefabFloors)
                        {
                            floorNumber = prefabFloors;
                        }
                        transformVertices[i].y = (floorNumber / 2 - prefabFloors / 2) * floorHeight;
                        transformUV[i].y       = floorNumber / 2 - prefabFloors / 2;
                    }

                    if (originalVertices[i].x > lowFloorBound.x)
                    {
                        if (buildingWidth < prefabWidth)
                        {
                            buildingWidth = prefabWidth;
                        }

                        transformVertices[i].x = (buildingWidth - prefabWidth) * floorHeight;


                        if (invNormal.z < 1 + normalThreshold && invNormal.z > 1 - normalThreshold)
                        {
                            transformUV[i].x = buildingWidth - prefabWidth;
                        }
                        if (normals[i].z < 1 + normalThreshold && normals[i].z > 1 - normalThreshold)
                        {
                            transformUV[i].x = -(buildingWidth - prefabWidth);
                        }
                    }
                    //New resize function
                    if (thresholdResizeX != 0 && (lowFloorBound.x + (thresholdResizeX / 2f)) > originalVertices[i].x && originalVertices[i].x > (lowFloorBound.x - (thresholdResizeX / 2f)))
                    {
                        if (buildingWidth < prefabWidth)
                        {
                            buildingWidth = prefabWidth;
                        }

                        transformVertices[i].x = (buildingWidth / 2 - prefabWidth / 2) * floorHeight;


                        if (invNormal.z < 1 + normalThreshold && invNormal.z > 1 - normalThreshold)
                        {
                            transformUV[i].x = buildingWidth / 2 - prefabWidth / 2;
                        }
                        if (normals[i].z < 1 + normalThreshold && normals[i].z > 1 - normalThreshold)
                        {
                            transformUV[i].x = -(buildingWidth / 2 - prefabWidth / 2);
                        }
                    }


                    if (originalVertices[i].z > lowFloorBound.z)
                    {
                        if (buildingDepth < prefabDepth)
                        {
                            buildingDepth = prefabDepth;
                        }
                        transformVertices[i].z = (buildingDepth - prefabDepth) * floorHeight;

                        if (normals[i].x < 1 + normalThreshold && normals[i].x > 1 - normalThreshold)
                        {
                            transformUV[i].x = (buildingDepth - prefabDepth);
                        }
                        if (invNormal.x < 1 + normalThreshold && invNormal.x > 1 - normalThreshold)
                        {
                            transformUV[i].x = -(buildingDepth - prefabDepth);
                        }
                    }

                    if (thresholdResizeZ != 0 && (lowFloorBound.z + (thresholdResizeZ / 2f)) > originalVertices[i].z && originalVertices[i].z > (lowFloorBound.z - (thresholdResizeZ / 2f)))
                    {
                        if (buildingDepth < prefabDepth)
                        {
                            buildingDepth = prefabDepth;
                        }
                        transformVertices[i].z = (buildingDepth / 2 - prefabDepth / 2) * floorHeight;

                        if (normals[i].x < 1 + normalThreshold && normals[i].x > 1 - normalThreshold)
                        {
                            transformUV[i].x = (buildingDepth / 2 - prefabDepth / 2);
                        }
                        if (invNormal.x < 1 + normalThreshold && invNormal.x > 1 - normalThreshold)
                        {
                            transformUV[i].x = -(buildingDepth / 2 - prefabDepth / 2);
                        }
                    }
                    ////Extend foundations for supporting tererain

                    if (extendFoundations != 0f)
                    {
                        if (originalVertices[i].y <= extFoundationsTreshhold)
                        {
                            transformVertices[i].y = transformVertices[i].y - extendFoundations;
                            transformUV[i].y       = transformUV[i].y - extendFoundations / 3;
                        }
                    }


                    if (useSlantedRoofsResize)
                    {
                        if (originalVertices[i].y >= slantedRoofsVal.y)
                        {
                            if (slantedRoofsVal.w != 0)
                            {
                                transformVertices[i].y = transformVertices[i].y + (buildingDepth - 1) * slantedRoofsVal.w;
                            }
                            if (slantedRoofsVal.z != 0)
                            {
                                transformVertices[i].y = transformVertices[i].y + (buildingWidth - 1) * slantedRoofsVal.z;
                            }
                            //                          transformUV[i].y = transformUV[i].y - extendFoundations / 3;
                        }
                    }

                    ///////// manipulate Vertex colors



                    if (prefabHasVertexInfo)
                    {
                        if (originalColors[i].r < 0.2f)
                        {
                            if (invNormal.z < 1 + normalThreshold && invNormal.z > 1 - normalThreshold)
                            {
                                vColors[i] = new Vector4(id2.x + lightVec3, lightVec4, lightVec2, lightVec) * 0.1f;
                            }
                            if (normals[i].z < 1 + normalThreshold && normals[i].z > 1 - normalThreshold)
                            {
                                vColors[i] = new Vector4(id2.x + lightVec6, lightVec4, lightVec2, lightVec) * 0.1f;
                            }
                            if (normals[i].x < 1 + normalThreshold && normals[i].x > 1 - normalThreshold)
                            {
                                vColors[i] = new Vector4(id3.x + lightVec7, lightVec4, lightVec2, lightVec) * 0.1f;
                            }
                            if (invNormal.x < 1 + normalThreshold && invNormal.x > 1 - normalThreshold)
                            {
                                vColors[i] = new Vector4(id3.x + lightVec8, lightVec4, lightVec2, lightVec) * 0.1f;
                            }
                        }
                        else
                        {
                            vColors[i] = new Vector4(id1.x + lightVec3, lightVec5, lightVec2, lightVec) * 0.1f;
                        }
                    }
                    else
                    {
                        if (invNormal.z < 1 + normalThreshold && invNormal.z > 1 - normalThreshold)
                        {
                            vColors[i] = new Vector4(id2.x + lightVec3, lightVec4, lightVec2, lightVec) * 0.1f;
                        }
                        if (normals[i].z < 1 + normalThreshold && normals[i].z > 1 - normalThreshold)
                        {
                            vColors[i] = new Vector4(id2.x + lightVec6, lightVec4, lightVec2, lightVec) * 0.1f;
                        }
                        if (normals[i].x < 1 + normalThreshold && normals[i].x > 1 - normalThreshold)
                        {
                            vColors[i] = new Vector4(id3.x + lightVec7, lightVec4, lightVec2, lightVec) * 0.1f;
                        }

                        if (invNormal.x < 1 + normalThreshold && invNormal.x > 1 - normalThreshold)
                        {
                            vColors[i] = new Vector4(id3.x + lightVec8, lightVec4, lightVec2, lightVec) * 0.1f;
                        }
                    }
                    //     Debug.Log((id2.x + lightVec3) * 0.1f);

                    vertices[i] = Vector3.Scale(originalVertices[i] + transformVertices[i], new Vector3(1, scale, 1));



                    uV[i] = new Vector2(originalUVs[i].x, originalUVs[i].y) + transformUV[i] + new Vector2(uniqueMapping, 0);



                    if (normals[i].y > 0.9 || normals[i].y < -0.9)
                    {
                        uV[i].x    = vertices[i].x * 0.5f;
                        uV[i].y    = vertices[i].z * 0.5f + 10;
                        vColors[i] = new Vector4(id4.x + lightVec3, lightVec4, lightVec2, lightVec) * 0.1f;
                    }


                    if (autoMap)
                    {
                        if (invNormal.z < 1 + normalThreshold && invNormal.z > 1 - normalThreshold)
                        {
                            uV[i] = new Vector2(vertices[i].x / floorHeight + uniqueMapping, (vertices[i].y / (floorHeight * scale * Mathf.Abs(1 - Mathf.Sin(normals[i].y)))));
                        }

                        if (normals[i].z < 1 + normalThreshold && normals[i].z > 1 - normalThreshold)
                        {
                            uV[i] = new Vector2(vertices[i].x / -floorHeight + uniqueMapping, (vertices[i].y / (floorHeight * scale * Mathf.Abs(1 - Mathf.Sin(normals[i].y)))));
                        }

                        if (normals[i].x < 1 + normalThreshold && normals[i].x > 1 - normalThreshold)
                        {
                            uV[i] = new Vector2(vertices[i].z / floorHeight + uniqueMapping, (vertices[i].y / (floorHeight * scale * Mathf.Abs(1 - Mathf.Sin(normals[i].y)))));
                        }

                        if (invNormal.x < 1 + normalThreshold && invNormal.x > 1 - normalThreshold)
                        {
                            uV[i] = new Vector2(vertices[i].z / -floorHeight + uniqueMapping, (vertices[i].y / (floorHeight * scale * Mathf.Abs(1 - Mathf.Sin(normals[i].y)))));
                        }
                    }

                    if (supportSkewing)
                    {
                        vertices[i] = new Vector3(vertices[i].x + (1 / Mathf.Tan(Mathf.Deg2Rad * ((skew - 90))) * vertices[i].z), vertices[i].y, vertices[i].z);
                    }
                    vColorsFloat[i] = vColors[i];



                    if (prefabHasVertexInfo)
                    {
                        float boolValue = 0;
                        if (customBool2)
                        {
                            boolValue = 0.1f;
                        }

                        if (useGraffiti && vertices[i].y < floorNumber * 3 - 1)
                        {
                            //graffiti written into channel A
                            //Rooftop Value into channel B
                            vertexColor[i] = new Color(vertexColor[i].r, vertexColor[i].g, rooftopID * 0.01f + boolValue, 255);
                        }
                        else
                        {
                            vertexColor[i] = new Color(vertexColor[i].r, 255, rooftopID * 0.01f + boolValue, 0);
                        }
                    }
                    if (hasNoFloorLevel)
                    {
                        uV[i] = new Vector2(uV[i].x, uV[i].y + 2);
                    }

                    i++;
                }



                var list = new List <Vector4>(vColors);

                //if (supportSkewing)
                //{
                //    i = 0;
                //    while (i < vertices.Length)
                //    {
                //        vertices[i] = new Vector3(vertices[i].x + (skew * vertices[i].z), vertices[i].y, vertices[i].z);
                //        i++;
                //    }
                //}

                mesh.vertices = vertices;
                mesh.uv       = uV;
                mesh.SetUVs(3, list);
                mesh.colors32     = vertexColor;
                vertices          = null;
                uV                = null;
                list              = null;
                vertexColor       = null;
                transformVertices = null;
                transformUV       = null;
                //originalVertices = null;
                //originalColors = null;
                //originalUVs = null;


                mesh.RecalculateNormals();
                mesh.RecalculateTangents();

                mesh.RecalculateBounds();
                MeshCollider mColl = gameObject.GetComponent <MeshCollider>();
                if (!gameObject.GetComponent <MeshCollider>())
                {
                    mColl = gameObject.AddComponent <MeshCollider>();
                }
                mColl.convex     = false;
                mColl.sharedMesh = mesh;



                if (hasRooftops)
                {
                    rooftops.UpdateElements();
                }
                if (hasAdvertising)
                {
                    //advertising.Awake();
                    advertising.UpdateElements();
                }

                if (hasBalcony)
                {
                    balcony.UpdateElements();
                }
                if (hasFloorDetails)
                {
                    floorDetails.UpdateElements();
                }
            }
        }
Example #7
0
        public void AwakeCity()
        {
            if (useFloorLimiting)
            {
                LimitFloors();
            }

            if (gameObject.activeInHierarchy)
            {
                CheckParents();

                if (cityRandomizerParent == null && isInRoot)
                {
                    cityRandomizerParent = gameObject.transform.parent.transform.parent.GetComponent <CityRandomizer>() as CityRandomizer;
                }

                rooftops = gameObject.GetComponent <CSRooftops>();
                if (gameObject.GetComponent <CSRooftops>() != null)
                {
                    hasRooftops = true;
                }
                else
                {
                    hasRooftops = false;
                }

                advertising = gameObject.GetComponent <CSAdvertising>();
                if (advertising != null)
                {
                    hasAdvertising             = true;
                    advertising.useAdvertising = useAdvertising;
                }
                else
                {
                    hasAdvertising = false;
                }

                balcony = gameObject.GetComponent <CSArray>();
                if (balcony != null)
                {
                    hasBalcony             = true;
                    balcony.useAdvertising = useAdvertising;
                }
                else
                {
                    hasFloorDetails = false;
                }

                floorDetails = gameObject.GetComponent <CSFloorDetails>();
                if (floorDetails != null)
                {
                    hasFloorDetails = true;
                }
                else
                {
                    hasFloorDetails = false;
                }



                parentStreets     = new StreetModifier[5];
                connectedSections = new BuildingModifier[5];

                //meshOriginal = GetComponent<MeshFilter>().sharedMesh;
                originalVertices = meshOriginal.vertices;
                if (scaleFrom1to3)
                {
                    for (int i = 0; i < meshOriginal.vertices.Length; i++)
                    {
                        originalVertices[i] = meshOriginal.vertices[i] * 3f;
                    }
                }
                originalUVs = meshOriginal.uv;

                if (meshOriginal.colors.Length > 0)
                {
                    originalColors = meshOriginal.colors;
                }
                else
                {
                    originalColors = new Color[meshOriginal.vertices.Length];
                }

                vColors = new Vector4[originalVertices.Length];
                mesh    = Instantiate(meshOriginal) as Mesh;
                MeshFilter meshFilter = GetComponent <MeshFilter>();
                meshFilter.mesh = mesh;
                //		gameObject.transform.GetChild (0);
                //      lightVec = (Mathf.FloorToInt(colorVariation.x * 0.1f) * 10f) + (Mathf.FloorToInt(colorVariation.y) * 0.1f) + (Mathf.FloorToInt(colorVariation.z) * 0.01f) + (Mathf.FloorToInt(colorVariation.w) * 0.001f + 0.00001f);
                //
                ModifyBuilding();
                //  Thread olix = new Thread (ModifyBuilding);
            }
        }