bcarrella
/
cef
mirror of https://bitbucket.org/chromiumembedded/cef
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
cef/tests/cefclient/browser/osr_d3d11_win.cc

935 lines
26 KiB
C++
Raw Blame History

// Copyright 2018 The Chromium Embedded Framework Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be found
// in the LICENSE file.
//
// Portions Copyright (c) 2018 Daktronics with the following MIT License:
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
#include "tests/cefclient/browser/osr_d3d11_win.h"
#include <iomanip> // For std::setw.
#if OS_WIN && ARCH_CPU_ARM_FAMILY
#define __prefetch(x) x
#endif
#include <d3dcompiler.h>
#include <directxmath.h>
#include "include/base/cef_logging.h"
#include "include/internal/cef_string.h"
#include "tests/shared/browser/util_win.h"
namespace client {
namespace d3d11 {
namespace {
// Wrap a raw COM pointer in a shared_ptr for auto Release().
template <class T>
std::shared_ptr<T> to_com_ptr(T* obj) {
return std::shared_ptr<T>(obj, [](T* p) {
if (p)
p->Release();
});
}
} // namespace
struct SimpleVertex {
DirectX::XMFLOAT3 pos;
DirectX::XMFLOAT2 tex;
};
Context::Context(ID3D11DeviceContext* ctx) : ctx_(to_com_ptr(ctx)) {}
void Context::flush() {
ctx_->Flush();
}
SwapChain::SwapChain(IDXGISwapChain* swapchain,
ID3D11RenderTargetView* rtv,
ID3D11SamplerState* sampler,
ID3D11BlendState* blender)
: sampler_(to_com_ptr(sampler)),
blender_(to_com_ptr(blender)),
swapchain_(to_com_ptr(swapchain)),
rtv_(to_com_ptr(rtv)),
width_(0),
height_(0) {}
void SwapChain::bind(const std::shared_ptr<Context>& ctx) {
ctx_ = ctx;
ID3D11DeviceContext* d3d11_ctx = (ID3D11DeviceContext*)(*ctx_);
ID3D11RenderTargetView* rtv[1] = {rtv_.get()};
d3d11_ctx->OMSetRenderTargets(1, rtv, nullptr);
// Set default blending state.
if (blender_) {
float factor[4] = {0.0f, 0.0f, 0.0f, 0.0f};
d3d11_ctx->OMSetBlendState(blender_.get(), factor, 0xffffffff);
}
// Set default sampler state.
if (sampler_) {
ID3D11SamplerState* samplers[1] = {sampler_.get()};
d3d11_ctx->PSSetSamplers(0, 1, samplers);
}
}
void SwapChain::unbind() {
ctx_.reset();
}
void SwapChain::clear(float red, float green, float blue, float alpha) {
ID3D11DeviceContext* d3d11_ctx = (ID3D11DeviceContext*)(*ctx_);
CHECK(d3d11_ctx);
FLOAT color[4] = {red, green, blue, alpha};
d3d11_ctx->ClearRenderTargetView(rtv_.get(), color);
}
void SwapChain::present(int sync_interval) {
swapchain_->Present(sync_interval, 0);
}
void SwapChain::resize(int width, int height) {
if (width <= 0 || height <= 0 || width == width_ || height == height_) {
return;
}
width_ = width;
height_ = height;
ID3D11DeviceContext* d3d11_ctx = (ID3D11DeviceContext*)(*ctx_);
CHECK(d3d11_ctx);
d3d11_ctx->OMSetRenderTargets(0, 0, 0);
rtv_.reset();
DXGI_SWAP_CHAIN_DESC desc;
swapchain_->GetDesc(&desc);
auto hr = swapchain_->ResizeBuffers(0, width, height, desc.BufferDesc.Format,
desc.Flags);
if (FAILED(hr)) {
LOG(ERROR) << "d3d11: Failed to resize swapchain (" << width << "x"
<< height << ")";
return;
}
ID3D11Texture2D* buffer = nullptr;
hr = swapchain_->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**)&buffer);
if (FAILED(hr)) {
LOG(ERROR) << "d3d11: Failed to resize swapchain (" << width << "x"
<< height << ")";
return;
}
ID3D11Device* dev = nullptr;
d3d11_ctx->GetDevice(&dev);
if (dev) {
D3D11_RENDER_TARGET_VIEW_DESC vdesc = {};
vdesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
vdesc.Texture2D.MipSlice = 0;
vdesc.Format = desc.BufferDesc.Format;
ID3D11RenderTargetView* view = nullptr;
hr = dev->CreateRenderTargetView(buffer, &vdesc, &view);
if (SUCCEEDED(hr)) {
rtv_ = to_com_ptr(view);
d3d11_ctx->OMSetRenderTargets(1, &view, nullptr);
}
dev->Release();
}
buffer->Release();
D3D11_VIEWPORT vp;
vp.Width = static_cast<float>(width);
vp.Height = static_cast<float>(height);
vp.MinDepth = D3D11_MIN_DEPTH;
vp.MaxDepth = D3D11_MAX_DEPTH;
vp.TopLeftX = 0;
vp.TopLeftY = 0;
d3d11_ctx->RSSetViewports(1, &vp);
}
Effect::Effect(ID3D11VertexShader* vsh,
ID3D11PixelShader* psh,
ID3D11InputLayout* layout)
: vsh_(to_com_ptr(vsh)),
psh_(to_com_ptr(psh)),
layout_(to_com_ptr(layout)) {}
void Effect::bind(const std::shared_ptr<Context>& ctx) {
ctx_ = ctx;
ID3D11DeviceContext* d3d11_ctx = (ID3D11DeviceContext*)(*ctx_);
d3d11_ctx->IASetInputLayout(layout_.get());
d3d11_ctx->VSSetShader(vsh_.get(), nullptr, 0);
d3d11_ctx->PSSetShader(psh_.get(), nullptr, 0);
}
void Effect::unbind() {}
Geometry::Geometry(D3D_PRIMITIVE_TOPOLOGY primitive,
uint32_t vertices,
uint32_t stride,
ID3D11Buffer* buffer)
: primitive_(primitive),
vertices_(vertices),
stride_(stride),
buffer_(to_com_ptr(buffer)) {}
void Geometry::bind(const std::shared_ptr<Context>& ctx) {
ctx_ = ctx;
ID3D11DeviceContext* d3d11_ctx = (ID3D11DeviceContext*)(*ctx_);
// TODO: Handle offset.
uint32_t offset = 0;
ID3D11Buffer* buffers[1] = {buffer_.get()};
d3d11_ctx->IASetVertexBuffers(0, 1, buffers, &stride_, &offset);
d3d11_ctx->IASetPrimitiveTopology(primitive_);
}
void Geometry::unbind() {}
void Geometry::draw() {
ID3D11DeviceContext* d3d11_ctx = (ID3D11DeviceContext*)(*ctx_);
CHECK(d3d11_ctx);
// TODO: Handle offset.
d3d11_ctx->Draw(vertices_, 0);
}
Texture2D::Texture2D(ID3D11Texture2D* tex, ID3D11ShaderResourceView* srv)
: texture_(to_com_ptr(tex)), srv_(to_com_ptr(srv)) {
share_handle_ = nullptr;
IDXGIResource* res = nullptr;
if (SUCCEEDED(texture_->QueryInterface(__uuidof(IDXGIResource),
reinterpret_cast<void**>(&res)))) {
res->GetSharedHandle(&share_handle_);
res->Release();
}
// Are we using a keyed mutex?
IDXGIKeyedMutex* mutex = nullptr;
if (SUCCEEDED(texture_->QueryInterface(__uuidof(IDXGIKeyedMutex),
(void**)&mutex))) {
keyed_mutex_ = to_com_ptr(mutex);
}
}
uint32_t Texture2D::width() const {
D3D11_TEXTURE2D_DESC desc;
texture_->GetDesc(&desc);
return desc.Width;
}
uint32_t Texture2D::height() const {
D3D11_TEXTURE2D_DESC desc;
texture_->GetDesc(&desc);
return desc.Height;
}
DXGI_FORMAT Texture2D::format() const {
D3D11_TEXTURE2D_DESC desc;
texture_->GetDesc(&desc);
return desc.Format;
}
bool Texture2D::has_mutex() const {
return (keyed_mutex_.get() != nullptr);
}
bool Texture2D::lock_key(uint64_t key, uint32_t timeout_ms) {
if (keyed_mutex_) {
const auto hr = keyed_mutex_->AcquireSync(key, timeout_ms);
return SUCCEEDED(hr);
}
return true;
}
void Texture2D::unlock_key(uint64_t key) {
if (keyed_mutex_) {
keyed_mutex_->ReleaseSync(key);
}
}
void Texture2D::bind(const std::shared_ptr<Context>& ctx) {
ctx_ = ctx;
ID3D11DeviceContext* d3d11_ctx = (ID3D11DeviceContext*)(*ctx_);
if (srv_) {
ID3D11ShaderResourceView* views[1] = {srv_.get()};
d3d11_ctx->PSSetShaderResources(0, 1, views);
}
}
void Texture2D::unbind() {}
void* Texture2D::share_handle() const {
return share_handle_;
}
void Texture2D::copy_from(const std::shared_ptr<Texture2D>& other) {
ID3D11DeviceContext* d3d11_ctx = (ID3D11DeviceContext*)(*ctx_);
CHECK(d3d11_ctx);
if (other) {
d3d11_ctx->CopyResource(texture_.get(), other->texture_.get());
}
}
Device::Device(ID3D11Device* pdev, ID3D11DeviceContext* pctx)
: device_(to_com_ptr(pdev)), ctx_(std::make_shared<Context>(pctx)) {
lib_compiler_ = LoadLibrary(L"d3dcompiler_47.dll");
}
// static
std::shared_ptr<Device> Device::create() {
UINT flags = 0;
#ifdef _DEBUG
flags |= D3D11_CREATE_DEVICE_DEBUG;
#endif
D3D_FEATURE_LEVEL feature_levels[] = {
D3D_FEATURE_LEVEL_11_1, D3D_FEATURE_LEVEL_11_0, D3D_FEATURE_LEVEL_10_1,
D3D_FEATURE_LEVEL_10_0,
// D3D_FEATURE_LEVEL_9_3,
};
UINT num_feature_levels = sizeof(feature_levels) / sizeof(feature_levels[0]);
ID3D11Device* pdev = nullptr;
ID3D11DeviceContext* pctx = nullptr;
D3D_FEATURE_LEVEL selected_level;
HRESULT hr = D3D11CreateDevice(
nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, flags, feature_levels,
num_feature_levels, D3D11_SDK_VERSION, &pdev, &selected_level, &pctx);
if (hr == E_INVALIDARG) {
// DirectX 11.0 platforms will not recognize D3D_FEATURE_LEVEL_11_1
// so we need to retry without it.
hr = D3D11CreateDevice(nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, flags,
&feature_levels[1], num_feature_levels - 1,
D3D11_SDK_VERSION, &pdev, &selected_level, &pctx);
}
if (SUCCEEDED(hr)) {
const auto dev = std::make_shared<Device>(pdev, pctx);
LOG(INFO) << "d3d11: Selected adapter " << dev->adapter_name()
<< " and feature level 0x" << std::setw(4) << std::hex
<< selected_level;
return dev;
}
return nullptr;
}
std::string Device::adapter_name() const {
IDXGIDevice* dxgi_dev = nullptr;
auto hr = device_->QueryInterface(__uuidof(dxgi_dev), (void**)&dxgi_dev);
if (SUCCEEDED(hr)) {
IDXGIAdapter* dxgi_adapt = nullptr;
hr = dxgi_dev->GetAdapter(&dxgi_adapt);
dxgi_dev->Release();
if (SUCCEEDED(hr)) {
DXGI_ADAPTER_DESC desc;
hr = dxgi_adapt->GetDesc(&desc);
dxgi_adapt->Release();
if (SUCCEEDED(hr)) {
return CefString(desc.Description);
}
}
}
return "n/a";
}
std::shared_ptr<Context> Device::immedidate_context() {
return ctx_;
}
std::shared_ptr<SwapChain> Device::create_swapchain(HWND window,
int width,
int height) {
HRESULT hr;
IDXGIFactory1* dxgi_factory = nullptr;
// Default size to the window size unless specified.
RECT rc_bounds;
GetClientRect(window, &rc_bounds);
if (width <= 0) {
width = rc_bounds.right - rc_bounds.left;
}
if (height <= 0) {
height = rc_bounds.bottom - rc_bounds.top;
}
{
IDXGIDevice* dxgi_dev = nullptr;
hr = device_->QueryInterface(__uuidof(IDXGIDevice),
reinterpret_cast<void**>(&dxgi_dev));
if (FAILED(hr)) {
return nullptr;
}
IDXGIAdapter* adapter = nullptr;
hr = dxgi_dev->GetAdapter(&adapter);
dxgi_dev->Release();
if (FAILED(hr)) {
return nullptr;
}
hr = adapter->GetParent(__uuidof(IDXGIFactory1),
reinterpret_cast<void**>(&dxgi_factory));
adapter->Release();
}
if (!dxgi_factory) {
return nullptr;
}
IDXGISwapChain* swapchain = nullptr;
// Create swap chain.
IDXGIFactory2* dxgi_factory2 = nullptr;
hr = dxgi_factory->QueryInterface(__uuidof(IDXGIFactory2),
reinterpret_cast<void**>(&dxgi_factory2));
if (dxgi_factory2) {
DXGI_SWAP_CHAIN_DESC1 sd;
ZeroMemory(&sd, sizeof(sd));
sd.Width = width;
sd.Height = height;
sd.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
sd.SampleDesc.Count = 1;
sd.SampleDesc.Quality = 0;
sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
sd.BufferCount = 1;
IDXGISwapChain1* swapchain1 = nullptr;
hr = dxgi_factory2->CreateSwapChainForHwnd(device_.get(), window, &sd,
nullptr, nullptr, &swapchain1);
if (SUCCEEDED(hr)) {
hr = swapchain1->QueryInterface(__uuidof(IDXGISwapChain),
reinterpret_cast<void**>(&swapchain));
swapchain1->Release();
}
dxgi_factory2->Release();
} else {
// DirectX 11.0 systems.
DXGI_SWAP_CHAIN_DESC sd;
ZeroMemory(&sd, sizeof(sd));
sd.BufferCount = 1;
sd.BufferDesc.Width = width;
sd.BufferDesc.Height = height;
sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
sd.BufferDesc.RefreshRate.Numerator = 60;
sd.BufferDesc.RefreshRate.Denominator = 1;
sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
sd.OutputWindow = window;
sd.SampleDesc.Count = 1;
sd.SampleDesc.Quality = 0;
sd.Windowed = TRUE;
hr = dxgi_factory->CreateSwapChain(device_.get(), &sd, &swapchain);
}
// We don't handle full-screen swapchains so we block the ALT+ENTER shortcut.
dxgi_factory->MakeWindowAssociation(window, DXGI_MWA_NO_ALT_ENTER);
dxgi_factory->Release();
if (!swapchain) {
return nullptr;
}
ID3D11Texture2D* back_buffer = nullptr;
hr = swapchain->GetBuffer(0, __uuidof(ID3D11Texture2D),
reinterpret_cast<void**>(&back_buffer));
if (FAILED(hr)) {
swapchain->Release();
return nullptr;
}
ID3D11RenderTargetView* rtv = nullptr;
hr = device_->CreateRenderTargetView(back_buffer, nullptr, &rtv);
back_buffer->Release();
if (FAILED(hr)) {
swapchain->Release();
return nullptr;
}
const auto ctx = (ID3D11DeviceContext*)(*ctx_);
ctx->OMSetRenderTargets(1, &rtv, nullptr);
// Setup the viewport.
D3D11_VIEWPORT vp;
vp.Width = (FLOAT)width;
vp.Height = (FLOAT)height;
vp.MinDepth = 0.0f;
vp.MaxDepth = 1.0f;
vp.TopLeftX = 0;
vp.TopLeftY = 0;
ctx->RSSetViewports(1, &vp);
// Create a default sampler to use.
ID3D11SamplerState* sampler = nullptr;
{
D3D11_SAMPLER_DESC desc = {};
desc.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP;
desc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP;
desc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
desc.ComparisonFunc = D3D11_COMPARISON_NEVER;
desc.MinLOD = 0.0f;
desc.MaxLOD = D3D11_FLOAT32_MAX;
desc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
device_->CreateSamplerState(&desc, &sampler);
}
// Create a default blend state to use (pre-multiplied alpha).
ID3D11BlendState* blender = nullptr;
{
D3D11_BLEND_DESC desc;
desc.AlphaToCoverageEnable = FALSE;
desc.IndependentBlendEnable = FALSE;
const auto count = sizeof(desc.RenderTarget) / sizeof(desc.RenderTarget[0]);
for (size_t n = 0; n < count; ++n) {
desc.RenderTarget[n].BlendEnable = TRUE;
desc.RenderTarget[n].SrcBlend = D3D11_BLEND_ONE;
desc.RenderTarget[n].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
desc.RenderTarget[n].SrcBlendAlpha = D3D11_BLEND_ONE;
desc.RenderTarget[n].DestBlendAlpha = D3D11_BLEND_INV_SRC_ALPHA;
desc.RenderTarget[n].BlendOp = D3D11_BLEND_OP_ADD;
desc.RenderTarget[n].BlendOpAlpha = D3D11_BLEND_OP_ADD;
desc.RenderTarget[n].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
}
device_->CreateBlendState(&desc, &blender);
}
return std::make_shared<SwapChain>(swapchain, rtv, sampler, blender);
}
std::shared_ptr<Geometry> Device::create_quad(float x,
float y,
float width,
float height,
bool flip) {
x = (x * 2.0f) - 1.0f;
y = 1.0f - (y * 2.0f);
width = width * 2.0f;
height = height * 2.0f;
float z = 1.0f;
SimpleVertex vertices[] = {
{DirectX::XMFLOAT3(x, y, z), DirectX::XMFLOAT2(0.0f, 0.0f)},
{DirectX::XMFLOAT3(x + width, y, z), DirectX::XMFLOAT2(1.0f, 0.0f)},
{DirectX::XMFLOAT3(x, y - height, z), DirectX::XMFLOAT2(0.0f, 1.0f)},
{DirectX::XMFLOAT3(x + width, y - height, z),
DirectX::XMFLOAT2(1.0f, 1.0f)}};
if (flip) {
DirectX::XMFLOAT2 tmp(vertices[2].tex);
vertices[2].tex = vertices[0].tex;
vertices[0].tex = tmp;
tmp = vertices[3].tex;
vertices[3].tex = vertices[1].tex;
vertices[1].tex = tmp;
}
D3D11_BUFFER_DESC desc = {};
desc.Usage = D3D11_USAGE_DEFAULT;
desc.ByteWidth = sizeof(SimpleVertex) * 4;
desc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
desc.CPUAccessFlags = 0;
D3D11_SUBRESOURCE_DATA srd = {};
srd.pSysMem = vertices;
ID3D11Buffer* buffer = nullptr;
const auto hr = device_->CreateBuffer(&desc, &srd, &buffer);
if (SUCCEEDED(hr)) {
return std::make_shared<Geometry>(
D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP, 4,
static_cast<uint32_t>(sizeof(SimpleVertex)), buffer);
}
return nullptr;
}
std::shared_ptr<Texture2D> Device::open_shared_texture(void* handle) {
ID3D11Texture2D* tex = nullptr;
auto hr = device_->OpenSharedResource(handle, __uuidof(ID3D11Texture2D),
(void**)(&tex));
if (FAILED(hr)) {
return nullptr;
}
D3D11_TEXTURE2D_DESC td;
tex->GetDesc(&td);
ID3D11ShaderResourceView* srv = nullptr;
if (td.BindFlags & D3D11_BIND_SHADER_RESOURCE) {
D3D11_SHADER_RESOURCE_VIEW_DESC srv_desc;
srv_desc.Format = td.Format;
srv_desc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
srv_desc.Texture2D.MostDetailedMip = 0;
srv_desc.Texture2D.MipLevels = 1;
hr = device_->CreateShaderResourceView(tex, &srv_desc, &srv);
if (FAILED(hr)) {
tex->Release();
return nullptr;
}
}
return std::make_shared<Texture2D>(tex, srv);
}
std::shared_ptr<Texture2D> Device::create_texture(int width,
int height,
DXGI_FORMAT format,
const void* data,
size_t row_stride) {
D3D11_TEXTURE2D_DESC td;
td.ArraySize = 1;
td.BindFlags = D3D11_BIND_SHADER_RESOURCE;
td.CPUAccessFlags = 0;
td.Format = format;
td.Width = width;
td.Height = height;
td.MipLevels = 1;
td.MiscFlags = 0;
td.SampleDesc.Count = 1;
td.SampleDesc.Quality = 0;
td.Usage = D3D11_USAGE_DEFAULT;
D3D11_SUBRESOURCE_DATA srd;
srd.pSysMem = data;
srd.SysMemPitch = static_cast<uint32_t>(row_stride);
srd.SysMemSlicePitch = 0;
ID3D11Texture2D* tex = nullptr;
auto hr = device_->CreateTexture2D(&td, data ? &srd : nullptr, &tex);
if (FAILED(hr)) {
return nullptr;
}
D3D11_SHADER_RESOURCE_VIEW_DESC srv_desc;
srv_desc.Format = td.Format;
srv_desc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
srv_desc.Texture2D.MostDetailedMip = 0;
srv_desc.Texture2D.MipLevels = 1;
ID3D11ShaderResourceView* srv = nullptr;
hr = device_->CreateShaderResourceView(tex, &srv_desc, &srv);
if (FAILED(hr)) {
tex->Release();
return nullptr;
}
return std::make_shared<Texture2D>(tex, srv);
}
std::shared_ptr<ID3DBlob> Device::compile_shader(const std::string& source_code,
const std::string& entry_point,
const std::string& model) {
if (!lib_compiler_) {
return nullptr;
}
typedef HRESULT(WINAPI * PFN_D3DCOMPILE)(
LPCVOID, SIZE_T, LPCSTR, const D3D_SHADER_MACRO*, ID3DInclude*, LPCSTR,
LPCSTR, UINT, UINT, ID3DBlob**, ID3DBlob**);
const auto fnc_compile = reinterpret_cast<PFN_D3DCOMPILE>(
GetProcAddress(lib_compiler_, "D3DCompile"));
if (!fnc_compile) {
return nullptr;
}
DWORD flags = D3DCOMPILE_ENABLE_STRICTNESS;
#if defined(NDEBUG)
// flags |= D3DCOMPILE_OPTIMIZATION_LEVEL3;
// flags |= D3DCOMPILE_AVOID_FLOW_CONTROL;
#else
flags |= D3DCOMPILE_DEBUG;
flags |= D3DCOMPILE_SKIP_OPTIMIZATION;
#endif
ID3DBlob* blob = nullptr;
ID3DBlob* blob_err = nullptr;
const auto psrc = source_code.c_str();
const auto len = source_code.size() + 1;
const auto hr =
fnc_compile(psrc, len, nullptr, nullptr, nullptr, entry_point.c_str(),
model.c_str(), flags, 0, &blob, &blob_err);
if (FAILED(hr)) {
if (blob_err) {
// TODO: Log the error.
blob_err->Release();
}
return nullptr;
}
if (blob_err) {
blob_err->Release();
}
return std::shared_ptr<ID3DBlob>(blob, [](ID3DBlob* p) {
if (p)
p->Release();
});
}
std::shared_ptr<Effect> Device::create_default_effect() {
const auto vsh =
R"--(struct VS_INPUT
{
float4 pos : POSITION;
float2 tex : TEXCOORD0;
};
struct VS_OUTPUT
{
float4 pos : SV_POSITION;
float2 tex : TEXCOORD0;
};
VS_OUTPUT main(VS_INPUT input)
{
VS_OUTPUT output;
output.pos = input.pos;
output.tex = input.tex;
return output;
})--";
const auto psh =
R"--(Texture2D tex0 : register(t0);
SamplerState samp0 : register(s0);
struct VS_OUTPUT
{
float4 pos : SV_POSITION;
float2 tex : TEXCOORD0;
};
float4 main(VS_OUTPUT input) : SV_Target
{
return tex0.Sample(samp0, input.tex);
})--";
return create_effect(vsh, "main", "vs_4_0", psh, "main", "ps_4_0");
}
std::shared_ptr<Effect> Device::create_effect(const std::string& vertex_code,
const std::string& vertex_entry,
const std::string& vertex_model,
const std::string& pixel_code,
const std::string& pixel_entry,
const std::string& pixel_model) {
const auto vs_blob = compile_shader(vertex_code, vertex_entry, vertex_model);
ID3D11VertexShader* vshdr = nullptr;
ID3D11InputLayout* layout = nullptr;
if (vs_blob) {
device_->CreateVertexShader(vs_blob->GetBufferPointer(),
vs_blob->GetBufferSize(), nullptr, &vshdr);
D3D11_INPUT_ELEMENT_DESC layout_desc[] = {
{"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0,
D3D11_INPUT_PER_VERTEX_DATA, 0},
{"TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12,
D3D11_INPUT_PER_VERTEX_DATA, 0},
};
UINT elements = ARRAYSIZE(layout_desc);
// Create the input layout.
device_->CreateInputLayout(layout_desc, elements,
vs_blob->GetBufferPointer(),
vs_blob->GetBufferSize(), &layout);
}
const auto ps_blob = compile_shader(pixel_code, pixel_entry, pixel_model);
ID3D11PixelShader* pshdr = nullptr;
if (ps_blob) {
device_->CreatePixelShader(ps_blob->GetBufferPointer(),
ps_blob->GetBufferSize(), nullptr, &pshdr);
}
return std::make_shared<Effect>(vshdr, pshdr, layout);
}
Layer::Layer(const std::shared_ptr<Device>& device, bool flip)
: device_(device), flip_(flip) {
bounds_.x = bounds_.y = bounds_.width = bounds_.height = 0.0f;
}
Layer::~Layer() {}
void Layer::attach(const std::shared_ptr<Composition>& parent) {
composition_ = parent;
}
std::shared_ptr<Composition> Layer::composition() const {
return composition_.lock();
}
Rect Layer::bounds() const {
return bounds_;
}
void Layer::move(float x, float y, float width, float height) {
bounds_.x = x;
bounds_.y = y;
bounds_.width = width;
bounds_.height = height;
// It's not efficient to create the quad everytime we move, but for now we're
// just trying to get something on-screen.
geometry_.reset();
}
void Layer::tick(double) {
// Nothing to update in the base class.
}
void Layer::render_texture(const std::shared_ptr<Context>& ctx,
const std::shared_ptr<Texture2D>& texture) {
if (!geometry_) {
geometry_ = device_->create_quad(bounds_.x, bounds_.y, bounds_.width,
bounds_.height, flip_);
}
if (geometry_ && texture) {
// We need a shader.
if (!effect_) {
effect_ = device_->create_default_effect();
}
// Bind our states/resource to the pipeline.
ScopedBinder<Geometry> quad_binder(ctx, geometry_);
ScopedBinder<Effect> fx_binder(ctx, effect_);
ScopedBinder<Texture2D> tex_binder(ctx, texture);
// Draw the quad.
geometry_->draw();
}
}
Composition::Composition(const std::shared_ptr<Device>& device,
int width,
int height)
: width_(width), height_(height), vsync_(true), device_(device) {
fps_ = 0.0;
time_ = 0.0;
frame_ = 0;
fps_start_ = GetTimeNow();
}
bool Composition::is_vsync() const {
return vsync_;
}
double Composition::time() const {
return time_;
}
double Composition::fps() const {
return fps_;
}
void Composition::add_layer(const std::shared_ptr<Layer>& layer) {
if (layer) {
layers_.push_back(layer);
// Attach ourselves as the parent.
layer->attach(shared_from_this());
}
}
bool Composition::remove_layer(const std::shared_ptr<Layer>& layer) {
size_t match = 0;
if (layer) {
for (auto i = layers_.begin(); i != layers_.end();) {
if ((*i).get() == layer.get()) {
i = layers_.erase(i);
match++;
} else {
i++;
}
}
}
return (match > 0);
}
void Composition::resize(bool vsync, int width, int height) {
vsync_ = vsync;
width_ = width;
height_ = height;
}
void Composition::tick(double t) {
time_ = t;
for (const auto& layer : layers_) {
layer->tick(t);
}
}
void Composition::render(const std::shared_ptr<Context>& ctx) {
// Use painter's algorithm and render our layers in order (not doing any dept
// or 3D here).
for (const auto& layer : layers_) {
layer->render(ctx);
}
frame_++;
const auto now = GetTimeNow();
if ((now - fps_start_) > 1000000) {
fps_ = frame_ / double((now - fps_start_) / 1000000.0);
frame_ = 0;
fps_start_ = now;
}
}
FrameBuffer::FrameBuffer(const std::shared_ptr<Device>& device)
: device_(device) {}
void FrameBuffer::on_paint(void* shared_handle) {
// Did the shared texture change?
if (shared_buffer_ && shared_handle != shared_buffer_->share_handle()) {
shared_buffer_.reset();
}
// Open the shared texture.
if (!shared_buffer_) {
shared_buffer_ = device_->open_shared_texture((void*)shared_handle);
if (!shared_buffer_) {
LOG(ERROR) << "d3d11: Could not open shared texture!";
}
}
}
} // namespace d3d11
} // namespace client
Reference in New Issue View Git Blame Copy Permalink