July 2017 (217e3d68) · Commits · for microsoft in general / xbox / tunip3 / Xbox-ATG-Samples

Kits/ATGTK/ControllerHelp.h

+7 −0

Original line number	Diff line number	Diff line
		@@ -67,6 +67,13 @@ namespace ATG
		public:
		Help(_In_z_ const wchar_t* title, _In_z_ const wchar_t* description,
		_In_count_(buttonCount) const HelpButtonAssignment* buttons, size_t buttonCount, bool linearColors = false);

		Help(Help&&) = default;
		Help& operator= (Help&&) = default;

		Help(Help const&) = delete;
		Help& operator= (Help const&) = delete;

		~Help();

		#if defined(__d3d12_h__) \|\| defined(__d3d12_x_h__)

Kits/ATGTK/PBREffect/PBREffect_Math.hlsli

+5 −0

Original line number	Diff line number	Diff line
		@@ -12,6 +12,11 @@

		static const float PI = 3.14159265f;

		float3 BiasX2(float3 x)
		{
		return 2.0f * x - 1.0f;
		}

		// Given a local normal, transform it into a tangent space given by surface normal and tangent
		float3 PeturbNormal(float3 localNormal, float3 surfaceNormalWS, float3 surfaceTangentWS)
		{

Kits/ATGTK/PBREffect/PBREffect_PSTextured.hlsl

+1 −1

Original line number	Diff line number	Diff line
		@@ -18,7 +18,7 @@ float4 PSTextured(PSInputPixelLightingTxTangent pin) : SV_Target0
		const float3 L = normalize(-PBR_LightDirection[0]); // light vector ("to light" oppositve of light's direction)

		// Before lighting, peturb the surface's normal by the one given in normal map.
		float3 localNormal = (PBR_NormalTexture.Sample(PBR_SurfaceSampler, pin.TexCoord).xyz * 2) - 1;
		float3 localNormal = BiasX2(PBR_NormalTexture.Sample(PBR_SurfaceSampler, pin.TexCoord).xyz);

		float3 N = PeturbNormal( localNormal, pin.NormalWS, pin.TangentWS);

Kits/ATGTK/RenderTexture.cpp

0 → 100644

+303 −0

Original line number	Diff line number	Diff line
		//--------------------------------------------------------------------------------------
		// File: RenderTexture.cpp
		//
		// Helper for managing offscreen render targets
		//
		// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
		// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
		// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
		// PARTICULAR PURPOSE.
		//
		// Copyright (c) Microsoft Corporation. All rights reserved.
		//-------------------------------------------------------------------------------------

		#pragma once

		#include "pch.h"
		#include "RenderTexture.h"

		#include "DirectXHelpers.h"

		#include <algorithm>
		#include <stdio.h>
		#include <stdexcept>

		#include <wrl/client.h>

		using namespace DirectX;
		using namespace DX;

		using Microsoft::WRL::ComPtr;

		#if defined(__d3d12_h__) \|\| defined(__d3d12_x_h__)
		//======================================================================================
		// Direct3D 12
		//======================================================================================
		RenderTexture::RenderTexture(DXGI_FORMAT format) :
		m_format(format),
		m_width(0),
		m_height(0),
		m_state(D3D12_RESOURCE_STATE_COMMON),
		m_srvDescriptor{},
		m_rtvDescriptor{},
		m_clearColor{}
		{
		}

		void RenderTexture::SetDevice(_In_ ID3D12Device* device, D3D12_CPU_DESCRIPTOR_HANDLE srvDescriptor, D3D12_CPU_DESCRIPTOR_HANDLE rtvDescriptor)
		{
		if (device == m_device.Get()
		&& srvDescriptor.ptr == m_srvDescriptor.ptr
		&& rtvDescriptor.ptr == m_rtvDescriptor.ptr)
		return;

		if (m_device)
		{
		ReleaseDevice();
		}

		{
		D3D12_FEATURE_DATA_FORMAT_SUPPORT formatSupport = { m_format };
		if (FAILED(device->CheckFeatureSupport(D3D12_FEATURE_FORMAT_SUPPORT, &formatSupport, sizeof(formatSupport))))
		{
		throw std::exception("CheckFeatureSupport");
		}

		UINT required = D3D12_FORMAT_SUPPORT1_TEXTURE2D \| D3D12_FORMAT_SUPPORT1_SHADER_SAMPLE \| D3D12_FORMAT_SUPPORT1_RENDER_TARGET;
		if ((formatSupport.Support1 & required) != required)
		{
		#ifdef _DEBUG
		char buff[128] = {};
		sprintf_s(buff, "RenderTexture: Device does not support the requested format (%u)!\n", m_format);
		OutputDebugStringA(buff);
		#endif
		throw std::exception("RenderTexture");
		}
		}

		if (!srvDescriptor.ptr \|\| !rtvDescriptor.ptr)
		{
		throw std::exception("Invalid descriptors");
		}

		m_device = device;

		m_srvDescriptor = srvDescriptor;
		m_rtvDescriptor = rtvDescriptor;
		}

		void RenderTexture::SizeResources(size_t width, size_t height)
		{
		if (width == m_width && height == m_height)
		return;

		if (m_width > UINT32_MAX \|\| m_height > UINT32_MAX)
		{
		throw std::out_of_range("Invalid width/height");
		}

		if (!m_device)
		return;

		m_width = m_height = 0;

		auto heapProperties = CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT);

		D3D12_RESOURCE_DESC desc = CD3DX12_RESOURCE_DESC::Tex2D(m_format,
		static_cast<UINT64>(width),
		static_cast<UINT>(height),
		1, 1, 1, 0, D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET);

		D3D12_CLEAR_VALUE clearValue = { m_format };
		memcpy(clearValue.Color, m_clearColor, sizeof(clearValue.Color));

		m_state = D3D12_RESOURCE_STATE_RENDER_TARGET;

		// Create a render target
		ThrowIfFailed(
		m_device->CreateCommittedResource(&heapProperties, D3D12_HEAP_FLAG_ALLOW_ALL_BUFFERS_AND_TEXTURES,
		&desc,
		m_state, &clearValue,
		IID_GRAPHICS_PPV_ARGS(m_resource.ReleaseAndGetAddressOf()))
		);

		SetDebugObjectName(m_resource.Get(), L"RenderTexture RT");

		// Create RTV.
		m_device->CreateRenderTargetView(m_resource.Get(), nullptr, m_rtvDescriptor);

		// Create SRV.
		m_device->CreateShaderResourceView(m_resource.Get(), nullptr, m_srvDescriptor);

		m_width = width;
		m_height = height;
		}

		void RenderTexture::ReleaseDevice()
		{
		m_resource.Reset();
		m_device.Reset();

		m_state = D3D12_RESOURCE_STATE_COMMON;
		m_width = m_height = 0;

		m_srvDescriptor.ptr = m_rtvDescriptor.ptr = 0;
		}

		void RenderTexture::TransitionTo(_In_ ID3D12GraphicsCommandList* commandList, D3D12_RESOURCE_STATES afterState)
		{
		TransitionResource(commandList, m_resource.Get(), m_state, afterState);
		m_state = afterState;
		}

		#else
		//======================================================================================
		// Direct3D 11
		//======================================================================================
		RenderTexture::RenderTexture(DXGI_FORMAT format) :
		m_format(format),
		m_width(0),
		m_height(0)
		{
		}

		void RenderTexture::SetDevice(_In_ ID3D11Device* device)
		{
		if (device == m_device.Get())
		return;

		if (m_device)
		{
		ReleaseDevice();
		}

		{
		UINT formatSupport = 0;
		if (FAILED(device->CheckFormatSupport(m_format, &formatSupport)))
		{
		throw std::exception("CheckFormatSupport");
		}

		UINT32 required = D3D11_FORMAT_SUPPORT_TEXTURE2D \| D3D11_FORMAT_SUPPORT_SHADER_SAMPLE \| D3D11_FORMAT_SUPPORT_RENDER_TARGET;
		if ((formatSupport & required) != required)
		{
		#ifdef _DEBUG
		char buff[128] = {};
		sprintf_s(buff, "RenderTexture: Device does not support the requested format (%u)!\n", m_format);
		OutputDebugStringA(buff);
		#endif
		throw std::exception("RenderTexture");
		}
		}

		m_device = device;

		#if defined(_XBOX_ONE) && defined(_TITLE)
		m_fastSemantics = (device->GetCreationFlags() & D3D11_CREATE_DEVICE_IMMEDIATE_CONTEXT_FAST_SEMANTICS) != 0;
		#endif
		}


		void RenderTexture::SizeResources(size_t width, size_t height)
		{
		if (width == m_width && height == m_height)
		return;

		if (m_width > UINT32_MAX \|\| m_height > UINT32_MAX)
		{
		throw std::out_of_range("Invalid width/height");
		}

		if (!m_device)
		return;

		m_width = m_height = 0;

		// Create a render target
		CD3D11_TEXTURE2D_DESC renderTargetDesc(
		m_format,
		static_cast<UINT>(width),
		static_cast<UINT>(height),
		1, // The render target view has only one texture.
		1, // Use a single mipmap level.
		D3D11_BIND_RENDER_TARGET \| D3D11_BIND_SHADER_RESOURCE,
		D3D11_USAGE_DEFAULT,
		0,
		1
		);

		ThrowIfFailed(m_device->CreateTexture2D(
		&renderTargetDesc,
		nullptr,
		m_renderTarget.ReleaseAndGetAddressOf()
		));

		SetDebugObjectName(m_renderTarget.Get(), "RenderTexture RT");

		// Create RTV.
		CD3D11_RENDER_TARGET_VIEW_DESC renderTargetViewDesc(D3D11_RTV_DIMENSION_TEXTURE2D, m_format);

		ThrowIfFailed(m_device->CreateRenderTargetView(
		m_renderTarget.Get(),
		&renderTargetViewDesc,
		m_renderTargetView.ReleaseAndGetAddressOf()
		));

		SetDebugObjectName(m_renderTargetView.Get(), "RenderTexture RTV");

		// Create SRV.
		CD3D11_SHADER_RESOURCE_VIEW_DESC shaderResourceViewDesc(D3D11_SRV_DIMENSION_TEXTURE2D, m_format);

		ThrowIfFailed(m_device->CreateShaderResourceView(
		m_renderTarget.Get(),
		&shaderResourceViewDesc,
		m_shaderResourceView.ReleaseAndGetAddressOf()
		));

		SetDebugObjectName(m_shaderResourceView.Get(), "RenderTexture SRV");

		m_width = width;
		m_height = height;
		}


		void RenderTexture::ReleaseDevice()
		{
		m_renderTargetView.Reset();
		m_shaderResourceView.Reset();
		m_renderTarget.Reset();

		m_device.Reset();

		m_width = m_height = 0;
		}

		#if defined(_XBOX_ONE) && defined(_TITLE)
		void RenderTexture::EndScene(_In_ ID3D11DeviceContextX* context)
		{
		if (m_fastSemantics)
		{
		context->FlushGpuCacheRange(
		D3D11_FLUSH_ENSURE_CB0_COHERENCY
		\| D3D11_FLUSH_COLOR_BLOCK_INVALIDATE
		\| D3D11_FLUSH_TEXTURE_L1_INVALIDATE
		\| D3D11_FLUSH_TEXTURE_L2_INVALIDATE,
		nullptr, D3D11_FLUSH_GPU_CACHE_RANGE_ALL);
		context->DecompressResource(m_renderTarget.Get(), 0, nullptr,
		m_renderTarget.Get(), 0, nullptr,
		m_format, D3D11X_DECOMPRESS_PROPAGATE_COLOR_CLEAR);
		}
		}
		#endif

		#endif

		void RenderTexture::SetWindow(const RECT& output)
		{
		// Determine the render target size in pixels.
		size_t width = std::max<size_t>(output.right - output.left, 1);
		size_t height = std::max<size_t>(output.bottom - output.top, 1);

		SizeResources(width, height);
		}

