/// <summary> /// Gets the view-projection constant buffer for the display, and attaches it /// to the shader pipeline. /// </summary> public bool AttachViewProjectionBuffer(DeviceResources deviceResources) { // This method uses Direct3D device-based resources. var context = deviceResources.D3DDeviceContext; // Loading is asynchronous. Resources must be created before they can be updated. // Cameras can also be added asynchronously, in which case they must be initialized // before they can be used. if (context == null || viewProjectionConstantBuffer == null || !framePending) { return(false); } // Set the viewport for this camera. context.Rasterizer.SetViewport(Viewport); // Send the constant buffer to the vertex shader. context.VertexShader.SetConstantBuffers(1, viewProjectionConstantBuffer); // The template includes a pass-through geometry shader that is used by // default on systems that don't support the D3D11_FEATURE_D3D11_OPTIONS3:: // VPAndRTArrayIndexFromAnyShaderFeedingRasterizer extension. The shader // will be enabled at run-time on systems that require it. // If your app will also use the geometry shader for other tasks and those // tasks require the view/projection matrix, uncomment the following line // of code to send the constant buffer to the geometry shader as well. //context.GeometryShader.SetConstantBuffers(1, viewProjectionConstantBuffer); framePending = false; return(true); }
public RenderableCubemap(DeviceResources resources, Vector3 position, int resolution = 1024, int mipCount = 1) { Resources = resources; Position = position; Resolution = resolution; MipCount = mipCount; MipRenderTargetViews = new RenderTargetView[MipCount]; MipShaderResourceViews = new ShaderResourceView[MipCount]; RenderTargetViews = new ReadOnlyCollection <RenderTargetView>(MipRenderTargetViews); ShaderResourceViews = new ReadOnlyCollection <ShaderResourceView>(MipShaderResourceViews); }
public static void ExportTexture(DeviceResources resources, StorageFile textureFile, Texture2D texture) { var device = resources.D3DDevice; var context = resources.D3DDeviceContext; var textureToSave = texture; var outputTexture = new Texture2D(device, new Texture2DDescription { Width = textureToSave.Description.Width, Height = textureToSave.Description.Height, MipLevels = 1, ArraySize = 1, Format = textureToSave.Description.Format, Usage = ResourceUsage.Staging, SampleDescription = new SampleDescription(1, 0), BindFlags = BindFlags.None, CpuAccessFlags = CpuAccessFlags.Read, OptionFlags = ResourceOptionFlags.None }); context.CopyResource(textureToSave, outputTexture); var mappedResource = context.MapSubresource(outputTexture, 0, 0, MapMode.Read, SharpDX.Direct3D11.MapFlags.None, out var dataStream); var dataRectangle = new DataRectangle { DataPointer = dataStream.DataPointer, Pitch = mappedResource.RowPitch }; var imagingFactory = new ImagingFactory(); var bitmap = new Bitmap(imagingFactory, outputTexture.Description.Width, outputTexture.Description.Height, PixelFormat.Format32bppRGBA, dataRectangle); using (var stream = new MemoryStream()) using (var bitmapEncoder = new PngBitmapEncoder(imagingFactory, stream)) using (var bitmapFrame = new BitmapFrameEncode(bitmapEncoder)) { bitmapFrame.Initialize(); bitmapFrame.SetSize(bitmap.Size.Width, bitmap.Size.Height); var pixelFormat = PixelFormat.FormatDontCare; bitmapFrame.SetPixelFormat(ref pixelFormat); bitmapFrame.WriteSource(bitmap); bitmapFrame.Commit(); bitmapEncoder.Commit(); FileIO.WriteBytesAsync(textureFile, stream.ToArray()).AsTask().Wait(-1); } context.UnmapSubresource(outputTexture, 0); outputTexture.Dispose(); bitmap.Dispose(); }
/// <summary> /// Releases resources associated with a holographic display back buffer. /// </summary> public void ReleaseResourcesForBackBuffer(DeviceResources deviceResources) { var context = deviceResources.D3DDeviceContext; RemoveAndDispose(ref d3dBackBuffer); RemoveAndDispose(ref d3dRenderTargetView); RemoveAndDispose(ref d3dDepthStencilView); const int D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT = 8; RenderTargetView[] nullViews = new RenderTargetView[D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT]; // Ensure system references to the back buffer are released by clearing the render // target from the graphics pipeline state, and then flushing the Direct3D context. context.OutputMerger.SetRenderTargets(null, nullViews); context.Flush(); }
public static async Task <Model> LoadObj(DeviceResources deviceResources, string path) { var folder = Windows.ApplicationModel.Package.Current.InstalledLocation; var fileContent = await FileIO.ReadLinesAsync(await folder.GetFileAsync(path)); var positions = new List <Vector3>(); var uvs = new List <Vector2>(); var normals = new List <Vector3>(); var output = new List <VertexPositionNormalUV>(); foreach (var line in fileContent) { var parts = line.Split(' '); if (parts[0] == "v") { positions.Add(new Vector3(float.Parse(parts[1]), float.Parse(parts[2]), float.Parse(parts[3]))); } else if (parts[0] == "vt") { uvs.Add(new Vector2(float.Parse(parts[1]), float.Parse(parts[2]))); } else if (parts[0] == "vn") { normals.Add(new Vector3(float.Parse(parts[1]), float.Parse(parts[2]), float.Parse(parts[3]))); } else if (parts[0] == "f") { for (int i = 1; i <= 3; i++) { var indices = parts[i].Split('/').Select(index => int.Parse(index) - 1).ToArray(); output.Add(new VertexPositionNormalUV { Position = positions[indices[0]], UV = uvs[indices[1]], Normal = normals[indices[2]] }); } } } return(new Model(deviceResources, output.ToArray())); }
/// <summary> /// Updates resources associated with a holographic camera's swap chain. /// The app does not access the swap chain directly, but it does create /// resource views for the back buffer. /// </summary> public void CreateResourcesForBackBuffer( DeviceResources deviceResources, HolographicCameraRenderingParameters cameraParameters ) { var device = deviceResources.D3DDevice; // Get the WinRT object representing the holographic camera's back buffer. IDirect3DSurface surface = cameraParameters.Direct3D11BackBuffer; // Get a DXGI interface for the holographic camera's back buffer. // Holographic cameras do not provide the DXGI swap chain, which is owned // by the system. The Direct3D back buffer resource is provided using WinRT // interop APIs. InteropStatics.IDirect3DDxgiInterfaceAccess surfaceDxgiInterfaceAccess = surface as InteropStatics.IDirect3DDxgiInterfaceAccess; IntPtr pResource = surfaceDxgiInterfaceAccess.GetInterface(InteropStatics.ID3D11Resource); SharpDX.Direct3D11.Resource resource = SharpDX.Direct3D11.Resource.FromPointer <SharpDX.Direct3D11.Resource>(pResource); Marshal.Release(pResource); // Get a Direct3D interface for the holographic camera's back buffer. Texture2D cameraBackBuffer = resource.QueryInterface <Texture2D>(); // Determine if the back buffer has changed. If so, ensure that the render target view // is for the current back buffer. if ((null == d3dBackBuffer) || (d3dBackBuffer.NativePointer != cameraBackBuffer.NativePointer)) { // This can change every frame as the system moves to the next buffer in the // swap chain. This mode of operation will occur when certain rendering modes // are activated. d3dBackBuffer = cameraBackBuffer; // Create a render target view of the back buffer. // Creating this resource is inexpensive, and is better than keeping track of // the back buffers in order to pre-allocate render target views for each one. d3dRenderTargetView = ToDispose(new RenderTargetView(device, BackBufferTexture2D)); // Get the DXGI format for the back buffer. // This information can be accessed by the app using CameraResources::GetBackBufferDXGIFormat(). Texture2DDescription backBufferDesc = BackBufferTexture2D.Description; dxgiFormat = backBufferDesc.Format; // Check for render target size changes. Size currentSize = holographicCamera.RenderTargetSize; if (d3dRenderTargetSize != currentSize) { // Set render target size. d3dRenderTargetSize = HolographicCamera.RenderTargetSize; // A new depth stencil view is also needed. RemoveAndDispose(ref d3dDepthStencilView); } } // Refresh depth stencil resources, if needed. if (null == DepthStencilView) { // Create a depth stencil view for use with 3D rendering if needed. var depthStencilDesc = new Texture2DDescription { Format = SharpDX.DXGI.Format.D16_UNorm, Width = (int)RenderTargetSize.Width, Height = (int)RenderTargetSize.Height, ArraySize = IsRenderingStereoscopic ? 2 : 1, // Create two textures when rendering in stereo. MipLevels = 1, // Use a single mipmap level. BindFlags = BindFlags.DepthStencil, SampleDescription = new SharpDX.DXGI.SampleDescription(1, 0) }; using (var depthStencil = new Texture2D(device, depthStencilDesc)) { var depthStencilViewDesc = new DepthStencilViewDescription(); depthStencilViewDesc.Dimension = IsRenderingStereoscopic ? DepthStencilViewDimension.Texture2DArray : DepthStencilViewDimension.Texture2D; depthStencilViewDesc.Texture2DArray.ArraySize = IsRenderingStereoscopic ? 2 : 0; d3dDepthStencilView = ToDispose(new DepthStencilView(device, depthStencil, depthStencilViewDesc)); } } // Create the constant buffer, if needed. if (null == viewProjectionConstantBuffer) { // Create a constant buffer to store view and projection matrices for the camera. ViewProjectionConstantBuffer viewProjectionConstantBufferData = new ViewProjectionConstantBuffer(); viewProjectionConstantBuffer = ToDispose(SharpDX.Direct3D11.Buffer.Create( device, BindFlags.ConstantBuffer, ref viewProjectionConstantBufferData)); } }
/// <summary> /// Updates the constant buffer for the display with view and projection /// matrices for the current frame. /// </summary> public void UpdateViewProjectionBuffer( DeviceResources deviceResources, HolographicCameraPose cameraPose, SpatialCoordinateSystem coordinateSystem ) { // The system changes the viewport on a per-frame basis for system optimizations. d3dViewport.X = (float)cameraPose.Viewport.Left; d3dViewport.Y = (float)cameraPose.Viewport.Top; d3dViewport.Width = (float)cameraPose.Viewport.Width; d3dViewport.Height = (float)cameraPose.Viewport.Height; d3dViewport.MinDepth = 0; d3dViewport.MaxDepth = 1; // The projection transform for each frame is provided by the HolographicCameraPose. HolographicStereoTransform cameraProjectionTransform = cameraPose.ProjectionTransform; // Get a container object with the view and projection matrices for the given // pose in the given coordinate system. HolographicStereoTransform?viewTransformContainer = cameraPose.TryGetViewTransform(coordinateSystem); // If TryGetViewTransform returns null, that means the pose and coordinate system // cannot be understood relative to one another; content cannot be rendered in this // coordinate system for the duration of the current frame. // This usually means that positional tracking is not active for the current frame, in // which case it is possible to use a SpatialLocatorAttachedFrameOfReference to render // content that is not world-locked instead. ViewProjectionConstantBuffer viewProjectionConstantBufferData = new ViewProjectionConstantBuffer(); bool viewTransformAcquired = viewTransformContainer.HasValue; if (viewTransformAcquired) { // Otherwise, the set of view transforms can be retrieved. HolographicStereoTransform viewCoordinateSystemTransform = viewTransformContainer.Value; // Update the view matrices. Holographic cameras (such as Microsoft HoloLens) are // constantly moving relative to the world. The view matrices need to be updated // every frame. viewProjectionConstantBufferData.viewProjectionLeft = Matrix4x4.Transpose( viewCoordinateSystemTransform.Left * cameraProjectionTransform.Left ); viewProjectionConstantBufferData.viewProjectionRight = Matrix4x4.Transpose( viewCoordinateSystemTransform.Right * cameraProjectionTransform.Right ); } // Use the D3D device context to update Direct3D device-based resources. var context = deviceResources.D3DDeviceContext; // Loading is asynchronous. Resources must be created before they can be updated. if (context == null || viewProjectionConstantBuffer == null || !viewTransformAcquired) { framePending = false; } else { // Update the view and projection matrices. context.UpdateSubresource(ref viewProjectionConstantBufferData, viewProjectionConstantBuffer); framePending = true; } }
public void ReleaseAllDeviceResources(DeviceResources deviceResources) { ReleaseResourcesForBackBuffer(deviceResources); RemoveAndDispose(ref viewProjectionConstantBuffer); }
public MeshTextureSet(DeviceResources resources, int resolution) { Resources = resources; Resolution = resolution; }