ShaderVulkan::ShaderVulkan(
::VkDevice deviceIn,
const ShaderBytecode& shaderBytecode,
const ShaderCompileOptions& compileOptions)
: device(deviceIn)
, shaderModule(nullptr)
{
VkShaderModuleCreateInfo moduleCreateInfo;
moduleCreateInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
moduleCreateInfo.pNext = nullptr;
moduleCreateInfo.flags = 0;
moduleCreateInfo.codeSize = shaderBytecode.ByteLength / sizeof(std::uint32_t);
moduleCreateInfo.pCode = reinterpret_cast<const std::uint32_t*>(shaderBytecode.Code);
auto result = vkCreateShaderModule(device, &moduleCreateInfo, nullptr, &shaderModule);
if (result != VK_SUCCESS) {
// FUS RO DAH!
POMDOG_THROW_EXCEPTION(std::runtime_error,
"Failed to create VkShaderModule");
}
///@todo Not implemented
// FUS RO DAH!
POMDOG_THROW_EXCEPTION(std::runtime_error, "Not implemented");
}
OpenGLContextWin32::OpenGLContextWin32(
HWND windowHandleIn,
const PresentationParameters& presentationParameters)
: windowHandle(windowHandleIn)
, hdc(nullptr, [this](HDC hdcIn) {
ReleaseDC(windowHandle, hdcIn);
})
, glrc(nullptr, [](HGLRC glrcIn) {
if (wglGetCurrentContext() == glrcIn) {
wglMakeCurrent(nullptr, nullptr);
}
wglDeleteContext(glrcIn);
})
{
hdc.reset(GetDC(windowHandle));
auto formatDescriptor = ToPixelFormatDescriptor(presentationParameters);
auto const pixelFormat = ChoosePixelFormat(hdc.get(), &formatDescriptor);
if (0 == pixelFormat)
{
auto const errorCode = ::GetLastError();
std::stringstream ss;
ss << "Failed to call ChoosePixelFormat function."
<< "The calling thread's last-error code is "
<< std::hex << errorCode;
POMDOG_THROW_EXCEPTION(std::runtime_error, ss.str());
}
if (!SetPixelFormat(hdc.get(), pixelFormat, &formatDescriptor))
{
auto const errorCode = ::GetLastError();
std::stringstream ss;
ss << "Failed to call SetPixelFormat function."
<< "The calling thread's last-error code is "
<< std::hex << errorCode;
POMDOG_THROW_EXCEPTION(std::runtime_error, ss.str());
}
// Create gl context
glrc.reset(wglCreateContext(hdc.get()));
if (!wglMakeCurrent(hdc.get(), glrc.get()))
{
auto const errorCode = ::GetLastError();
std::stringstream ss;
ss << "Failed to call wglMakeCurrent function."
<< "The calling thread's last-error code is "
<< std::hex << errorCode;
POMDOG_THROW_EXCEPTION(std::runtime_error, ss.str());
}
}
GameHostX11::Impl::Impl(const PresentationParameters& presentationParameters)
: backBufferSurfaceFormat(presentationParameters.BackBufferFormat)
, backBufferDepthStencilFormat(presentationParameters.DepthStencilFormat)
, exitRequest(false)
{
POMDOG_ASSERT(presentationParameters.PresentationInterval > 0);
presentationInterval = Duration(1.0) / presentationParameters.PresentationInterval;
x11Context = std::make_shared<X11Context>();
auto framebufferConfig = ChooseFramebufferConfig(
x11Context->Display, presentationParameters);
window = std::make_shared<GameWindowX11>(
x11Context,
framebufferConfig,
presentationParameters.BackBufferWidth,
presentationParameters.BackBufferHeight);
openGLContext = std::make_shared<OpenGLContextX11>(window, framebufferConfig);
if (!openGLContext->IsOpenGL3Supported()) {
POMDOG_THROW_EXCEPTION(std::runtime_error,
"Pomdog doesn't support versions of OpenGL lower than 3.3/4.0.");
}
openGLContext->MakeCurrent();
auto const errorCode = glewInit();
if (GLEW_OK != errorCode) {
auto description = reinterpret_cast<const char*>(glewGetErrorString(errorCode));
POMDOG_THROW_EXCEPTION(std::runtime_error, description);
}
graphicsDevice = std::make_shared<GraphicsDevice>(
std::make_unique<GraphicsDeviceGL4>(presentationParameters));
graphicsContext = std::make_shared<GraphicsContextGL4>(openGLContext, window);
graphicsCommandQueue = std::make_shared<GraphicsCommandQueue>(
std::make_unique<GraphicsCommandQueueImmediate>(graphicsContext));
audioEngine = std::make_shared<AudioEngine>();
keyboard = std::make_unique<KeyboardX11>(x11Context->Display);
gamepad = Detail::InputSystem::CreateGamepad();
Detail::AssetLoaderContext loaderContext;
loaderContext.RootDirectory = PathHelper::Join(FileSystem::GetResourceDirectoryPath(), "Content");
loaderContext.GraphicsDevice = graphicsDevice;
assetManager = std::make_unique<AssetManager>(std::move(loaderContext));
}
GraphicsCommandListVulkan::GraphicsCommandListVulkan()
{
// TODO: Not implemented
commandBuffer = nullptr;
POMDOG_THROW_EXCEPTION(std::runtime_error, "Not implemented");
}
std::shared_ptr<AudioClip> AssetLoader<AudioClip>::operator()(
const AssetLoaderContext& loaderContext, const std::string& assetName)
{
auto binaryStream = loaderContext.OpenStream(assetName);
if (!binaryStream.Stream) {
POMDOG_THROW_EXCEPTION(std::runtime_error,
"Cannot open the wave file: " + assetName);
}
if (binaryStream.SizeInBytes < (sizeof(std::uint8_t) * 12)) {
POMDOG_THROW_EXCEPTION(std::runtime_error,
"The audio file is too small: " + assetName);
}
auto & stream = binaryStream.Stream;
auto signature = BinaryReader::ReadArray<std::uint8_t, 12>(stream);
if (stream.fail()) {
POMDOG_THROW_EXCEPTION(std::runtime_error,
"Failed to read the audio file.");
}
const auto fourCC = MakeFourCC(signature[0], signature[1], signature[2], signature[3]);
if (fourCC == MakeFourCC('R', 'I', 'F', 'F')) {
const auto fccType = MakeFourCC(signature[8], signature[9], signature[10], signature[11]);
if (fccType == MakeFourCC('W', 'A', 'V', 'E')) {
// This file format is RIFF waveform audio.
auto audioClip = MSWaveAudioLoader::Load(std::move(binaryStream));
return std::move(audioClip);
}
}
else if (fourCC == MakeFourCC('O', 'g', 'g', 'S')) {
// This file format is Ogg Vorbis.
POMDOG_THROW_EXCEPTION(std::runtime_error,
"Pomdog does not yet supported Ogg Vorbis format.");
}
POMDOG_THROW_EXCEPTION(std::runtime_error, "Not implemented.");
}
//-----------------------------------------------------------------------
std::unique_ptr<Shader>
GraphicsDeviceGL4::CreateShader(ShaderBytecode const& shaderBytecode,
ShaderCompileOptions const& compileOptions)
{
switch (compileOptions.Profile.PipelineStage) {
case ShaderPipelineStage::VertexShader: {
return std::make_unique<VertexShaderGL4>(shaderBytecode);
}
case ShaderPipelineStage::PixelShader: {
return std::make_unique<PixelShaderGL4>(shaderBytecode);
}
}
POMDOG_THROW_EXCEPTION(std::domain_error, "Failed to create shader");
}
X11Context::X11Context()
: Display(nullptr)
{
::XInitThreads();
Display = ::XOpenDisplay(nullptr);
if (Display == nullptr) {
POMDOG_THROW_EXCEPTION(std::runtime_error, "Error: XOpenDisplay");
}
//int screen = DefaultScreen(display);
//::Window rootWindow = RootWindow(display, screen);
InitializeAtoms(Display, Atoms);
}
std::string FileSystem::GetAppDataDirectoryPath()
{
TCHAR directoryName[MAX_PATH];
auto hr = SHGetFolderPath(nullptr, CSIDL_APPDATA, nullptr, 0, directoryName);
if (FAILED(hr)) {
POMDOG_THROW_EXCEPTION(std::runtime_error,
"Failed to get AppData path.");
}
///@todo FIXME
constexpr auto productName = "Pomdog";
std::string appData(directoryName);
return PathHelper::Join(appData, productName);
}
std::vector<EffectConstantDescription> EffectReflectionVulkan::GetConstantBuffers() const
{
POMDOG_THROW_EXCEPTION(std::runtime_error, "Not implemented");
}
EffectReflectionVulkan::EffectReflectionVulkan()
{
POMDOG_THROW_EXCEPTION(std::runtime_error, "Not implemented");
}
void GraphicsCommandListVulkan::SetVertexBuffers(std::vector<VertexBufferBinding> && vertexBuffers)
{
POMDOG_THROW_EXCEPTION(std::runtime_error, "Not implemented");
}
void GraphicsCommandListVulkan::SetPipelineState(const std::shared_ptr<NativePipelineState>& pipelineState)
{
POMDOG_THROW_EXCEPTION(std::runtime_error, "Not implemented");
}
void GraphicsCommandListVulkan::SetPrimitiveTopology(PrimitiveTopology primitiveTopology)
{
POMDOG_THROW_EXCEPTION(std::runtime_error, "Not implemented");
}
//-----------------------------------------------------------------------
void GraphicsContextGL4::SetRenderTargets(std::vector<std::shared_ptr<RenderTarget2D>> const& renderTargetsIn)
{
POMDOG_ASSERT(!renderTargetsIn.empty());
POMDOG_ASSERT(frameBuffer);
// Bind framebuffer
glBindFramebuffer(GL_FRAMEBUFFER, frameBuffer->value);
POMDOG_CHECK_ERROR_GL4("glBindFramebuffer");
// Unbind render targets
{
std::size_t index = 0;
for (auto const& renderTarget: renderTargets)
{
POMDOG_ASSERT(renderTarget);
renderTarget->UnbindFromFramebuffer(ToColorAttachment(index));
++index;
}
}
renderTargets.clear();
// Unbind depth stencil buffer
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, 0);
POMDOG_CHECK_ERROR_GL4("glFramebufferRenderbuffer");
std::vector<GLenum> attachments;
attachments.reserve(renderTargetsIn.size());
renderTargets.reserve(renderTargetsIn.size());
// Attach textures
std::uint32_t index = 0;
for (auto const& renderTarget: renderTargetsIn)
{
POMDOG_ASSERT(renderTarget);
auto const nativeRenderTarget = static_cast<RenderTarget2DGL4*>(renderTarget->NativeRenderTarget2D());
POMDOG_ASSERT(nativeRenderTarget != nullptr);
POMDOG_ASSERT(nativeRenderTarget == dynamic_cast<RenderTarget2DGL4*>(renderTarget->NativeRenderTarget2D()));
POMDOG_ASSERT(nativeRenderTarget);
nativeRenderTarget->BindToFramebuffer(ToColorAttachment(index));
renderTargets.emplace_back(renderTarget, nativeRenderTarget);
attachments.push_back(ToColorAttachment(index));
++index;
}
// Attach depth stencil buffer
{
POMDOG_ASSERT(renderTargets.front());
auto const& renderTarget = renderTargets.front();
POMDOG_ASSERT(renderTarget);
renderTarget->BindDepthStencilBuffer();
}
// Check framebuffer status
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
// FUS RO DAH!
POMDOG_THROW_EXCEPTION(std::runtime_error,
"Failed to make complete framebuffer.");
}
POMDOG_ASSERT(!attachments.empty());
POMDOG_ASSERT(attachments.size() <= static_cast<std::size_t>(std::numeric_limits<GLsizei>::max()));
glDrawBuffers(static_cast<GLsizei>(attachments.size()), attachments.data());
POMDOG_CHECK_ERROR_GL4("glDrawBuffers");
}
void GraphicsCommandListVulkan::SetTexture(int index, const std::shared_ptr<RenderTarget2D>& texture)
{
POMDOG_THROW_EXCEPTION(std::runtime_error, "Not implemented");
}
void GraphicsCommandListVulkan::SetTexture(int index)
{
POMDOG_THROW_EXCEPTION(std::runtime_error, "Not implemented");
}
void GraphicsCommandListVulkan::SetSampler(int index, std::shared_ptr<NativeSamplerState> && sampler)
{
POMDOG_THROW_EXCEPTION(std::runtime_error, "Not implemented");
}
void GraphicsCommandListVulkan::SetConstantBuffer(int index, const std::shared_ptr<NativeBuffer>& constantBuffer)
{
POMDOG_THROW_EXCEPTION(std::runtime_error, "Not implemented");
}
void GraphicsCommandListVulkan::SetBlendFactor(const Color& blendFactor)
{
POMDOG_THROW_EXCEPTION(std::runtime_error, "Not implemented");
}
std::size_t GraphicsCommandListVulkan::GetCount() const noexcept
{
POMDOG_THROW_EXCEPTION(std::runtime_error, "Not implemented");
}
void GraphicsCommandListVulkan::SetIndexBuffer(const std::shared_ptr<IndexBuffer>& indexBuffer)
{
POMDOG_THROW_EXCEPTION(std::runtime_error, "Not implemented");
}
void GraphicsCommandListVulkan::Reset()
{
POMDOG_THROW_EXCEPTION(std::runtime_error, "Not implemented");
}
void GraphicsCommandListVulkan::SetRenderPass(RenderPass && renderPass)
{
POMDOG_THROW_EXCEPTION(std::runtime_error, "Not implemented");
}