Kits/ATGTK/RenderTexture.h

0 → 100644

+102 −0

Original line number	Diff line number	Diff line
		//--------------------------------------------------------------------------------------
		// File: RenderTexture.h
		//
		// Helper for managing offscreen render targets
		//
		// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
		// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
		// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
		// PARTICULAR PURPOSE.
		//
		// Copyright (c) Microsoft Corporation. All rights reserved.
		//-------------------------------------------------------------------------------------

		#pragma once

		namespace DX
		{
		class RenderTexture
		{
		public:
		RenderTexture(DXGI_FORMAT format);

		RenderTexture(RenderTexture&&) = default;
		RenderTexture& operator= (RenderTexture&&) = default;

		RenderTexture(RenderTexture const&) = delete;
		RenderTexture& operator= (RenderTexture const&) = delete;

		#if defined(__d3d12_h__) \|\| defined(__d3d12_x_h__)

		void SetDevice(_In_ ID3D12Device* device, D3D12_CPU_DESCRIPTOR_HANDLE srvDescriptor, D3D12_CPU_DESCRIPTOR_HANDLE rtvDescriptor);

		void SizeResources(size_t width, size_t height);

		void ReleaseDevice();

		void TransitionTo(_In_ ID3D12GraphicsCommandList* commandList, D3D12_RESOURCE_STATES afterState);

		void BeginScene(_In_ ID3D12GraphicsCommandList* commandList)
		{
		TransitionTo(commandList, D3D12_RESOURCE_STATE_RENDER_TARGET);
		}

		void EndScene(_In_ ID3D12GraphicsCommandList* commandList)
		{
		TransitionTo(commandList, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE);
		}

		void SetClearColor(DirectX::FXMVECTOR color)
		{
		DirectX::XMStoreFloat4(reinterpret_cast<DirectX::XMFLOAT4*>(m_clearColor), color);
		}

		private:
		Microsoft::WRL::ComPtr<ID3D12Device> m_device;
		Microsoft::WRL::ComPtr<ID3D12Resource> m_resource;
		D3D12_RESOURCE_STATES m_state;
		D3D12_CPU_DESCRIPTOR_HANDLE m_srvDescriptor;
		D3D12_CPU_DESCRIPTOR_HANDLE m_rtvDescriptor;
		float m_clearColor[4];

		#elif defined(__d3d11_h__) \|\| defined(__d3d11_x_h__)

		void SetDevice(_In_ ID3D11Device* device);

		void SizeResources(size_t width, size_t height);

		void ReleaseDevice();

		#if defined(_XBOX_ONE) && defined(_TITLE)
		void EndScene(_In_ ID3D11DeviceContextX* context);
		#endif

		ID3D11Texture2D* GetRenderTarget() const { return m_renderTarget.Get(); }
		ID3D11RenderTargetView* GetRenderTargetView() const { return m_renderTargetView.Get(); }
		ID3D11ShaderResourceView* GetShaderResourceView() const { return m_shaderResourceView.Get(); }

		private:
		Microsoft::WRL::ComPtr<ID3D11Device> m_device;
		Microsoft::WRL::ComPtr<ID3D11Texture2D> m_renderTarget;
		Microsoft::WRL::ComPtr<ID3D11RenderTargetView> m_renderTargetView;
		Microsoft::WRL::ComPtr<ID3D11ShaderResourceView> m_shaderResourceView;
		#if defined(_XBOX_ONE) && defined(_TITLE)
		bool m_fastSemantics;
		#endif

		#else
		# error Please #include <d3d11.h> or <d3d12.h>
		#endif

		public:
		void SetWindow(const RECT& rect);

		DXGI_FORMAT GetFormat() const { return m_format; }

		private:
		DXGI_FORMAT m_format;

		size_t m_width;
		size_t m_height;
		};
		}
		No newline at end of file