Пример #1
0
        public void UpdateVolumeTexture(float[, ,] volumeData)
        {
            VolumeTexture tmp = _texture[0];

            _texture[0] = _texture[1];

            int temp = 0;
            int nz   = volumeData.GetLength(0);

            if (texture != null)
            {
                texture.Dispose();
            }
            texture = new VolumeTexture(DrawArgs.Device, _nx, _ny, nz, 1, Usage.None, Format.A8R8G8B8, Pool.Managed);
            DataBox      db = texture.LockBox(0, LockFlags.None);
            BinaryWriter bw = new BinaryWriter(db.Data);

            bw.Seek(0, SeekOrigin.Begin);
            for (int l = 0; l < nz; l++)
            {
                for (int r = 0; r < _ny; r++)
                {
                    for (int c = 0; c < _nx; c++)
                    {
                        temp = _dvr.ActualValueToTransferMapCoord(volumeData[l, r + _iy, c + _ix]);
                        bw.Write(temp << 16);
                    }
                }
            }
            texture.UnlockBox(0);

            _texture[1] = texture;
            tmp.Dispose();
            GC.Collect();
        }
Пример #2
0
        public void Run(OpsContext context, OpsStatement statement)
        {
            ShadeArgs args = statement.Arguments as ShadeArgs;

            ConstantTable constantTable = SetupDevice(context, args);

            EffectHandle hTarget = constantTable.GetConstant(null, "Target");


            ArrayList containers = statement.GetContent(context);

            OpsConsole.WriteLine("Shading textures with \"{0}\"", args.File);

            foreach (OpsTexture container in containers)
            {
                if (hTarget != null)
                {
                    context.Device.SetTexture(
                        constantTable.GetSamplerIndex(hTarget),
                        container.Texture);
                }


                if (container.Texture is Texture)
                {
                    Texture oldTexture = container.Texture as Texture;
                    Texture newTexture = OpsTextureHelper.CloneTexture(oldTexture, Usage.None, Pool.Managed);

                    for (int mip = 0; mip < oldTexture.LevelCount; mip++)
                    {
                        SurfaceDescription sd = oldTexture.GetLevelDescription(mip);

                        CheckFormatValid(sd.Format);

                        Surface rt = context.Device.CreateRenderTarget(sd.Width, sd.Height, sd.Format, MultiSampleType.None, 0, true);

                        context.Device.SetRenderTarget(0, rt);


                        ShadeVertex[] vb = new ShadeVertex[]
                        {
                            ShadeVertex.ForTexture(-1.0f, -1.0f, sd.Width, sd.Height),
                            ShadeVertex.ForTexture(1.0f, -1.0f, sd.Width, sd.Height),
                            ShadeVertex.ForTexture(-1.0f, 1.0f, sd.Width, sd.Height),
                            ShadeVertex.ForTexture(1.0f, 1.0f, sd.Width, sd.Height),
                        };

                        context.Device.BeginScene();
                        context.Device.DrawUserPrimitives(PrimitiveType.TriangleStrip, 2, vb);
                        context.Device.EndScene();

                        context.Device.SetRenderTarget(0, context.Device.GetBackBuffer(0, 0, BackBufferType.Mono));

                        SurfaceLoader.FromSurface(newTexture.GetSurfaceLevel(mip), rt, Filter.None | (container.SRGB?Filter.SrgbOut:0), 0);
                    }

                    oldTexture.Dispose();
                    container.Texture = newTexture;
                }
                else if (container.Texture is VolumeTexture)
                {
                    VolumeTexture oldTexture = container.Texture as VolumeTexture;
                    VolumeTexture newTexture = OpsTextureHelper.CloneVolume(oldTexture, Usage.None, Pool.Managed);

                    for (int mip = 0; mip < oldTexture.LevelCount; mip++)
                    {
                        VolumeDescription vd = oldTexture.GetLevelDescription(mip);

                        CheckFormatValid(vd.Format);

                        Surface sliceRT = context.Device.CreateRenderTarget(vd.Width, vd.Height, vd.Format, MultiSampleType.None, 0, true);

                        for (int slice = 0; slice < vd.Depth; slice++)
                        {
                            context.Device.SetRenderTarget(0, sliceRT);

                            ShadeVertex[] vb = new ShadeVertex[]
                            {
                                ShadeVertex.ForVolume(-1.0f, -1.0f, slice, vd.Width, vd.Height, vd.Depth),
                                ShadeVertex.ForVolume(1.0f, -1.0f, slice, vd.Width, vd.Height, vd.Depth),
                                ShadeVertex.ForVolume(-1.0f, 1.0f, slice, vd.Width, vd.Height, vd.Depth),
                                ShadeVertex.ForVolume(1.0f, 1.0f, slice, vd.Width, vd.Height, vd.Depth),
                            };

                            context.Device.BeginScene();
                            context.Device.DrawUserPrimitives(PrimitiveType.TriangleStrip, 2, vb);
                            context.Device.EndScene();

                            context.Device.SetRenderTarget(0, context.Device.GetBackBuffer(0, 0, BackBufferType.Mono));

                            OpsTextureHelper.LoadVolumeSliceFromSurface(newTexture, mip, slice, Filter.None | (container.SRGB?Filter.SrgbOut:0), sliceRT);
                        }

                        sliceRT.Dispose();
                    }

                    oldTexture.Dispose();
                    container.Texture = newTexture;
                }
                else if (container.Texture is CubeTexture)
                {
                    CubeTexture oldTexture = container.Texture as CubeTexture;
                    CubeTexture newTexture = OpsTextureHelper.CloneCube(oldTexture, Usage.None, Pool.Managed);

                    for (int mip = 0; mip < oldTexture.LevelCount; mip++)
                    {
                        SurfaceDescription sd = oldTexture.GetLevelDescription(mip);

                        CheckFormatValid(sd.Format);

                        Surface rt = context.Device.CreateRenderTarget(sd.Width, sd.Height, sd.Format, MultiSampleType.None, 0, true);

                        RenderCubeMapFace(context, newTexture, rt, CubeMapFace.PositiveX, mip, sd.Width, container.SRGB);
                        RenderCubeMapFace(context, newTexture, rt, CubeMapFace.PositiveY, mip, sd.Width, container.SRGB);
                        RenderCubeMapFace(context, newTexture, rt, CubeMapFace.PositiveZ, mip, sd.Width, container.SRGB);
                        RenderCubeMapFace(context, newTexture, rt, CubeMapFace.NegativeX, mip, sd.Width, container.SRGB);
                        RenderCubeMapFace(context, newTexture, rt, CubeMapFace.NegativeY, mip, sd.Width, container.SRGB);
                        RenderCubeMapFace(context, newTexture, rt, CubeMapFace.NegativeZ, mip, sd.Width, container.SRGB);
                    }

                    oldTexture.Dispose();

                    container.Texture = newTexture;
                }
            }
        }