예제 #1
0
    private void Swap()
    {
        var tmp = u1;

        u1 = u0;
        u0 = tmp;
    }
예제 #2
0
 public void Dispose()
 {
     if (matrices != null)
     {
         matrices.Dispose();
         matrices = null;
     }
 }
예제 #3
0
        private void OnEnable()
        {
            graph = new BarGraphBuf();
            buf   = new GPUList <float>();

            rend = GetComponent <Renderer>();

            Build();
        }
예제 #4
0
        public void Upload(RenderTexture tex, IList <int> values)
        {
            using (var buf = new GPUList <int>(values)) {
                cs.SetInts(P_COUNT, tex.width, tex.height);

                var cap = cs.DispatchSize(K_UPLOAD_INT, new Vector3Int(tex.width, tex.height, 1));
                cs.SetBuffer(K_UPLOAD_INT, P_INT_VALUES, buf);
                cs.SetTexture(K_UPLOAD_INT, P_INT_TEX, tex);
                cs.Dispatch(K_UPLOAD_INT, cap.x, cap.y, cap.z);
            }
        }
        private void OnEnable()
        {
            this.kernelIDEmit = compute.FindKernel(KERNEL_EMIT);

            this.positionList      = new GPUList <Vector3>(capasity);
            this.rotationList      = new GPUList <Quaternion>(capasity);
            this.objectToWorldList = new GPUList <Matrix4x4>(capasity);
            this.worldToObjectList = new GPUList <Matrix4x4>(capasity);

            this.args      = new GPUList <uint>(5, ComputeBufferType.IndirectArguments);
            this.deadList  = new GPUList <uint>(capasity, ComputeBufferType.Append);
            this.aliveList = new GPUList <uint>(capasity, ComputeBufferType.Append);

            this.uploadPositionList = new GPUList <Vector3>();

            for (var i = 0; i < capasity; i++)
            {
                deadList[i] = (uint)i;
            }
            deadList.Buffer.SetCounterValue((uint)capasity);
            aliveList.Buffer.SetCounterValue(0);
        }
예제 #6
0
    private void OnEnable()
    {
        we    = new WaveEquation1DBuf();
        graph = new BarGraphBuf();
        v     = new GPUList <float>();
        u0    = new GPUList <float>();
        u1    = new GPUList <float>();

        rend = GetComponent <Renderer>();

        validator.Reset();
        validator.Validation += () => {
            we.C        = speed;
            we.H        = 1000f / count;
            we.MaxSlope = maxSlope;

            graph.Peak = maxSlope * 2;

            time = 0f;
            dt   = Mathf.Min(we.SupDt(), Time.fixedDeltaTime) / (2 * quality);
            Debug.LogFormat("Set dt={0} for speed={1}", dt, speed);

            var dw     = 4f / count;
            var offset = dw * 0.5f * count;
            var dam    = Mathf.RoundToInt(0.1f * count);
            v.Clear();
            u0.Clear();
            u1.Clear();
            for (var i = 0; i < count; i++)
            {
                var w = 1f - Mathf.Clamp01(Mathf.Abs(dw * i - offset));
                u0.Add(w);
                u1.Add(0);
                v.Add(0);
            }
        };
    }
예제 #7
0
 public MatrixBuffer()
 {
     invalid  = true;
     matrices = new GPUList <Matrix4x4>();
 }
