コード例 #1
0
    static private Texture2D[] LoadImages(CWVisualDefinition visualDefinition)
    {
        Texture2D[] images = new Texture2D[visualDefinition.materialCount];
        for (int i = 0; i < visualDefinition.materialCount; i++)
        {
            string resourceName;

            if (i == 0 && visualDefinition.materialCount == 1)
                resourceName = "Items/" + visualDefinition.material;
            else
                resourceName = "Items/" + visualDefinition.material + "_z" + (i + 1).ToString();

            Texture2D image = (Texture2D) Resources.Load(resourceName, typeof(Texture2D));

            if (image == null)
                Debug.LogError("Image not found: " + resourceName);

            images[i] = image;
        }

        return images;
    }
コード例 #2
0
    static private Mesh GetMeshForDefinition(CWVisualDefinition visualDefinition, float lightIntensity)
    {
        int lightIntensityI = (int)(lightIntensity * 10);
        lightIntensity = (float) lightIntensityI / 10.0f;

        Mesh mesh = null;

        if (cacheMeshes.ContainsKey(visualDefinition))
            if (cacheMeshes[visualDefinition].ContainsKey(lightIntensityI))
                mesh = cacheMeshes[visualDefinition][lightIntensityI];

        if (mesh == null)
        {
            Mesh baseMesh = GetBaseMeshForDefinition(visualDefinition);
            Color[] colors = baseMesh.colors;

            for (int i = 0; i < colors.Length; i++)
                colors[i] *= lightIntensity;

            mesh = new Mesh();

            mesh.vertices = baseMesh.vertices;
            mesh.colors = colors;
            mesh.normals = baseMesh.normals;
            mesh.triangles = baseMesh.triangles;

            if (cacheMeshes.ContainsKey(visualDefinition) == false)
                cacheMeshes[visualDefinition] = new Dictionary<int, Mesh>();

            cacheMeshes[visualDefinition][lightIntensityI] = mesh;
        }

        return mesh;
    }
コード例 #3
0
    static private Mesh GetBaseMeshForDefinition(CWVisualDefinition visualDefinition)
    {
        Mesh mesh;

        if (cacheBaseMeshes.TryGetValue(visualDefinition, out mesh) == false)
        {
            float pixelScale = 1.0f / (float)visualDefinition.scale;
            Vector3 pivot = GraphicsUnity.CubeWorldVector3ToVector3(visualDefinition.pivot);

            mesh = new Mesh();
            Texture2D[] images = LoadImages(visualDefinition);

            colors.Clear();
            vertices.Clear();
            normals.Clear();
            trianglesNormal.Clear();

            int index = 0;

            TilePosition mainNormal;
            TilePosition d1Normal;
            TilePosition d2Normal;

            switch (visualDefinition.plane)
            {
                case "x":
                    mainNormal = new TilePosition(1, 0, 0);
                    d1Normal = new TilePosition(0, 0, 1);
                    d2Normal = new TilePosition(0, 1, 0);
                    break;

                case "y":
                    mainNormal = new TilePosition(0, 1, 0);
                    d1Normal = new TilePosition(1, 0, 0);
                    d2Normal = new TilePosition(0, 0, 1);
                    break;

                case "z":
                default:
                    mainNormal = new TilePosition(0, 0, 1);
                    d1Normal = new TilePosition(1, 0, 0);
                    d2Normal = new TilePosition(0, 1, 0);
                    break;
            }

            float halfDmain = images.Length / 2.0f;
            float halfD1 = images[0].width / 2.0f;
            float halfD2 = images[0].height / 2.0f;

            for (int dmain = 0; dmain < images.Length; dmain++)
            {
                Texture2D image = images[dmain];

                for (int d1 = 0; d1 < image.width; d1++)
                {
                    for (int d2 = 0; d2 < image.height; d2++)
                    {
                        Color colorPixel = image.GetPixel(d1, d2);

                        if (colorPixel.a == 0.0f)
                            continue;

                        Vector3 offset = new Vector3();

                        offset += GraphicsUnity.TilePositionToVector3(d1Normal) * (((d1Normal * d1).GetSumComponents() - halfD1) - halfD1 * pivot.x);
                        offset += GraphicsUnity.TilePositionToVector3(d2Normal) * (((d2Normal * d2).GetSumComponents() - halfD2) - halfD2 * pivot.y);
                        offset += GraphicsUnity.TilePositionToVector3(mainNormal) * (((mainNormal * dmain).GetSumComponents() - halfDmain) - halfDmain * pivot.z);

                        offset += new Vector3(CubeWorld.Utils.Graphics.HALF_TILE_SIZE, CubeWorld.Utils.Graphics.HALF_TILE_SIZE, CubeWorld.Utils.Graphics.HALF_TILE_SIZE);

                        offset *= pixelScale;

                        for (int face = 0; face < 6; face++)
                        {
                            TilePosition normalInt = MeshUtils.faceNormalsTile[face];

                            int near1 = d1 + (d1Normal * normalInt).GetSumComponents();
                            int near2 = d2 + (d2Normal * normalInt).GetSumComponents();
                            int nearMain = dmain + (mainNormal * normalInt).GetSumComponents();

                            if (near1 >= 0 && near2 >= 0 && nearMain >= 0 &&
                                near1 < image.width && near2 < image.height && nearMain < images.Length)
                            {
                                if (images[nearMain].GetPixel(near1, near2).a == 1.0f)
                                    continue;
                            }

                            Color faceColor = colorPixel * MeshUtils.faceBright[face];

                            Vector3 faceNormal = MeshUtils.faceNormals[face];

                            for (int i = 0; i < 4; i++)
                            {
                                vertices.Add(MeshUtils.faceVectorsNormal[(face << 2) + i] * pixelScale + offset);
                                normals.Add(faceNormal);
                                colors.Add(faceColor);
                            }

                            trianglesNormal.Add(index + 0);
                            trianglesNormal.Add(index + 1);
                            trianglesNormal.Add(index + 2);

                            trianglesNormal.Add(index + 2);
                            trianglesNormal.Add(index + 3);
                            trianglesNormal.Add(index + 0);

                            index += 4;
                        }
                    }
                }
            }

            mesh.vertices = vertices.ToArray();
            mesh.colors = colors.ToArray();
            mesh.normals = normals.ToArray();
            mesh.triangles = trianglesNormal.ToArray();

            cacheBaseMeshes[visualDefinition] = mesh;
        }

        return mesh;
    }
コード例 #4
0
        private CWVisualDefinition ParseVisualDefinition(XmlElement visualDefinitionXML)
        {
            CWVisualDefinition visualDefinition = new CWVisualDefinition();

            visualDefinition.material = GetAttributeStringValue(visualDefinitionXML, "material");
            visualDefinition.materialCount = GetAttributeIntValue(visualDefinitionXML, "materialCount", 1);
            visualDefinition.scale = GetAttributeIntValue(visualDefinitionXML, "scale", 16);
            visualDefinition.pivot = GetAttributeVector3Value(visualDefinitionXML, "pivot", new Vector3(0, 0, 0));
            visualDefinition.plane = GetAttributeStringValue(visualDefinitionXML, "plane", "z");

            return visualDefinition;
        }