public void Update(IPluginIO pin, DX11RenderContext context)
        {
            Device device = context.Device;

            if (this.spmax == 0)
            {
                return;
            }

            if (this.updateddevices.Contains(context))
            {
                return;
            }

            if (!this.FOutCubeTexture[0].Contains(context))
            {
                var cube = new DX11CubeRenderTarget(context, this.FInSize[0], this.sd, DeviceFormatHelper.GetFormat(this.FInFormat[0].Name), false, 1);
                this.FOutCubeTexture[0][context]      = cube;
                this.FOutCubeDepthTexture[0][context] = new DX11CubeDepthStencil(context, this.FInSize[0], this.sd, Format.D24_UNorm_S8_UInt);
                for (int i = 0; i < 6; i++)
                {
                    this.FOutSliceTextures[i][context] = DX11Texture2D.FromTextureAndSRV(context, cube.Resource, cube.SliceRTV[i].SRV);
                }
            }

            this.updateddevices.Add(context);
        }
Пример #2
0
        protected override void OnUpdate(DX11RenderContext context)
        {
            if (this.resetbuffers || !this.FOutTexture[0].Contains(context))
            {
                this.DisposeBuffers(context);

                DX11CubeRenderTarget rt = new DX11CubeRenderTarget(context, this.size, new SampleDescription(1, 0),
                                                                   DeviceFormatHelper.GetFormat(this.FInFormat[0].Name), this.genmipmap, this.mipmaplevel);

                this.FOutTexture[0][context] = rt;
            }
        }
Пример #3
0
        public void Render(DX11RenderContext context)
        {
            Device device = context.Device;

            //Just in case
            if (!this.updateddevices.Contains(context))
            {
                this.Update(null, context);
            }

            if (this.rendereddevices.Contains(context))
            {
                return;
            }

            if (this.FInEnabled[0])
            {
                if (this.BeginQuery != null)
                {
                    this.BeginQuery(context);
                }

                DX11CubeRenderTarget target = this.FOutCubeTexture[0][context];
                DX11CubeDepthStencil depth  = this.FOutCubeDepthTexture[0][context];

                if (this.FInClear[0])
                {
                    context.CurrentDeviceContext.ClearRenderTargetView(target.RTV, this.FInBgColor[0]);

                    if (this.FInDepthBuffer[0])
                    {
                        context.CurrentDeviceContext.ClearDepthStencilView(depth.DSV, DepthStencilClearFlags.Depth, 1.0f, 0);
                    }
                }

                if (this.FInLayer.PluginIO.IsConnected)
                {
                    int size = this.FInSize[0];

                    Matrix proj = Matrix.PerspectiveFovLH((float)Math.PI * 0.5f, 1.0f, this.FInNear[0], this.FInFar[0]);

                    for (int i = 0; i < 6; i++)
                    {
                        settings.ViewportIndex = i;
                        settings.ViewportCount = 6;

                        Vector3 p = this.FInPosition[0];

                        Vector3 t = p + this.lookatvectors[i];

                        settings.View           = Matrix.LookAtLH(p, t, this.upvectors[i]);
                        settings.Projection     = proj;
                        settings.ViewProjection = settings.View * settings.Projection;
                        settings.RenderWidth    = size;
                        settings.RenderHeight   = size;
                        settings.BackBuffer     = null;
                        settings.CustomSemantics.Clear();
                        settings.ResourceSemantics.Clear();

                        if (this.FInDepthBuffer[0])
                        {
                            context.RenderTargetStack.Push(depth.SliceDSV[i], false, target.SliceRTV[i]);
                        }
                        else
                        {
                            context.RenderTargetStack.Push(target.SliceRTV[i]);
                        }



                        for (int j = 0; j < this.FInLayer.SliceCount; j++)
                        {
                            try
                            {
                                this.FInLayer[j][context].Render(this.FInLayer.PluginIO, context, settings);
                            }
                            catch (Exception ex)
                            {
                                Console.WriteLine(ex.Message);
                            }
                        }

                        context.RenderTargetStack.Pop();
                    }
                }


                if (this.EndQuery != null)
                {
                    this.EndQuery(context);
                }

                this.rendereddevices.Add(context);
            }
        }