void D2DComponent::BeginDraw(Windows::Foundation::Rect updateRect)
{
Microsoft::WRL::ComPtr<IDXGISurface> surface;
POINT offset;
RECT updateRectNative =
{
(LONG)updateRect.Left,
(LONG)updateRect.Top,
(LONG)updateRect.Right,
(LONG)updateRect.Bottom
};
HRESULT beginDrawHR = _sisNative->BeginDraw(updateRectNative, &surface, &offset);
if (beginDrawHR == DXGI_ERROR_DEVICE_REMOVED || beginDrawHR == DXGI_ERROR_DEVICE_RESET)
{
CreateDeviceResources();
BeginDraw(updateRect);
}
else
{
ThrowIfFailed(beginDrawHR);
}
Microsoft::WRL::ComPtr<ID2D1Bitmap1> bitmap;
ThrowIfFailed(_d2dDeviceContext->CreateBitmapFromDxgiSurface(surface.Get(), nullptr, &bitmap));
_d2dDeviceContext->BeginDraw();
_d2dDeviceContext->SetTarget(bitmap.Get());
}
IFACEMETHODIMP CTriColorControlProvider::GetSelection(_Outptr_result_maybenull_ SAFEARRAY * *retVal)
{
*retVal = nullptr;
HRESULT hr = CheckDisconnected();
if (SUCCEEDED(hr))
{
TriColorValue controlValue;
hr = m_control->get_ControlValue(&controlValue);
if (SUCCEEDED(hr))
{
ComPtr<IInspectable> spFragmentProvider;
hr = m_control->GetTriColorFragmentProvider(controlValue, &spFragmentProvider);
if (SUCCEEDED(hr))
{
*retVal = SafeArrayCreateVector(VT_UNKNOWN, 0, 1);
if (*retVal != nullptr)
{
long index = 0;
hr = SafeArrayPutElement(*retVal, &index, spFragmentProvider.Get());
if (FAILED(hr))
{
SafeArrayDestroy(*retVal);
*retVal = nullptr;
}
}
else
{
hr = E_OUTOFMEMORY;
}
}
}
}
return hr;
}
//-------------------------------------------------------------------
// GetFloatProperty
//
//-------------------------------------------------------------------
float CObjectFinderEffect::GetFloatProperty(
Microsoft::WRL::ComPtr<ABI::Windows::Foundation::Collections::IMap<HSTRING, IInspectable *>> &spSetting,
const HSTRING &key, boolean &found)
{
float value = 0.0f;
spSetting->HasKey(key, &found);
IInspectable* valueAsInsp = NULL;
if (found)
{
spSetting->Lookup(key, &valueAsInsp);
}
if (valueAsInsp)
{
Microsoft::WRL::ComPtr<ABI::Windows::Foundation::IPropertyValue> pPropertyValue;
HRESULT hr = valueAsInsp->QueryInterface(IID_PPV_ARGS(&pPropertyValue));
if (!FAILED(hr))
{
hr = pPropertyValue->GetSingle(&value);
}
}
return value;
}
IFACEMETHODIMP CTriColorControlProvider::Navigate(_In_ NavigateDirection direction, _Outptr_result_maybenull_ IRawElementProviderFragment ** retVal)
{
*retVal = nullptr;
ComPtr<IInspectable> spFragment;
HRESULT hr = CheckDisconnected();
if (SUCCEEDED(hr))
{
if (direction == NavigateDirection_Parent)
{
hr = m_control->GetAppWindowProvider(&spFragment);
}
else if (direction == NavigateDirection_FirstChild)
{
hr = m_control->GetTriColorFragmentProvider(TriColorValue::Red, &spFragment);
}
else if (direction == NavigateDirection_LastChild)
{
hr = m_control->GetTriColorFragmentProvider(TriColorValue::Green, &spFragment);
}
}
if (SUCCEEDED(hr) && spFragment != nullptr)
{
hr = spFragment.Get()->QueryInterface(IID_PPV_ARGS(retVal));
}
// For the other directions (next, previous) the default of nullptr is correct
return hr;
}
void BasicShapes::CreateVertexBuffer(
_In_ unsigned int numVertices,
_In_ BasicVertex *vertexData,
_Out_ ID3D11Buffer **vertexBuffer
)
{
*vertexBuffer = nullptr;
Microsoft::WRL::ComPtr<ID3D11Buffer> vertexBufferInternal;
D3D11_BUFFER_DESC VertexBufferDesc;
VertexBufferDesc.ByteWidth = sizeof(BasicVertex) * numVertices;
VertexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
VertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
VertexBufferDesc.CPUAccessFlags = 0;
VertexBufferDesc.MiscFlags = 0;
VertexBufferDesc.StructureByteStride = 0;
D3D11_SUBRESOURCE_DATA VertexBufferData;
VertexBufferData.pSysMem = vertexData;
VertexBufferData.SysMemPitch = 0;
VertexBufferData.SysMemSlicePitch = 0;
DX::ThrowIfFailed(
m_d3dDevice->CreateBuffer(
&VertexBufferDesc,
&VertexBufferData,
&vertexBufferInternal
)
);
*vertexBuffer = vertexBufferInternal.Detach();
}
void BasicShapes::CreateIndexBuffer(
_In_ unsigned int numIndices,
_In_ unsigned short *indexData,
_Out_ ID3D11Buffer **indexBuffer
)
{
*indexBuffer = nullptr;
Microsoft::WRL::ComPtr<ID3D11Buffer> indexBufferInternal;
D3D11_BUFFER_DESC IndexBufferDesc;
IndexBufferDesc.ByteWidth = sizeof(unsigned short) * numIndices;
IndexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
IndexBufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
IndexBufferDesc.CPUAccessFlags = 0;
IndexBufferDesc.MiscFlags = 0;
IndexBufferDesc.StructureByteStride = 0;
D3D11_SUBRESOURCE_DATA IndexBufferData;
IndexBufferData.pSysMem = indexData;
IndexBufferData.SysMemPitch = 0;
IndexBufferData.SysMemSlicePitch = 0;
DX::ThrowIfFailed(
m_d3dDevice->CreateBuffer(
&IndexBufferDesc,
&IndexBufferData,
&indexBufferInternal
)
);
*indexBuffer = indexBufferInternal.Detach();
}
plaintext_string winrt_encryption::decrypt() const
{
// To fully guarantee asynchrony would require significant impact on existing code. This code path
// is never run on a user's thread and is only done once when setting up a connection.
auto encrypted = m_buffer.get();
auto provider = ref new Windows::Security::Cryptography::DataProtection::DataProtectionProvider();
auto plaintext = pplx::create_task(provider->UnprotectAsync(encrypted)).get();
// Get access to raw bytes in plain text buffer.
Microsoft::WRL::ComPtr<IInspectable> bufferInspectable(reinterpret_cast<IInspectable *>(plaintext));
Microsoft::WRL::ComPtr<Windows::Storage::Streams::IBufferByteAccess> bufferByteAccess;
bufferInspectable.As(&bufferByteAccess);
byte * rawPlaintext;
const auto &result = bufferByteAccess->Buffer(&rawPlaintext);
if (result != S_OK)
{
throw ::utility::details::create_system_error(result);
}
// Construct string and zero out memory from plain text buffer.
auto data = plaintext_string(new std::wstring(
reinterpret_cast<const std::wstring::value_type *>(rawPlaintext),
plaintext->Length / 2));
SecureZeroMemory(rawPlaintext, plaintext->Length);
return std::move(data);
}
Handle Create(size_t hash, const void* data, size_t data_size, ID3D11Device* device) {
auto cached_handle = g_cache_.Get(hash);
if (cached_handle.IsValid()) {
return cached_handle;
}
D3D11_BUFFER_DESC bufferDesc;
ZeroMemory(&bufferDesc, sizeof(bufferDesc));
bufferDesc.Usage = D3D11_USAGE_DEFAULT;
bufferDesc.ByteWidth = data_size;
bufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
bufferDesc.CPUAccessFlags = 0;
bufferDesc.MiscFlags = 0;
D3D11_SUBRESOURCE_DATA bufferData;
ZeroMemory(&bufferData, sizeof(bufferData));
bufferData.pSysMem = data;
Microsoft::WRL::ComPtr<ID3D11Buffer> buffer;
HRESULT create_buffer_result = device->CreateBuffer(&bufferDesc, &bufferData, buffer.GetAddressOf());
if (FAILED(create_buffer_result)) {
DXFW_DIRECTX_TRACE(__FILE__, __LINE__, true, create_buffer_result);
return {};
}
auto new_handle = g_storage_.Add(buffer);
g_cache_.Set(hash, new_handle);
return new_handle;
}
void Model::Create()
{
CreateRootSignature();
CreatePipelineState();
Microsoft::WRL::ComPtr<ID3D12CommandAllocator> CommandAllocator;
Microsoft::WRL::ComPtr<ID3D12GraphicsCommandList> CommandList;
Microsoft::WRL::ComPtr<ID3D12Resource> VertexUploadResource;
Microsoft::WRL::ComPtr<ID3D12Resource> IndexUploadResource;
GPUFence Fence;
Fence.Initialize(DeviceContext.GetDevice());
Utility::ThrowOnFail(DeviceContext.GetDevice()->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&CommandAllocator)));
Utility::ThrowOnFail(DeviceContext.GetDevice()->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, CommandAllocator.Get(), nullptr, IID_PPV_ARGS(&CommandList)));
UploadVertices(CommandList, VertexUploadResource);
UploadIndices(CommandList, IndexUploadResource);
Utility::ThrowOnFail(CommandList->Close());
ID3D12CommandList * CommandListPointer = CommandList.Get();
DeviceContext.GetCommandQueue()->ExecuteCommandLists(1, &CommandListPointer);
Fence.SetAndWait(DeviceContext.GetCommandQueue());
}
HRESULT CompileShaderFromFile(const std::wstring &file
, const StageInfo &info, ID3D10Blob** ppBlobOut)
{
DWORD dwShaderFlags = D3DCOMPILE_ENABLE_STRICTNESS;
#if defined(DEBUG) || defined(_DEBUG)
dwShaderFlags |= D3DCOMPILE_DEBUG;
#endif//defiend(DEBUG) || defined(_DEBUG)
#if defined(NDEBUG) || defined(_NDEBUG)
dwShaderFlags |= D3DCOMPILE_OPTIMIZATION_LEVEL3;
#endif//defined(NDEBUG) || defined(_NDEBUG)
Microsoft::WRL::ComPtr<ID3DBlob> pErrorBlob;
auto hr = D3DCompileFromFile(
file.c_str()
, NULL
, D3D_COMPILE_STANDARD_FILE_INCLUDE
, info.entrypoint.c_str()
, info.model.c_str()
, dwShaderFlags
, 0
, ppBlobOut
, pErrorBlob.GetAddressOf()
);
if ( FAILED( hr ) ) {
if (pErrorBlob) {
// エラーメッセージを出力.
OutputDebugStringA( (char*)pErrorBlob->GetBufferPointer() );
}
}
return hr;
}
ID3D11DepthStencilView* CreateDepthStencilView(ID3D11Device* pDevice,DWORD dwWidth, DWORD dwHeight)
{
HRESULT hr;
ID3D11DepthStencilView* pDSV = nullptr;
Microsoft::WRL::ComPtr<ID3D11Texture2D> pDSTexture = nullptr;
D3D11_TEXTURE2D_DESC DescDepth;
DescDepth.Width = dwWidth;
DescDepth.Height = dwHeight;
DescDepth.MipLevels = 1;
DescDepth.ArraySize = 1;
DescDepth.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
DescDepth.SampleDesc.Count = 1;
DescDepth.SampleDesc.Quality = 0;
DescDepth.Usage = D3D11_USAGE_DEFAULT;
DescDepth.BindFlags = D3D11_BIND_DEPTH_STENCIL;
DescDepth.CPUAccessFlags = 0;
DescDepth.MiscFlags = 0;
if (FAILED(hr = pDevice->CreateTexture2D(&DescDepth, NULL, &pDSTexture)))
{
return nullptr;
}
D3D11_DEPTH_STENCIL_VIEW_DESC dsvd;
ZeroMemory(&dsvd, sizeof(dsvd));
dsvd.Format = DescDepth.Format;
dsvd.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
dsvd.Texture2D.MipSlice = 0;
if (FAILED(hr = pDevice->CreateDepthStencilView(
pDSTexture.Get(), &dsvd, &pDSV)))
{
return nullptr;
}
return pDSV;
}
void Model::CreatePipelineState()
{
Microsoft::WRL::ComPtr<ID3DBlob> VertexShader;
Microsoft::WRL::ComPtr<ID3DBlob> PixelShader;
LoadAndCompileShader(VertexShader, PixelShader);
std::array<D3D12_INPUT_ELEMENT_DESC, 2> InputElementDesc
{ {
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
{ "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 }
} };
D3D12_GRAPHICS_PIPELINE_STATE_DESC PipelineStateDesc = {};
PipelineStateDesc.InputLayout = { InputElementDesc.data(), static_cast<UINT>(InputElementDesc.size()) };
PipelineStateDesc.pRootSignature = RootSignature.Get();
PipelineStateDesc.VS = CD3DX12_SHADER_BYTECODE(VertexShader.Get());
PipelineStateDesc.PS = CD3DX12_SHADER_BYTECODE(PixelShader.Get());
PipelineStateDesc.RasterizerState = CD3DX12_RASTERIZER_DESC(D3D12_DEFAULT);
PipelineStateDesc.BlendState = CD3DX12_BLEND_DESC(D3D12_DEFAULT);
PipelineStateDesc.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC(D3D12_DEFAULT);
PipelineStateDesc.SampleMask = UINT_MAX;
PipelineStateDesc.SampleDesc.Count = 1;
PipelineStateDesc.NumRenderTargets = 1;
PipelineStateDesc.RTVFormats[0] = DXGI_FORMAT_R8G8B8A8_UNORM;
PipelineStateDesc.DSVFormat = DXGI_FORMAT_D32_FLOAT;
PipelineStateDesc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
Utility::ThrowOnFail(DeviceContext.GetDevice()->CreateGraphicsPipelineState(&PipelineStateDesc, IID_PPV_ARGS(&PipelineState)));
}
RoundedRectangle::RoundedRectangle(FLOAT x, FLOAT y, FLOAT width, FLOAT height,
FLOAT xRadius, FLOAT yRadius) : Shape(ShapeType::RoundedRectangle),
m_X(x),
m_Y(y),
m_Width(width + x),
m_Height(height + y),
m_XRadius(xRadius),
m_YRadius(yRadius)
{
HRESULT hr = E_FAIL;
const D2D1_ROUNDED_RECT rect = { m_X, m_Y, m_Width, m_Height, m_XRadius, m_YRadius };
Microsoft::WRL::ComPtr<ID2D1RoundedRectangleGeometry> rectangle;
hr = Canvas::c_D2DFactory->CreateRoundedRectangleGeometry(rect, rectangle.GetAddressOf());
if (FAILED(hr))
{
LogErrorF(
L"Could not create rounded rectangle object. X=%i, Y=%i, W=%i, H=%i, XRadius=%i, YRadius=%i",
(int)m_X, (int)m_Y, (int)m_Width, (int)m_Height, (int)m_XRadius, (int)m_YRadius);
return;
}
hr = rectangle.CopyTo(m_Shape.GetAddressOf());
if (FAILED(hr)) LogErrorF(
L"Could not copy rounded rectangle object to shape object. X=%i, Y=%i, W=%i, H=%i, XRadius=%i, YRadius=%i",
(int)m_X, (int)m_Y, (int)m_Width, (int)m_Height, (int)m_XRadius, (int)m_YRadius);
}
HRESULT sound_xaudio2::create_voices(const WAVEFORMATEX &format)
{
assert(m_xAudio2);
assert(!m_masterVoice);
HRESULT result;
IXAudio2MasteringVoice *temp_master_voice = nullptr;
HR_RETHR(
m_xAudio2->CreateMasteringVoice(
&temp_master_voice,
format.nChannels,
sample_rate()));
m_masterVoice = mastering_voice_ptr(temp_master_voice);
// create the source voice
IXAudio2SourceVoice *temp_source_voice = nullptr;
HR_RETHR(m_xAudio2->CreateSourceVoice(
&temp_source_voice,
&format,
XAUDIO2_VOICE_NOSRC | XAUDIO2_VOICE_NOPITCH,
1.0,
this));
m_sourceVoice = src_voice_ptr(temp_source_voice);
return S_OK;
}
Arc::Arc(FLOAT x1, FLOAT y1, FLOAT x2, FLOAT y2, FLOAT xRadius, FLOAT yRadius, FLOAT angle,
D2D1_SWEEP_DIRECTION sweep, D2D1_ARC_SIZE size, D2D1_FIGURE_END ending) : Shape(ShapeType::Arc),
m_StartPoint(D2D1::Point2F(x1, y1)),
m_ArcSegment(D2D1::ArcSegment(
D2D1::Point2F(x2, y2),
D2D1::SizeF(xRadius, yRadius),
angle,
sweep,
size)),
m_ShapeEnding(ending)
{
Microsoft::WRL::ComPtr<ID2D1GeometrySink> sink;
Microsoft::WRL::ComPtr<ID2D1PathGeometry> path;
HRESULT hr = Canvas::c_D2DFactory->CreatePathGeometry(path.GetAddressOf());
if (SUCCEEDED(hr))
{
hr = path->Open(sink.GetAddressOf());
if (SUCCEEDED(hr))
{
sink->BeginFigure(m_StartPoint, D2D1_FIGURE_BEGIN_FILLED);
sink->AddArc(m_ArcSegment);
sink->EndFigure(m_ShapeEnding);
sink->Close();
hr = path.CopyTo(m_Shape.GetAddressOf());
if (SUCCEEDED(hr)) return;
}
}
LogErrorF(L"Could not create arc object. X1=%i, Y1=%i, X2=%i, Y2=%i, XRadius=%i, YRadius=%i, Angle=%i",
(int)x1, (int)y1, (int)x2, (int)y2, (int)xRadius, (int)yRadius, (int)angle);
}
bool createIB(const Microsoft::WRL::ComPtr<ID3D11Device> &pDevice)
{
unsigned int pIndices[] =
{
0, 1, 2, 2, 3, 0,
4, 5, 6, 6, 7, 4,
8, 9, 10, 10, 11, 8,
12, 13, 14, 14, 15, 12,
16, 17, 18, 18, 19, 16,
20, 21, 22, 22, 23, 20,
};
unsigned int isize = sizeof(pIndices);
m_indices = isize / sizeof(pIndices[0]);
D3D11_BUFFER_DESC idesc;
ZeroMemory(&idesc, sizeof(idesc));
idesc.ByteWidth = isize;
idesc.Usage = D3D11_USAGE_DEFAULT;
idesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
idesc.CPUAccessFlags = 0;
D3D11_SUBRESOURCE_DATA indexData;
ZeroMemory(&indexData, sizeof(indexData));
indexData.pSysMem = pIndices;
HRESULT hr = pDevice->CreateBuffer(&idesc, &indexData, m_pIndexBuf.GetAddressOf());
if (FAILED(hr)){
return false;
}
return true;
}
void Shader::Draw(const Microsoft::WRL::ComPtr<ID3D11DeviceContext> &pDeviceContext)
{
// VS
pDeviceContext->VSSetShader(m_pVsh.Get(), NULL, 0);
// PS
pDeviceContext->PSSetShader(m_pPsh.Get(), NULL, 0);
// 定数バッファ
m_constant->UpdateCB(pDeviceContext);
m_constant->SetCB(pDeviceContext);
// Texture
{
auto v = m_constant->GetSRV("diffuseTexture");
m_constant->SetSRV(pDeviceContext, v, m_texture->GetSRV());
}
{
auto v = m_constant->GetSampler("diffuseTextureSampler");
m_constant->SetSampler(pDeviceContext, v, m_texture->GetSampler());
}
// IA InputLayout
pDeviceContext->IASetInputLayout(m_pInputLayout.Get());
m_IASource->Draw(pDeviceContext);
}
IDWriteFont* CreateDWriteFontFromGDIFamilyName(IDWriteFactory* factory, const WCHAR* gdiFamilyName)
{
Microsoft::WRL::ComPtr<IDWriteGdiInterop> dwGdiInterop;
HRESULT hr = factory->GetGdiInterop(dwGdiInterop.GetAddressOf());
if (SUCCEEDED(hr))
{
LOGFONT lf = {};
wcscpy_s(lf.lfFaceName, gdiFamilyName);
lf.lfHeight = -12;
lf.lfWeight = FW_DONTCARE;
lf.lfCharSet = DEFAULT_CHARSET;
lf.lfOutPrecision = OUT_DEFAULT_PRECIS;
lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
lf.lfQuality = ANTIALIASED_QUALITY;
lf.lfPitchAndFamily = VARIABLE_PITCH;
IDWriteFont* dwFont;
hr = dwGdiInterop->CreateFontFromLOGFONT(&lf, &dwFont);
if (SUCCEEDED(hr))
{
return dwFont;
}
}
return nullptr;
}
IFACEMETHODIMP CTriColorFragmentProvider::Navigate(_In_ NavigateDirection direction, _Outptr_result_maybenull_ IRawElementProviderFragment ** retVal)
{
*retVal = nullptr;
ComPtr<IInspectable> spFragment;
HRESULT hr = CheckDisconnected();
if (SUCCEEDED(hr))
{
if (direction == NavigateDirection_Parent)
{
hr = m_control->GetTriColorControlProvider(&spFragment);
}
else if (direction == NavigateDirection_NextSibling)
{
if (!TriColorValueHelper::IsLast(m_value))
{
hr = m_control->GetTriColorFragmentProvider(TriColorValueHelper::NextValue(m_value), &spFragment);
}
}
else if (direction == NavigateDirection_PreviousSibling)
{
if (!TriColorValueHelper::IsFirst(m_value))
{
hr = m_control->GetTriColorFragmentProvider(TriColorValueHelper::PreviousValue(m_value), &spFragment);
}
}
}
if (SUCCEEDED(hr) && spFragment != nullptr)
{
hr = spFragment.Get()->QueryInterface(IID_PPV_ARGS(retVal));
}
// For the other directions (first child, last child) the default of nullptr is correct
return hr;
}
ID3D12DescriptorHeap* DynamicDescriptorHeap::RequestDescriptorHeap(void)
{
std::lock_guard<std::mutex> LockGuard(sm_Mutex);
while (!sm_RetiredDescriptorHeaps.empty() && g_CommandManager.IsFenceComplete(sm_RetiredDescriptorHeaps.front().first))
{
sm_AvailableDescriptorHeaps.push(sm_RetiredDescriptorHeaps.front().second);
sm_RetiredDescriptorHeaps.pop();
}
if (!sm_AvailableDescriptorHeaps.empty())
{
ID3D12DescriptorHeap* HeapPtr = sm_AvailableDescriptorHeaps.front();
sm_AvailableDescriptorHeaps.pop();
return HeapPtr;
}
else
{
D3D12_DESCRIPTOR_HEAP_DESC HeapDesc = {};
HeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV;
HeapDesc.NumDescriptors = kNumDescriptorsPerHeap;
HeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
HeapDesc.NodeMask = 1;
Microsoft::WRL::ComPtr<ID3D12DescriptorHeap> HeapPtr;
ASSERT_SUCCEEDED(g_Device->CreateDescriptorHeap(&HeapDesc, MY_IID_PPV_ARGS(&HeapPtr)));
sm_DescriptorHeapPool.emplace_back(HeapPtr);
return HeapPtr.Get();
}
}
HRESULT Trace::GetMediaProperties(ComPtr<ILoggingFields> *pFields,IMFMediaType *pMediaType)
{
using namespace ABI::Windows::Media::MediaProperties;
HRESULT hr = CreateLoggingFields(pFields);
if (pMediaType != nullptr)
{
Microsoft::WRL::ComPtr<IMediaEncodingProperties> spMediaProps;
HRESULT hr = MFCreatePropertiesFromMediaType(pMediaType, IID_PPV_ARGS(&spMediaProps));
if (FAILED(hr))
return hr;
HSTRING hsMediaType = 0;
spMediaProps->get_Type(&hsMediaType);
HSTRING hsMediaSubType = 0;
spMediaProps->get_Subtype(&hsMediaSubType);
(*pFields)->AddString(HStringReference(L"Type").Get(), hsMediaType);
(*pFields)->AddString(HStringReference(L"SubType").Get(), hsMediaSubType);
UINT32 samplesPerSecond = 0;
hr = pMediaType->GetUINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, &samplesPerSecond);
if (SUCCEEDED(hr))
(*pFields)->AddUInt32(HStringReference(L"SampleRate").Get(), samplesPerSecond);
UINT32 numChannels;
hr = pMediaType->GetUINT32(MF_MT_AUDIO_NUM_CHANNELS, &numChannels);
if (SUCCEEDED(hr))
(*pFields)->AddUInt32(HStringReference(L"Channels").Get(), numChannels);
}
else
{
(*pFields)->AddEmpty(HStringReference(L"Type").Get());
}
return hr;
}
void Shape::CreateRadialGradient(ID2D1RenderTarget* target, ID2D1GradientStopCollection* collection,
Microsoft::WRL::ComPtr<ID2D1Brush>& brush, bool isStroke)
{
auto swapIfNotDefined = [](D2D1_POINT_2F& pt1, const D2D1_POINT_2F pt2) -> void
{
if (pt2.x != FLT_MAX) pt1.x = pt2.x;
if (pt2.y != FLT_MAX) pt1.y = pt2.y;
};
auto bounds = GetBounds(false);
D2D1_POINT_2F offset = D2D1::Point2F();
D2D1_POINT_2F center = D2D1::Point2F(((bounds.left + bounds.right) / 2.0f), ((bounds.top + bounds.bottom) / 2.0f));
D2D1_POINT_2F radius = D2D1::Point2F((bounds.right - bounds.left) / 2.0f, (bounds.bottom - bounds.top) / 2.0f);
// Offset from actual center of shape
center = Util::AddPoint2F(center, isStroke ? m_StrokeRadialGradientCenter : m_FillRadialGradientCenter);
// Check if offset and radii are defined
swapIfNotDefined(offset, isStroke ? m_StrokeRadialGradientOffset : m_FillRadialGradientOffset);
swapIfNotDefined(radius, isStroke ? m_StrokeRadialGradientRadius : m_FillRadialGradientRadius);
Microsoft::WRL::ComPtr<ID2D1RadialGradientBrush> radial;
HRESULT hr = target->CreateRadialGradientBrush(
D2D1::RadialGradientBrushProperties(
center,
offset,
radius.x,
radius.y),
collection,
radial.GetAddressOf());
if (SUCCEEDED(hr)) radial.CopyTo(brush.ReleaseAndGetAddressOf());
}
void Shape::CreateSolidBrush(ID2D1RenderTarget* target, Microsoft::WRL::ComPtr<ID2D1Brush>& brush,
const D2D1_COLOR_F& color)
{
Microsoft::WRL::ComPtr<ID2D1SolidColorBrush> solid;
HRESULT hr = target->CreateSolidColorBrush(color, solid.GetAddressOf());
if (SUCCEEDED(hr)) solid.CopyTo(brush.ReleaseAndGetAddressOf());
}
void glClear(GLbitfield mask)
{
if( g_pD3DContext )
{
g_pD3DContext->ClearRenderTargetView( g_pD3DRenderTargetView.Get(), g_ClearColor );
g_pD3DContext->ClearDepthStencilView( g_pD3DDepthStencilView.Get(), D3D11_CLEAR_DEPTH, 1.0f, 0 );
}
}
void D3DCreateDepthStencilStates()
{
HRESULT result;
D3D11_DEPTH_STENCIL_DESC depthDisabledStencilDesc;
ZeroMemory(&depthDisabledStencilDesc, sizeof(depthDisabledStencilDesc));
depthDisabledStencilDesc.DepthEnable = true;
depthDisabledStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthDisabledStencilDesc.DepthFunc = D3D11_COMPARISON_LESS_EQUAL;
depthDisabledStencilDesc.StencilEnable = true;
depthDisabledStencilDesc.StencilReadMask = 0xFF;
depthDisabledStencilDesc.StencilWriteMask = 0xFF;
depthDisabledStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthDisabledStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR;
depthDisabledStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthDisabledStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
depthDisabledStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthDisabledStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
depthDisabledStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthDisabledStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
// Test: Enabled Write: Enabled
depthDisabledStencilDesc.DepthEnable = true;
depthDisabledStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
result = g_pD3DDevice->CreateDepthStencilState( &depthDisabledStencilDesc, &g_pD3DDepthStencilState_DepthTestEnabled_DepthWriteEnabled );
if( FAILED( result ) )
{
LOGInfo( LOGTag, "Failed to create DepthStencilState\n" );
}
// Test: Disabled Write: Enabled
depthDisabledStencilDesc.DepthEnable = false;
depthDisabledStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
result = g_pD3DDevice->CreateDepthStencilState( &depthDisabledStencilDesc, &g_pD3DDepthStencilState_DepthTestDisabled_DepthWriteEnabled );
if( FAILED( result ) )
{
LOGInfo( LOGTag, "Failed to create DepthStencilState\n" );
}
// Test: Enabled Write: Disabled
depthDisabledStencilDesc.DepthEnable = true;
depthDisabledStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ZERO;
result = g_pD3DDevice->CreateDepthStencilState( &depthDisabledStencilDesc, &g_pD3DDepthStencilState_DepthTestEnabled_DepthWriteDisabled );
if( FAILED( result ) )
{
LOGInfo( LOGTag, "Failed to create DepthStencilState\n" );
}
// Test: Disabled Write: Disabled
depthDisabledStencilDesc.DepthEnable = false;
depthDisabledStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ZERO;
result = g_pD3DDevice->CreateDepthStencilState( &depthDisabledStencilDesc, &g_pD3DDepthStencilState_DepthTestDisabled_DepthWriteDisabled );
if( FAILED( result ) )
{
LOGInfo( LOGTag, "Failed to create DepthStencilState\n" );
}
}
// Initializes D2D resources used for text rendering.
SampleDebugTextRenderer::SampleDebugTextRenderer(const std::shared_ptr<DX::DeviceResources>& deviceResources) :
Overlay(deviceResources)
{
ZeroMemory(&m_textMetrics, sizeof(DWRITE_TEXT_METRICS) * XINPUT_MAX_CONTROLLERS);
ZeroMemory(&m_textMetricsFPS, sizeof(DWRITE_TEXT_METRICS));
for (unsigned int i = 0; i < 4; i++)
{
m_text[i] = L"";
}
// Create device-independent resources.
DX::ThrowIfFailed(
m_deviceResources->GetDWriteFactory()->CreateTextFormat(
L"Segoe UI",
nullptr,
DWRITE_FONT_WEIGHT_LIGHT,
DWRITE_FONT_STYLE_NORMAL,
DWRITE_FONT_STRETCH_NORMAL,
32.0f,
L"en-US",
&m_textFormat
)
);
DX::ThrowIfFailed(
m_textFormat->SetParagraphAlignment(DWRITE_PARAGRAPH_ALIGNMENT_NEAR)
);
DX::ThrowIfFailed(
m_deviceResources->GetD2DFactory()->CreateDrawingStateBlock(&m_stateBlock)
);
// Generate static input text height.
unsigned int lines = 6; // Increase this if you need to display more than 5 separate action types
std::wstring inputText = L"";
for (unsigned int i = 0; i < lines; i++) inputText += L"\n";
Microsoft::WRL::ComPtr<IDWriteTextLayout> layout;
DX::ThrowIfFailed(
m_deviceResources->GetDWriteFactory()->CreateTextLayout(
inputText.c_str(),
(uint32) inputText.length(),
m_textFormat.Get(),
DEBUG_INPUT_TEXT_MAX_WIDTH,
DEBUG_INPUT_TEXT_MAX_HEIGHT,
&layout
)
);
DWRITE_TEXT_METRICS metrics;
DX::ThrowIfFailed(
layout->GetMetrics(&metrics)
);
m_inputTextHeight = metrics.height;
CreateDeviceDependentResources();
}
HRESULT CallPlmToEnableDebugging()
{
// Calling public API.
// EnableDebugging() implementation lives in COMBASE.DLL loaded into Explorer.exe's address space.
// Explorer's security token is used on invocation. Since Explorer and this code might run under
// different users, the following call might fail.
HRESULT hr = m_packageDebugSettings->EnableDebugging(m_packageName, m_debuggerString, m_environmentVars);
// Calling internal API on failure.
// It's almost identical code like in EnableDebugging() but it uses a security token of the curent process.
if (FAILED(hr) && hr == HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED))
{
if (m_debuggerString != nullptr ||
m_environmentVars != nullptr)
{
// Enable debug on activation
hr = ::RoEnableDebuggingForPackage(m_packageName, m_debuggerString, m_environmentVars);
if (FAILED(hr))
{
return hr;
}
}
// Disable activation timeouts
Microsoft::WRL::ComPtr<IApplicationActivationManagerPriv> spActivationManager;
hr = CoCreateInstance(CLSID_ApplicationActivationManager, nullptr, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&spActivationManager));
if (FAILED(hr))
{
return hr;
}
if (SUCCEEDED(hr))
{
hr = spActivationManager->PutPackageActivationSettings(Windows::Internal::StringReference(m_packageName).Get(), PAS_NORPCTIMEOUTS, PAS_NORPCTIMEOUTS);
// CImmersiveApplicationDebugControlInternal, which implements IPackageDebugSettings,
// does the following. We don't have an ISuspendResumeController, so we don't do it.
// This must be what disables suspend/resume on the app (to aid debugging).
// We probably don't need it for iDNA.
//if (SUCCEEDED(hr))
//{
// hr = _spSuspendResumeController->OnDebugModeEnabled(m_packageName);
//}
}
// Roll back on failure.
if (FAILED(hr))
{
HRESULT const disableHr = CallPlmToDisableDebugging();
if (FAILED(disableHr))
{
LogError(disableHr, L"CallPlmToDisableDebugging() reported an error while aborting in CallPlmToEnableDebugging() .\n");
}
}
}
return hr;
}
void MazeWallObstacle::Render( Microsoft::WRL::ComPtr<ID2D1DeviceContext> & d2dContext ) const
{
Microsoft::WRL::ComPtr<ID2D1SolidColorBrush> brush;
DX::ThrowIfFailed(d2dContext->CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF::Black), &brush));
D2D1_POINT_2F const pt1 = {(float)m_pt1.m_x, (float)m_pt1.m_y};
D2D1_POINT_2F const pt2 = {(float)m_pt2.m_x, (float)m_pt2.m_y};
d2dContext->DrawLine(pt1, pt2, brush.Get());
}
void PrimitveDrawer::End()
{
Microsoft::WRL::ComPtr<ID3D11RasterizerState> pRSState;
m_pContext->RSGetState(&pRSState);
m_pContext->RSSetState(m_pStates->CullClockwise());
m_pDirectXBatch->End();
m_pContext->RSSetState(pRSState.Get());
}
bool createVB(const Microsoft::WRL::ComPtr<ID3D11Device> &pDevice)
{
// Create VB
auto size = 0.5f;
Vertex pVertices[] =
{
// x
{ DirectX::XMFLOAT4(-size, -size, -size, 1.0f), DirectX::XMFLOAT4(0.5f, 0.0f, 0.0f, 1.0f), DirectX::XMFLOAT2(0, 1) },
{ DirectX::XMFLOAT4(-size, -size, size, 1.0f), DirectX::XMFLOAT4(0.5f, 0.0f, 0.0f, 1.0f), DirectX::XMFLOAT2(0, 0) },
{ DirectX::XMFLOAT4(-size, size, size, 1.0f), DirectX::XMFLOAT4(0.5f, 0.0f, 0.0f, 1.0f), DirectX::XMFLOAT2(1, 0) },
{ DirectX::XMFLOAT4(-size, size, -size, 1.0f), DirectX::XMFLOAT4(0.5f, 0.0f, 0.0f, 1.0f), DirectX::XMFLOAT2(1, 1) },
{ DirectX::XMFLOAT4(size, -size, -size, 1.0f), DirectX::XMFLOAT4(1.0f, 0.0f, 0.0f, 1.0f), DirectX::XMFLOAT2(0, 1) },
{ DirectX::XMFLOAT4(size, size, -size, 1.0f), DirectX::XMFLOAT4(1.0f, 0.0f, 0.0f, 1.0f), DirectX::XMFLOAT2(1, 1) },
{ DirectX::XMFLOAT4(size, size, size, 1.0f), DirectX::XMFLOAT4(1.0f, 0.0f, 0.0f, 1.0f), DirectX::XMFLOAT2(1, 0) },
{ DirectX::XMFLOAT4(size, -size, size, 1.0f), DirectX::XMFLOAT4(1.0f, 0.0f, 0.0f, 1.0f), DirectX::XMFLOAT2(0, 0) },
// y
{ DirectX::XMFLOAT4(-size, size, -size, 1.0f), DirectX::XMFLOAT4(0.0f, 1.0f, 0.0f, 1.0f), DirectX::XMFLOAT2(0, 1) },
{ DirectX::XMFLOAT4(-size, size, size, 1.0f), DirectX::XMFLOAT4(0.0f, 1.0f, 0.0f, 1.0f), DirectX::XMFLOAT2(0, 0) },
{ DirectX::XMFLOAT4(size, size, size, 1.0f), DirectX::XMFLOAT4(0.0f, 1.0f, 0.0f, 1.0f), DirectX::XMFLOAT2(1, 0) },
{ DirectX::XMFLOAT4(size, size, -size, 1.0f), DirectX::XMFLOAT4(0.0f, 1.0f, 0.0f, 1.0f), DirectX::XMFLOAT2(1, 1) },
{ DirectX::XMFLOAT4(-size, -size, -size, 1.0f), DirectX::XMFLOAT4(0.0f, 0.5f, 0.0f, 1.0f), DirectX::XMFLOAT2(0, 1) },
{ DirectX::XMFLOAT4(size, -size, -size, 1.0f), DirectX::XMFLOAT4(0.0f, 0.5f, 0.0f, 1.0f), DirectX::XMFLOAT2(1, 1) },
{ DirectX::XMFLOAT4(size, -size, size, 1.0f), DirectX::XMFLOAT4(0.0f, 0.5f, 0.0f, 1.0f), DirectX::XMFLOAT2(1, 0) },
{ DirectX::XMFLOAT4(-size, -size, size, 1.0f), DirectX::XMFLOAT4(0.0f, 0.5f, 0.0f, 1.0f), DirectX::XMFLOAT2(0, 0) },
// z
{ DirectX::XMFLOAT4(-size, -size, -size, 1.0f), DirectX::XMFLOAT4(0.0f, 0.0f, 0.5f, 1.0f), DirectX::XMFLOAT2(0, 1) },
{ DirectX::XMFLOAT4(-size, size, -size, 1.0f), DirectX::XMFLOAT4(0.0f, 0.0f, 0.5f, 1.0f), DirectX::XMFLOAT2(0, 0) },
{ DirectX::XMFLOAT4(size, size, -size, 1.0f), DirectX::XMFLOAT4(0.0f, 0.0f, 0.5f, 1.0f), DirectX::XMFLOAT2(1, 0) },
{ DirectX::XMFLOAT4(size, -size, -size, 1.0f), DirectX::XMFLOAT4(0.0f, 0.0f, 0.5f, 1.0f), DirectX::XMFLOAT2(1, 1) },
{ DirectX::XMFLOAT4(-size, -size, size, 1.0f), DirectX::XMFLOAT4(0.0f, 0.0f, 1.0f, 1.0f), DirectX::XMFLOAT2(0, 1) },
{ DirectX::XMFLOAT4(size, -size, size, 1.0f), DirectX::XMFLOAT4(0.0f, 0.0f, 1.0f, 1.0f), DirectX::XMFLOAT2(1, 1) },
{ DirectX::XMFLOAT4(size, size, size, 1.0f), DirectX::XMFLOAT4(0.0f, 0.0f, 1.0f, 1.0f), DirectX::XMFLOAT2(1, 0) },
{ DirectX::XMFLOAT4(-size, size, size, 1.0f), DirectX::XMFLOAT4(0.0f, 0.0f, 1.0f, 1.0f), DirectX::XMFLOAT2(0, 0) },
};
unsigned int vsize = sizeof(pVertices);
D3D11_BUFFER_DESC vdesc;
ZeroMemory(&vdesc, sizeof(vdesc));
vdesc.ByteWidth = vsize;
vdesc.Usage = D3D11_USAGE_DEFAULT;
vdesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
vdesc.CPUAccessFlags = 0;
D3D11_SUBRESOURCE_DATA vertexData;
ZeroMemory(&vertexData, sizeof(vertexData));
vertexData.pSysMem = pVertices;
HRESULT hr = pDevice->CreateBuffer(&vdesc, &vertexData, m_pVertexBuf.GetAddressOf());
if (FAILED(hr)){
return false;
}
return true;
}