コード例 #1
0
 public static RenderVoxelVolumeData GetDataForComponent(VoxelVolumeComponent component)
 {
     if (!renderVoxelVolumeData.TryGetValue(component, out var data))
     {
         return(null);
     }
     return(data);
 }
コード例 #2
0
        public override Task <Entity> CreateEntity(EntityHierarchyItemViewModel parent)
        {
            var name      = ComputeNewName(parent, "Voxel volume");
            var component = new VoxelVolumeComponent {
                Attributes = { new VoxelAttributeEmissionOpacity() }
            };

            return(CreateEntityWithComponent(name, component));
        }
コード例 #3
0
        public virtual void Draw(RenderDrawContext drawContext, IShadowMapRenderer ShadowMapRenderer)
        {
            if (renderVoxelVolumes == null)
            {
                return;
            }
            var context      = drawContext;
            var renderSystem = drawContext.RenderContext.RenderSystem;

            using (drawContext.PushRenderTargetsAndRestore())
            {
                // Draw all shadow views generated for the current view
                foreach (var renderView in renderSystem.Views)
                {
                    VoxelVolumeComponent component = null;

                    if (reflectiveVoxelViews.TryGetValue(renderView, out component))
                    {
                        RenderView voxelizeRenderView = renderView;
                        var        data = renderVoxelVolumeData[component];

                        if (data.ClipMapResolution.X < 16 || data.ClipMapResolution.Y < 16 || data.ClipMapResolution.Z < 16)
                        {
                            continue;
                        }

                        //Render Shadow Maps
                        RenderView oldView = drawContext.RenderContext.RenderView;

                        drawContext.RenderContext.RenderView = voxelizeRenderView;
                        ShadowMapRenderer.Draw(drawContext);

                        drawContext.RenderContext.RenderView = oldView;

                        //Render/Collect voxel fragments
                        using (drawContext.QueryManager.BeginProfile(Color.Black, FragmentVoxelizationProfilingKey))
                        {
                            drawContext.CommandList.ResetTargets();
                            drawContext.CommandList.SetRenderTarget(null, MSAARenderTarget);
                            float maxResolution = Math.Max(Math.Max(data.ClipMapResolution.X, data.ClipMapResolution.Y), data.ClipMapResolution.Z);
                            drawContext.CommandList.SetViewport(new Viewport(0, 0, (int)maxResolution, (int)maxResolution));
                            renderSystem.Draw(drawContext, voxelizeRenderView, renderSystem.RenderStages[voxelizeRenderView.RenderStages[0].Index]);
                        }

                        //Fill and write to voxel volume
                        using (drawContext.QueryManager.BeginProfile(Color.Black, ArrangementVoxelizationProfilingKey))
                        {
                            context.CommandList.ClearReadWrite(data.ClipMaps, new Vector4(0.0f));

                            ArrangeFragments.ThreadGroupCounts = new Int3(16, 16, 1);
                            ArrangeFragments.ThreadNumbers     = new Int3((int)data.ClipMapResolution.X / ArrangeFragments.ThreadGroupCounts.X, (int)data.ClipMapResolution.Y / ArrangeFragments.ThreadGroupCounts.Y, data.ClipMapCount / ArrangeFragments.ThreadGroupCounts.Z);
                            ArrangeFragments.Parameters.Set(ArrangeFragmentsKeys.VoxelFragmentsCounts, FragmentsCounter);
                            ArrangeFragments.Parameters.Set(ArrangeFragmentsKeys.VoxelFragments, Fragments);
                            ArrangeFragments.Parameters.Set(ArrangeFragmentsKeys.VoxelVolumeW0, data.ClipMaps);
                            ArrangeFragments.Parameters.Set(ArrangeFragmentsKeys.clipMapResolution, data.ClipMapResolution);
                            ((RendererBase)ArrangeFragments).Draw(context);


                            context.CommandList.ClearReadWrite(FragmentsCounter, new Vector4(0));
                        }

                        //Mipmap
                        using (drawContext.QueryManager.BeginProfile(Color.Black, MipmappingVoxelizationProfilingKey))
                        {
                            ClearBuffer.ThreadGroupCounts = new Int3(64, 1, 1);
                            ClearBuffer.ThreadNumbers     = new Int3(FragmentsCounter.ElementCount / ClearBuffer.ThreadGroupCounts.X, 1 / ClearBuffer.ThreadGroupCounts.Y, 1 / ClearBuffer.ThreadGroupCounts.Z);
                            ClearBuffer.Parameters.Set(ClearBufferKeys.buffer, FragmentsCounter);
                            ((RendererBase)ClearBuffer).Draw(context);

                            //Mipmap
                            Vector3 resolution        = data.ClipMapResolution;
                            Int3    threadGroupCounts = new Int3(8, 8, 8);
                            for (int i = 0; i < TempMipMaps.Length - 1; i++)
                            {
                                resolution /= 2;
                                if (resolution.X < threadGroupCounts.X || resolution.Y < threadGroupCounts.Y || resolution.Z < threadGroupCounts.Z)
                                {
                                    threadGroupCounts /= 4;
                                    if (threadGroupCounts.X < 1)
                                    {
                                        threadGroupCounts.X = 1;
                                    }
                                    if (threadGroupCounts.Y < 1)
                                    {
                                        threadGroupCounts.Y = 1;
                                    }
                                    if (threadGroupCounts.Z < 1)
                                    {
                                        threadGroupCounts.Z = 1;
                                    }
                                }
                                Generate3DMipmaps.ThreadGroupCounts = threadGroupCounts;
                                Generate3DMipmaps.ThreadNumbers     = new Int3((int)resolution.X / threadGroupCounts.X, (int)resolution.Y / threadGroupCounts.Y, (int)resolution.Z / threadGroupCounts.Z);

                                if (i == 0)
                                {
                                    Generate3DMipmaps.Parameters.Set(Generate3DMipmapsKeys.VoxelsTexR, data.ClipMaps);
                                }
                                else
                                {
                                    Generate3DMipmaps.Parameters.Set(Generate3DMipmapsKeys.VoxelsTexR, TempMipMaps[i - 1]);
                                }
                                Generate3DMipmaps.Parameters.Set(Generate3DMipmapsKeys.VoxelsTexW, TempMipMaps[i]);
                                ((RendererBase)Generate3DMipmaps).Draw(context);
                                //Don't seem to be able to read and write to the same texture, even if the views
                                //point to different mipmaps.
                                context.CommandList.CopyRegion(TempMipMaps[i], 0, null, data.MipMaps, i);
                            }
                        }
                    }
                }
            }
        }