Example #1
0
        public RayIntersections(string name, uint maxCount, int deviceIndex) : base(name)
        {
            MaxRayCount = maxCount;

            RayBuffer    = new StreamableBuffer(name + "_rays", maxCount * RaySize, BufferUsage.Storage);
            rayBufferPtr = RayBuffer.LocalBuffer.GetRayDevicePointer(0);

            HitBuffer       = new StreamableBuffer(name + "_hits", maxCount * HitSize, BufferUsage.Storage);
            resultBufferPtr = HitBuffer.LocalBuffer.GetRayDevicePointer(0);

            //Allocate the necessary memory
            unsafe
            {
                ulong scratchSz = 0;
                if (rrGetTraceMemoryRequirements(GraphicsDevice.DeviceInformation[deviceIndex].RaysContext, maxCount, &scratchSz) != RRError.RrSuccess)
                {
                    throw new Exception("Failed to determine trace memory requirements.");
                }

                ScratchBuffer = new GpuBuffer(name + "_scratch")
                {
                    MemoryUsage = MemoryUsage.GpuOnly,
                    Size        = scratchSz,
                    Usage       = BufferUsage.Storage | BufferUsage.TransferDst
                };
                ScratchBuffer.Build(deviceIndex);
                scratchBufferPtr = ScratchBuffer.GetRayDevicePointer(0);
            }
        }
Example #2
0
        public void SetupBuild(int deviceIndex, uint triangleCnt, GpuBuffer vertices, ulong vertices_off, GpuBuffer indices, ulong indices_off, bool shortIndices)
        {
            devID             = deviceIndex;
            TrianglePrimitive = new RRTriangleMeshPrimitive()
            {
                index_type       = shortIndices ? RRIndexType.RrIndexTypeUint16 : RRIndexType.RrIndexTypeUint32,
                triangle_count   = triangleCnt,
                triangle_indices = indices.GetRayDevicePointer(indices_off),
                vertex_count     = VertexCount,
                vertex_stride    = VertexSize,
                vertices         = vertices.GetRayDevicePointer(vertices_off)
            };
            TrianglePrimitive_ptr = TrianglePrimitive.Pointer();

            GeometryBuildInput = new RRGeometryBuildInput()
            {
                primitive_type  = RRPrimitiveType.RrPrimitiveTypeTriangleMesh,
                primitive_count = 1,
                primitives      = TrianglePrimitive_ptr,
            };
            GeometryBuildInput_ptr = GeometryBuildInput.Pointer();

            RRBuildOptions opts = new RRBuildOptions()
            {
                build_flags           = 0,
                backend_specific_info = IntPtr.Zero,
            };
            var opts_ptr = opts.Pointer();

            //Allocate the necessary memory
            ManagedPtr <RRMemoryRequirements> geomMemReqs = new ManagedPtr <RRMemoryRequirements>();

            if (rrGetGeometryBuildMemoryRequirements(GraphicsDevice.DeviceInformation[deviceIndex].RaysContext, GeometryBuildInput_ptr, opts_ptr, geomMemReqs) != RRError.RrSuccess)
            {
                throw new Exception("Failed to determine geometry memory requirements.");
            }

            ScratchBuffer = new GpuBuffer(Name + "_scratch")
            {
                MemoryUsage = MemoryUsage.GpuOnly,
                Size        = geomMemReqs.Value.temporary_build_buffer_size,
                Usage       = BufferUsage.Storage | BufferUsage.TransferDst
            };
            ScratchBuffer.Build(deviceIndex);
            scratchBufferPtr = ScratchBuffer.GetRayDevicePointer(0);

            BuiltGeometryBuffer = new GpuBuffer(Name + "_geom")
            {
                MemoryUsage = MemoryUsage.GpuOnly,
                Size        = geomMemReqs.Value.result_buffer_size,
                Usage       = BufferUsage.Storage | BufferUsage.TransferDst
            };
            BuiltGeometryBuffer.Build(deviceIndex);
            geomBufferPtr = BuiltGeometryBuffer.GetRayDevicePointer(0);
        }
Example #3
0
        public StreamableBuffer(string name, ulong sz, BufferUsage usage) : base(name)
        {
            this.Size       = sz;
            this.Streamable = true;
            LocalBuffer     = new GpuBuffer(name)
            {
                MemoryUsage = MemoryUsage.GpuOnly,
                Size        = sz,
                Usage       = usage | BufferUsage.TransferDst,
            };
            LocalBuffer.Build(0);

            HostBuffer = new GpuBuffer(name + "_host")
            {
                Mapped      = true,
                Size        = sz,
                MemoryUsage = MemoryUsage.CpuToGpu,
                Usage       = BufferUsage.TransferSrc
            };
            HostBuffer.Build(0);
        }
        public StreamableImage(string name, ulong buf_sz, uint dims, uint w, uint h, uint d, uint layers, uint levels, ImageViewType viewType, ImageFormat format, ImageUsage usage) : base(name)
        {
            this.Size       = buf_sz;
            this.Streamable = true;
            LocalImage      = new Image(Name + "_upload_img")
            {
                Cubemappable  = false,
                Width         = w,
                Height        = h,
                Depth         = d,
                Dimensions    = dims,
                InitialLayout = ImageLayout.Undefined,
                Layers        = layers,
                Levels        = levels,
                MemoryUsage   = MemoryUsage.GpuOnly,
                Usage         = usage | ImageUsage.TransferDst,
                Format        = format,
            };
            LocalImage.Build(0);

            LocalImageView = new ImageView(Name)
            {
                BaseLayer  = 0,
                BaseLevel  = 0,
                Format     = format,
                LayerCount = layers,
                LevelCount = levels,
                ViewType   = viewType,
            };
            LocalImageView.Build(LocalImage);

            HostBuffer = new GpuBuffer(name + "_host")
            {
                Mapped      = true,
                Size        = buf_sz,
                MemoryUsage = MemoryUsage.CpuToGpu,
                Usage       = BufferUsage.TransferSrc
            };
            HostBuffer.Build(0);
        }