Пример #1
0
        PCache ComputePCacheFromMesh()
        {
            var meshCache = ComputeDataCache(m_Mesh);

            Picker picker = null;

            if (m_Distribution == Distribution.Sequential)
            {
                if (m_MeshBakeMode == MeshBakeMode.Vertex)
                {
                    picker = new SequentialPickerVertex(meshCache);
                }
                else if (m_MeshBakeMode == MeshBakeMode.Triangle)
                {
                    picker = new SequentialPickerTriangle(meshCache);
                }
            }
            else if (m_Distribution == Distribution.Random)
            {
                if (m_MeshBakeMode == MeshBakeMode.Vertex)
                {
                    picker = new RandomPickerVertex(meshCache, m_SeedMesh);
                }
                else if (m_MeshBakeMode == MeshBakeMode.Triangle)
                {
                    picker = new RandomPickerTriangle(meshCache, m_SeedMesh);
                }
            }
            else if (m_Distribution == Distribution.RandomUniformArea)
            {
                picker = new RandomPickerUniformArea(meshCache, m_SeedMesh);
            }
            if (picker == null)
            {
                throw new InvalidOperationException("Unable to find picker");
            }

            var positions = new List <Vector3>();
            var normals   = m_ExportNormals ? new List <Vector3>() : null;
            var colors    = m_ExportColors ? new List <Vector4>() : null;
            var uvs       = m_ExportUV ? new List <Vector4>() : null;

            for (int i = 0; i < m_OutputPointCount; ++i)
            {
                if (i % 64 == 0)
                {
                    var cancel = EditorUtility.DisplayCancelableProgressBar("pCache bake tool", string.Format("Sampling data... {0}/{1}", i, m_OutputPointCount), (float)i / (float)m_OutputPointCount);
                    if (cancel)
                    {
                        return(null);
                    }
                }

                var vertex = picker.GetNext();
                positions.Add(vertex.position);
                if (m_ExportNormals)
                {
                    normals.Add(vertex.normal);
                }
                if (m_ExportColors)
                {
                    colors.Add(vertex.color);
                }
                if (m_ExportUV)
                {
                    uvs.Add(vertex.uvs.Any() ? vertex.uvs[0] : Vector4.zero);
                }
            }

            var file = new PCache();

            file.AddVector3Property("position");
            if (m_ExportNormals)
            {
                file.AddVector3Property("normal");
            }
            if (m_ExportColors)
            {
                file.AddColorProperty("color");
            }
            if (m_ExportUV)
            {
                file.AddVector4Property("uv");
            }

            EditorUtility.DisplayProgressBar("pCache bake tool", "Generating pCache...", 0.0f);
            file.SetVector3Data("position", positions);
            if (m_ExportNormals)
            {
                file.SetVector3Data("normal", normals);
            }
            if (m_ExportColors)
            {
                file.SetColorData("color", colors);
            }
            if (m_ExportUV)
            {
                file.SetVector4Data("uv", uvs);
            }

            EditorUtility.ClearProgressBar();
            return(file);
        }
Пример #2
0
    public static PCache ComputePCacheFromMesh(Mesh mesh, int mapSize = 512, int pointCount = 4096, int seed = 0, Distribution distribution = Distribution.RandomUniformArea, MeshBakeMode meshBakeMode = MeshBakeMode.Triangle)
    {
        if (mapSize % 8 != 0)
        {
            Debug.LogError("Position map dimensions should be a multiple of 8.");
            return(null);
        }

        if (computeShader == null)
        {
            computeShader = computeShader = Resources.Load <ComputeShader>("Shaders/ComputeMeshToMap");
        }

        PCache pCache = new PCache();

        // From PointCacheBakeTool
        MeshData meshCache = ComputeDataCache(mesh);

        Picker picker = null;

        if (distribution == Distribution.Sequential)
        {
            if (meshBakeMode == MeshBakeMode.Vertex)
            {
                picker = new SequentialPickerVertex(meshCache);
            }
            else if (meshBakeMode == MeshBakeMode.Triangle)
            {
                picker = new SequentialPickerTriangle(meshCache);
            }
        }
        else if (distribution == Distribution.Random)
        {
            if (meshBakeMode == MeshBakeMode.Vertex)
            {
                picker = new RandomPickerVertex(meshCache, seed);
            }
            else if (meshBakeMode == MeshBakeMode.Triangle)
            {
                picker = new RandomPickerTriangle(meshCache, seed);
            }
        }
        else if (distribution == Distribution.RandomUniformArea)
        {
            picker = new RandomPickerUniformArea(meshCache, seed);
        }
        if (picker == null)
        {
            throw new InvalidOperationException("Unable to find picker");
        }

        pCache.mesh      = mesh;
        pCache.mapSize   = mapSize;
        pCache.positions = new List <Vector3>();
        pCache.normals   = new List <Vector3>();

        for (int i = 0; i < pointCount; ++i)
        {
            var vertex = picker.GetNext();
            pCache.positions.Add(vertex.position);
            pCache.normals.Add(vertex.normal);
        }

        // From SMRVFX
        pCache.positionMap = new RenderTexture(mapSize, mapSize, 0, RenderTextureFormat.ARGBFloat);
        pCache.positionMap.enableRandomWrite = true;
        pCache.positionMap.Create();
        pCache.normalMap = new RenderTexture(mapSize, mapSize, 0, RenderTextureFormat.ARGBFloat);
        pCache.normalMap.enableRandomWrite = true;
        pCache.normalMap.Create();

        // Transfer data
        var vcount    = pCache.positions.Count;
        var vcount_x3 = vcount * 3;

        pCache.positionBuffer = new ComputeBuffer(vcount_x3, sizeof(float));
        pCache.normalBuffer   = new ComputeBuffer(vcount_x3, sizeof(float));

        computeShader.SetInt("VertexCount", vcount);

        pCache.positionBuffer.SetData(pCache.positions);
        pCache.normalBuffer.SetData(pCache.normals);

        computeShader.SetBuffer(0, "PositionBuffer", pCache.positionBuffer);
        computeShader.SetBuffer(0, "NormalBuffer", pCache.normalBuffer);

        computeShader.SetTexture(0, "PositionMap", pCache.positionMap);
        computeShader.SetTexture(0, "NormalMap", pCache.normalMap);

        computeShader.Dispatch(0, pCache.mapSize / 8, pCache.mapSize / 8, 1);

        return(pCache);
    }