예제 #8
0
        public byte[] FilterGPU(byte[] bgra, ushort[] depth, DepthSpacePoint[] depthSpaceData,
                                int nearThresh, int farThresh, int haloSize)
        {
            if (computeShader == null)
            {
                return(new byte[0]);
            }

            // Initialize last frame with current color frame, if it was reset
            if (bLastFrameReset)
            {
                lastFramePixels = bgra;
                bLastFrameReset = false;
            }

            // -- Create halo array --

            List <int2> halo = new List <int2>();

            int s              = haloSize;
            int xd             = s;
            int yd             = s / 2;
            int S              = (xd + yd) / 2;
            int x0             = -xd;
            int x1             = +xd;
            int y0             = -yd;
            int y1             = +yd;
            int actualHaloSize = 0;

            for (int y = y0; y < y1; ++y)
            {
                for (int x = x0; x < x1; ++x)
                {
                    if (Math.Abs(x) + Math.Abs(y) <= S)
                    {
                        halo.Add(new int2(x, y));
                        ++actualHaloSize;
                    }
                }
            }

            // --

            // -- Perform data transformations so the arrays can be passed to the GPU --

            var bgraDataTransformed = new int4[1920 * 1080];

            for (int i = 0, j = 0; i < bgra.Length; i += 4, ++j)
            {
                bgraDataTransformed[j] = new int4(bgra[i], bgra[i + 1], bgra[i + 2], bgra[i + 3]);
            }

            var lastFrameDataTransformed = new int4[1920 * 1080];

            for (int i = 0, j = 0; i < bgra.Length; i += 4, ++j)
            {
                lastFrameDataTransformed[j] = new int4(lastFramePixels[i], lastFramePixels[i + 1], lastFramePixels[i + 2], lastFramePixels[i + 3]);
            }

            // --

            //var sw = Stopwatch.StartNew();

            // Create a constant buffer to pass the filter configuration
            var cbuffer = GPGPUHelper.CreateConstantBuffer(device, new int[] { nearThresh, farThresh, haloSize });

            // -- Create GPULists using the immediate context and pass the data --

            GPUList <int4> bgraData = new GPUList <int4>(device.ImmediateContext);

            bgraData.AddRange(bgraDataTransformed);

            GPUList <uint> depthData = new GPUList <uint>(device.ImmediateContext);

            depthData.AddRange(depth.Select(d => (uint)d));

            GPUList <DepthSpacePoint> depthSpacePointData = new GPUList <DepthSpacePoint>(device.ImmediateContext, depthSpaceData);
            //depthSpacePointData.AddRange(depthSpaceData.Select(dsp => {

            //    if (dsp.X == float.NegativeInfinity || dsp.Y == -float.NegativeInfinity)
            //    {
            //        return new DepthSpacePoint() { X = -1, Y = -1 };
            //    }
            //    else
            //    {
            //        return dsp;
            //    }
            //}));

            GPUList <int4> lastFrameData = new GPUList <int4>(device.ImmediateContext);

            lastFrameData.AddRange(lastFrameDataTransformed);

            var            resultArray = new int4[1920 * 1080];
            GPUList <int4> resultData  = new GPUList <int4>(device.ImmediateContext, resultArray);

            GPUList <int2> haloData = new GPUList <int2>(device.ImmediateContext, halo);

            // --

            var sw = Stopwatch.StartNew();

            // Set the buffers and uavs
            device.ImmediateContext.ComputeShader.Set(computeShader);
            device.ImmediateContext.ComputeShader.SetConstantBuffer(cbuffer, 0);
            device.ImmediateContext.ComputeShader.SetUnorderedAccessView(bgraData.UnorderedAccess, 0);
            device.ImmediateContext.ComputeShader.SetUnorderedAccessView(depthData.UnorderedAccess, 1);
            device.ImmediateContext.ComputeShader.SetUnorderedAccessView(depthSpacePointData.UnorderedAccess, 2);
            device.ImmediateContext.ComputeShader.SetUnorderedAccessView(lastFrameData.UnorderedAccess, 3);
            device.ImmediateContext.ComputeShader.SetUnorderedAccessView(resultData.UnorderedAccess, 4);
            device.ImmediateContext.ComputeShader.SetUnorderedAccessView(haloData.UnorderedAccess, 5);

            // Run the compute shader
            device.ImmediateContext.Dispatch(1920 * 1080 / 256, 1, 1);

            // Get result. This call blocks, until the result was calculated
            // because the MapSubresource call waits.
            var result = resultData.ToArray();

            sw.Stop();

            // -- Clean up --

            device.ImmediateContext.ComputeShader.SetConstantBuffer(null, 0);
            device.ImmediateContext.ComputeShader.SetUnorderedAccessView(null, 0);
            device.ImmediateContext.ComputeShader.SetUnorderedAccessView(null, 1);
            device.ImmediateContext.ComputeShader.SetUnorderedAccessView(null, 2);
            device.ImmediateContext.ComputeShader.SetUnorderedAccessView(null, 3);
            device.ImmediateContext.ComputeShader.SetUnorderedAccessView(null, 4);
            device.ImmediateContext.ComputeShader.SetUnorderedAccessView(null, 5);

            cbuffer.Dispose();
            bgraData.Dispose();
            depthData.Dispose();
            depthSpacePointData.Dispose();
            lastFrameData.Dispose();
            resultData.Dispose();
            haloData.Dispose();

            // --

            Debug.WriteLine($"Filtering took {sw.ElapsedMilliseconds} ms");

            var resultBytes = new byte[1920 * 1080 * 4];

            for (int i = 0, j = 0; i < resultBytes.Length; i += 4, ++j)
            {
                resultBytes[i]     = (byte)result[j].x;
                resultBytes[i + 1] = (byte)result[j].y;
                resultBytes[i + 2] = (byte)result[j].z;
                resultBytes[i + 3] = (byte)result[j].a;
            }

            lastFramePixels = resultBytes;

            return(resultBytes);
        }
