コード例 #1
0
        /// <summary>
        /// Creates device-based resources to store a constant buffer, cube
        /// geometry, and vertex and pixel shaders. In some cases this will also
        /// store a geometry shader.
        /// </summary>
        public async void CreateDeviceDependentResourcesAsync()
        {
            ReleaseDeviceDependentResources();

            usingVprtShaders = deviceResources.D3DDeviceSupportsVprt;

            var folder = Windows.ApplicationModel.Package.Current.InstalledLocation;

            // On devices that do support the D3D11_FEATURE_D3D11_OPTIONS3::
            // VPAndRTArrayIndexFromAnyShaderFeedingRasterizer optional feature
            // we can avoid using a pass-through geometry shader to set the render
            // target array index, thus avoiding any overhead that would be
            // incurred by setting the geometry shader stage.
            var vertexShaderFileName = usingVprtShaders ? "Content\\Shaders\\VPRTVertexShader.cso" : "Content\\Shaders\\VertexShader.cso";

            // Load the compiled vertex shader.
            var vertexShaderByteCode = await DirectXHelper.ReadDataAsync(await folder.GetFileAsync(vertexShaderFileName));

            // After the vertex shader file is loaded, create the shader and input layout.
            vertexShader = this.ToDispose(new SharpDX.Direct3D11.VertexShader(
                                              deviceResources.D3DDevice,
                                              vertexShaderByteCode));

            //TODO: Change VertexDesc to use new structure: VertexPositionTextureCoordinates
            SharpDX.Direct3D11.InputElement[] vertexDesc =
            {
                new SharpDX.Direct3D11.InputElement("POSITION", 0, SharpDX.DXGI.Format.R32G32B32_Float,  0, 0, SharpDX.Direct3D11.InputClassification.PerVertexData, 0),
                new SharpDX.Direct3D11.InputElement("TEXCOORD", 0, SharpDX.DXGI.Format.R32G32B32_Float, 12, 0, SharpDX.Direct3D11.InputClassification.PerVertexData, 0),
            };


            inputLayout = this.ToDispose(new SharpDX.Direct3D11.InputLayout(
                                             deviceResources.D3DDevice,
                                             vertexShaderByteCode,
                                             vertexDesc));

            if (!usingVprtShaders)
            {
                // Load the compiled pass-through geometry shader.
                var geometryShaderByteCode = await DirectXHelper.ReadDataAsync(await folder.GetFileAsync("Content\\Shaders\\GeometryShader.cso"));

                // After the pass-through geometry shader file is loaded, create the shader.
                geometryShader = this.ToDispose(new SharpDX.Direct3D11.GeometryShader(
                                                    deviceResources.D3DDevice,
                                                    geometryShaderByteCode));
            }

            // Load the compiled pixel shader.
            var pixelShaderByteCode = await DirectXHelper.ReadDataAsync(await folder.GetFileAsync("Content\\Shaders\\PixelShader.cso"));

            // After the pixel shader file is loaded, create the shader.
            pixelShader = this.ToDispose(new SharpDX.Direct3D11.PixelShader(
                                             deviceResources.D3DDevice,
                                             pixelShaderByteCode));

            //TODO: Use a photo editing app to create a texture, like GIMP2 with DDS Plugin, make sure photo width & height divisible by 4, for a cube must be an exact square
            //used Gimp 2 with DDS Plugin to create a 2000x2000 image and export at .dds file.
            //in the export options I used BC3_UNorm format, along with automatic MIP levels
            string textureName2 = "Content\\Textures\\nuwaupian_holding_fire3.dds";

            //TODO: Create the SamplerState
            var samplerStateDescription = new SharpDX.Direct3D11.SamplerStateDescription();

            samplerStateDescription.Filter      = SharpDX.Direct3D11.Filter.MinMagMipLinear;
            samplerStateDescription.AddressU    = SharpDX.Direct3D11.TextureAddressMode.Wrap;
            samplerStateDescription.AddressV    = SharpDX.Direct3D11.TextureAddressMode.Wrap;
            samplerStateDescription.AddressW    = SharpDX.Direct3D11.TextureAddressMode.Wrap;
            samplerStateDescription.BorderColor = new SharpDX.Mathematics.Interop.RawColor4(0f, 0f, 0f, 1f);

            samplerState = new SharpDX.Direct3D11.SamplerState(deviceResources.D3DDevice, samplerStateDescription);

            //TODO: Use the TextureLoader class to create a bitmap source from a .DDS texture file
            //Retreived TextureLoader from DirectXTK or DirectText Tool
            var bitmapSource2 = TextureLoader.LoadBitmap(new SharpDX.WIC.ImagingFactory2(), textureName2);

            //TODO: Create a Texture Description to describe the texture you'll be using or converting to
            var textDesc = new SharpDX.Direct3D11.Texture2DDescription()
            {
                Width             = bitmapSource2.Size.Width,
                Height            = bitmapSource2.Size.Height,
                ArraySize         = 6,
                BindFlags         = SharpDX.Direct3D11.BindFlags.ShaderResource,
                Usage             = SharpDX.Direct3D11.ResourceUsage.Default,
                CpuAccessFlags    = SharpDX.Direct3D11.CpuAccessFlags.None,
                Format            = SharpDX.DXGI.Format.R8G8B8A8_UNorm,
                MipLevels         = 1,
                OptionFlags       = SharpDX.Direct3D11.ResourceOptionFlags.TextureCube,
                SampleDescription = new SharpDX.DXGI.SampleDescription(1, 0),
            };

            //TODO: Create Shader Resource View
            var shaderResourceDesc = new SharpDX.Direct3D11.ShaderResourceViewDescription()
            {
                Format      = textDesc.Format,
                Dimension   = SharpDX.Direct3D.ShaderResourceViewDimension.TextureCube,
                TextureCube = new SharpDX.Direct3D11.ShaderResourceViewDescription.TextureCubeResource()
                {
                    MipLevels = textDesc.MipLevels, MostDetailedMip = 0
                }
            };

            //TODO: Create 6 pointers for the 6 sides of the cube, each pointing to an 2000x2000 image you want to display
            IntPtr[] ptrImages = new IntPtr[6];

            //TODO: Get the Stride of each image - stride is the size of 1 row pixels
            int stride = bitmapSource2.Size.Width * 4;

            //TODO: for each of the 6 pointers, create a buffer to hold the pixels using the DataStream object,
            using (var buffer = new SharpDX.DataStream(bitmapSource2.Size.Height * stride, true, true))
            {
                //TODO: for each of the 6 data streams, copy the pixels into a buffer
                // Copy the content of the WIC to the buffer
                bitmapSource2.CopyPixels(stride, buffer);

                //TODO: for each of the 6 pointers get the IntPtr to the buffers, taking care not get rid of the buffers, pointers, or datastreams before we can create the texture cube
                ptrImages[0] = buffer.DataPointer;


                using (var buffer1 = new SharpDX.DataStream(bitmapSource2.Size.Height * stride, true, true))
                {
                    // Copy the content of the WIC to the buffer
                    bitmapSource2.CopyPixels(stride, buffer1);
                    ptrImages[1] = buffer1.DataPointer;


                    using (var buffer2 = new SharpDX.DataStream(bitmapSource2.Size.Height * stride, true, true))
                    {
                        // Copy the content of the WIC to the buffer
                        bitmapSource2.CopyPixels(stride, buffer2);
                        ptrImages[2] = buffer2.DataPointer;

                        using (var buffer3 = new SharpDX.DataStream(bitmapSource2.Size.Height * stride, true, true))
                        {
                            // Copy the content of the WIC to the buffer
                            bitmapSource2.CopyPixels(stride, buffer3);
                            ptrImages[3] = buffer3.DataPointer;

                            using (var buffer4 = new SharpDX.DataStream(bitmapSource2.Size.Height * stride, true, true))
                            {
                                // Copy the content of the WIC to the buffer
                                bitmapSource2.CopyPixels(stride, buffer4);
                                ptrImages[4] = buffer4.DataPointer;

                                using (var buffer5 = new SharpDX.DataStream(bitmapSource2.Size.Height * stride, true, true))
                                {
                                    // Copy the content of the WIC to the buffer
                                    bitmapSource2.CopyPixels(stride, buffer5);
                                    ptrImages[5] = buffer5.DataPointer;


                                    //TODO: create a DataBox of the 6 pixel buffers. The DataBox is the typed array which we described in the TextureDescription and ShaderResource Description to hold the 6 sides
                                    var dataRects = new SharpDX.DataBox[] { new SharpDX.DataBox(ptrImages[0], stride, 0),
                                                                            new SharpDX.DataBox(ptrImages[1], stride, 0),
                                                                            new SharpDX.DataBox(ptrImages[2], stride, 0),
                                                                            new SharpDX.DataBox(ptrImages[3], stride, 0),
                                                                            new SharpDX.DataBox(ptrImages[4], stride, 0),
                                                                            new SharpDX.DataBox(ptrImages[5], stride, 0) };

                                    //TODO: Now create the TextureCube
                                    var texture2D = new SharpDX.Direct3D11.Texture2D(deviceResources.D3DDevice, textDesc, dataRects);

                                    //TODO: Now create the TextureShaderResourceView - which will be used in the PixelShader, after this point we can release all the buffers
                                    textureResource = new SharpDX.Direct3D11.ShaderResourceView(deviceResources.D3DDevice, texture2D, shaderResourceDesc);
                                }
                            }
                        }
                    }
                }
            }

            //TODO: Change to VertexPositionCoordinate
            // Load mesh vertices. Each vertex has a position and a color.
            // Note that the cube size has changed from the default DirectX app
            // template. Windows Holographic is scaled in meters, so to draw the
            // cube at a comfortable size we made the cube width 0.2 m (20 cm).
            VertexPositionCoordinate[] cubeVertices =
            {
                new VertexPositionCoordinate(new Vector3(-0.1f, -0.1f, -0.1f), new Vector3(0.0f, 0.0f, 0.0f)),
                new VertexPositionCoordinate(new Vector3(-0.1f, -0.1f,  0.1f), new Vector3(0.0f, 0.0f, 1.0f)),
                new VertexPositionCoordinate(new Vector3(-0.1f,  0.1f, -0.1f), new Vector3(0.0f, 1.0f, 0.0f)),
                new VertexPositionCoordinate(new Vector3(-0.1f,  0.1f,  0.1f), new Vector3(0.0f, 1.0f, 1.0f)),
                new VertexPositionCoordinate(new Vector3(0.1f,  -0.1f, -0.1f), new Vector3(1.0f, 0.0f, 0.0f)),
                new VertexPositionCoordinate(new Vector3(0.1f,  -0.1f,  0.1f), new Vector3(1.0f, 0.0f, 1.0f)),
                new VertexPositionCoordinate(new Vector3(0.1f,   0.1f, -0.1f), new Vector3(1.0f, 1.0f, 0.0f)),
                new VertexPositionCoordinate(new Vector3(0.1f,   0.1f,  0.1f), new Vector3(1.0f, 1.0f, 1.0f)),
            };

            vertexBuffer = this.ToDispose(SharpDX.Direct3D11.Buffer.Create(
                                              deviceResources.D3DDevice,
                                              SharpDX.Direct3D11.BindFlags.VertexBuffer,
                                              cubeVertices));

            // Load mesh indices. Each trio of indices represents
            // a triangle to be rendered on the screen.
            // For example: 0,2,1 means that the vertices with indexes
            // 0, 2 and 1 from the vertex buffer compose the
            // first triangle of this mesh.
            ushort[] cubeIndices =
            {
                2, 1, 0, // -x
                2, 3, 1,

                6, 4, 5, // +x
                6, 5, 7,

                0, 1, 5, // -y
                0, 5, 4,

                2, 6, 7, // +y
                2, 7, 3,

                0, 4, 6, // -z
                0, 6, 2,

                1, 3, 7, // +z
                1, 7, 5,
            };

            indexCount = cubeIndices.Length;

            indexBuffer = this.ToDispose(SharpDX.Direct3D11.Buffer.Create(
                                             deviceResources.D3DDevice,
                                             SharpDX.Direct3D11.BindFlags.IndexBuffer,
                                             cubeIndices));

            // Create a constant buffer to store the model matrix.
            modelConstantBuffer = this.ToDispose(SharpDX.Direct3D11.Buffer.Create(
                                                     deviceResources.D3DDevice,
                                                     SharpDX.Direct3D11.BindFlags.ConstantBuffer,
                                                     ref modelConstantBufferData));

            // Once the cube is loaded, the object is ready to be rendered.
            loadingComplete = true;
        }