예제 #9
0
        public byte[] FilterGPU(byte[] bgra, ushort[] depth, DepthSpacePoint[] depthSpaceData,
            int nearThresh, int farThresh, int haloSize)
        {
            if (computeShader == null)
            {
                return new byte[0];
            }

            // Initialize last frame with current color frame, if it was reset
            if (bLastFrameReset)
            {
                lastFramePixels = bgra;
                bLastFrameReset = false;
            }

            // -- Create halo array --

            List<int2> halo = new List<int2>();

            int s = haloSize;
            int xd = s;
            int yd = s / 2;
            int S = (xd + yd) / 2;
            int x0 = -xd;
            int x1 = +xd;
            int y0 = -yd;
            int y1 = +yd;
            int actualHaloSize = 0;
            for (int y = y0; y < y1; ++y)
            {
                for (int x = x0; x < x1; ++x)
                {
                    if (Math.Abs(x) + Math.Abs(y) <= S)
                    {
                        halo.Add(new int2(x, y));
                        ++actualHaloSize;
                    }
                }
            }

            // --

            // -- Perform data transformations so the arrays can be passed to the GPU --

            var bgraDataTransformed = new int4[1920 * 1080];
            for (int i = 0, j = 0; i < bgra.Length; i += 4, ++j)
            {
                bgraDataTransformed[j] = new int4(bgra[i], bgra[i + 1], bgra[i + 2], bgra[i + 3]);
            }

            var lastFrameDataTransformed = new int4[1920 * 1080];
            for (int i = 0, j = 0; i < bgra.Length; i += 4, ++j)
            {
                lastFrameDataTransformed[j] = new int4(lastFramePixels[i], lastFramePixels[i + 1], lastFramePixels[i + 2], lastFramePixels[i + 3]);
            }

            // --

            //var sw = Stopwatch.StartNew();

            // Create a constant buffer to pass the filter configuration
            var cbuffer = GPGPUHelper.CreateConstantBuffer(device, new int[] { nearThresh, farThresh, haloSize });

            // -- Create GPULists using the immediate context and pass the data --

            GPUList<int4> bgraData = new GPUList<int4>(device.ImmediateContext);
            bgraData.AddRange(bgraDataTransformed);

            GPUList<uint> depthData = new GPUList<uint>(device.ImmediateContext);
            depthData.AddRange(depth.Select(d => (uint)d));

            GPUList<DepthSpacePoint> depthSpacePointData = new GPUList<DepthSpacePoint>(device.ImmediateContext, depthSpaceData);
            //depthSpacePointData.AddRange(depthSpaceData.Select(dsp => {

            //    if (dsp.X == float.NegativeInfinity || dsp.Y == -float.NegativeInfinity)
            //    {
            //        return new DepthSpacePoint() { X = -1, Y = -1 };
            //    }
            //    else
            //    {
            //        return dsp;
            //    }
            //}));

            GPUList<int4> lastFrameData = new GPUList<int4>(device.ImmediateContext);
            lastFrameData.AddRange(lastFrameDataTransformed);

            var resultArray = new int4[1920 * 1080];
            GPUList<int4> resultData = new GPUList<int4>(device.ImmediateContext, resultArray);

            GPUList<int2> haloData = new GPUList<int2>(device.ImmediateContext, halo);

            // --

            var sw = Stopwatch.StartNew();

            // Set the buffers and uavs
            device.ImmediateContext.ComputeShader.Set(computeShader);
            device.ImmediateContext.ComputeShader.SetConstantBuffer(cbuffer, 0);
            device.ImmediateContext.ComputeShader.SetUnorderedAccessView(bgraData.UnorderedAccess, 0);
            device.ImmediateContext.ComputeShader.SetUnorderedAccessView(depthData.UnorderedAccess, 1);
            device.ImmediateContext.ComputeShader.SetUnorderedAccessView(depthSpacePointData.UnorderedAccess, 2);
            device.ImmediateContext.ComputeShader.SetUnorderedAccessView(lastFrameData.UnorderedAccess, 3);
            device.ImmediateContext.ComputeShader.SetUnorderedAccessView(resultData.UnorderedAccess, 4);
            device.ImmediateContext.ComputeShader.SetUnorderedAccessView(haloData.UnorderedAccess, 5);

            // Run the compute shader
            device.ImmediateContext.Dispatch(1920 * 1080 / 256, 1, 1);

            // Get result. This call blocks, until the result was calculated
            // because the MapSubresource call waits.
            var result = resultData.ToArray();

            sw.Stop();

            // -- Clean up --

            device.ImmediateContext.ComputeShader.SetConstantBuffer(null, 0);
            device.ImmediateContext.ComputeShader.SetUnorderedAccessView(null, 0);
            device.ImmediateContext.ComputeShader.SetUnorderedAccessView(null, 1);
            device.ImmediateContext.ComputeShader.SetUnorderedAccessView(null, 2);
            device.ImmediateContext.ComputeShader.SetUnorderedAccessView(null, 3);
            device.ImmediateContext.ComputeShader.SetUnorderedAccessView(null, 4);
            device.ImmediateContext.ComputeShader.SetUnorderedAccessView(null, 5);

            cbuffer.Dispose();
            bgraData.Dispose();
            depthData.Dispose();
            depthSpacePointData.Dispose();
            lastFrameData.Dispose();
            resultData.Dispose();
            haloData.Dispose();

            // --

            Debug.WriteLine($"Filtering took {sw.ElapsedMilliseconds} ms");

            var resultBytes = new byte[1920 * 1080 * 4];

            for (int i = 0, j = 0; i < resultBytes.Length; i += 4, ++j)
            {
                resultBytes[i] = (byte)result[j].x;
                resultBytes[i+1] = (byte)result[j].y;
                resultBytes[i+2] = (byte)result[j].z;
                resultBytes[i+3] = (byte)result[j].a;
            }

            lastFramePixels = resultBytes;

            return resultBytes;
        }