コード例 #2
0
ファイル: VRRenderer.cs プロジェクト: jhartikainen/mscvr
        public VRRenderer(SharpDX.Direct3D11.Device d3d11Device, SharpDX.Direct3D11.Device unityDevice, VRRig rig)
        {
            instance = this;


            this.rig      = rig;
            device        = d3d11Device;
            unityRenderer = unityDevice;

            bounds      = new VRTextureBounds_t();
            bounds.vMin = bounds.uMin = 0;
            bounds.vMax = bounds.uMax = 1;

            var w           = rig.leftTexture.Description.Width;
            var h           = rig.leftTexture.Description.Height;
            var description = new SharpDX.Direct3D11.Texture2DDescription()
            {
                Width  = (int)w,
                Height = (int)h,

                MipLevels = 1,
                ArraySize = 1,

                SampleDescription = new SampleDescription()
                {
                    Count = 1
                },

                BindFlags      = SharpDX.Direct3D11.BindFlags.ShaderResource | SharpDX.Direct3D11.BindFlags.RenderTarget,
                CpuAccessFlags = SharpDX.Direct3D11.CpuAccessFlags.None,
                Format         = Format.R8G8B8A8_UNorm,
                OptionFlags    = SharpDX.Direct3D11.ResourceOptionFlags.Shared,
                Usage          = SharpDX.Direct3D11.ResourceUsage.Default
            };

            System.Diagnostics.Trace.WriteLine("Creating D3D11 Textures");

            leftVRTexture  = new SharpDX.Direct3D11.Texture2D(d3d11Device, description);
            rightVRTexture = new SharpDX.Direct3D11.Texture2D(d3d11Device, description);

            leftEye = new Texture_t()
            {
                eColorSpace = EColorSpace.Gamma,
                eType       = ETextureType.DirectX,
                handle      = leftVRTexture.NativePointer
            };
            rightEye = new Texture_t()
            {
                eColorSpace = EColorSpace.Gamma,
                eType       = ETextureType.DirectX,
                handle      = rightVRTexture.NativePointer
            };


            var sharedHandleLeft  = leftVRTexture.QueryInterface <Resource>().SharedHandle;
            var sharedHandleRight = rightVRTexture.QueryInterface <Resource>().SharedHandle;

            leftHandle  = unityRenderer.OpenSharedResource <SharpDX.Direct3D11.Texture2D>(sharedHandleLeft);
            rightHandle = unityRenderer.OpenSharedResource <SharpDX.Direct3D11.Texture2D>(sharedHandleRight);

            var viewDesc = new SharpDX.Direct3D11.ShaderResourceViewDescription()
            {
                Format    = Format.R8G8B8A8_UNorm,
                Dimension = SharpDX.Direct3D.ShaderResourceViewDimension.Texture2D,
                Texture2D = new SharpDX.Direct3D11.ShaderResourceViewDescription.Texture2DResource()
                {
                    MipLevels       = 1,
                    MostDetailedMip = 0
                }
            };
            var leftView  = new SharpDX.Direct3D11.ShaderResourceView(unityDevice, leftHandle, viewDesc);
            var rightView = new SharpDX.Direct3D11.ShaderResourceView(unityDevice, rightHandle, viewDesc);

            leftUnityTexture  = Texture2D.CreateExternalTexture(w, h, TextureFormat.ARGB32, false, false, leftView.NativePointer);
            rightUnityTexture = Texture2D.CreateExternalTexture(w, h, TextureFormat.ARGB32, false, false, rightView.NativePointer);
        }