thirdparty/ppsspp
2
0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

More progress

Browse source
This commit is contained in:
Henrik Rydgard 2016-01-02 02:08:05 +01:00
parent 4ddca8607f
commit cfbecf5071
18 changed files with 320 additions and 426 deletions
Download patch file Download diff file Expand all files Collapse all files

2
GPU/GPU.vcxproj
View file

@ -249,7 +249,6 @@
<ClInclude Include="Vulkan\FramebufferVulkan.h" />
<ClInclude Include="Vulkan\GPU_Vulkan.h" />
<ClInclude Include="Vulkan\PipelineManagerVulkan.h" />
<ClInclude Include="Vulkan\ShaderCompiler.h" />
<ClInclude Include="Vulkan\ShaderManagerVulkan.h" />
<ClInclude Include="Vulkan\TextureCacheVulkan.h" />
<ClInclude Include="Vulkan\VertexShaderGeneratorVulkan.h" />
@ -337,7 +336,6 @@
<ClCompile Include="Vulkan\FramebufferVulkan.cpp" />
<ClCompile Include="Vulkan\GPU_Vulkan.cpp" />
<ClCompile Include="Vulkan\PipelineManagerVulkan.cpp" />
<ClCompile Include="Vulkan\ShaderCompiler.cpp" />
<ClCompile Include="Vulkan\ShaderManagerVulkan.cpp" />
<ClCompile Include="Vulkan\StateMappingVulkan.cpp" />
<ClCompile Include="Vulkan\VertexShaderGeneratorVulkan.cpp" />

2
GPU/GPU.vcxproj.filters
View file

@ -210,7 +210,6 @@
<ClInclude Include="Vulkan\VertexShaderGeneratorVulkan.h" />
<ClInclude Include="Vulkan\FragmentShaderGeneratorVulkan.h" />
<ClInclude Include="Vulkan\ShaderManagerVulkan.h" />
<ClInclude Include="Vulkan\ShaderCompiler.h" />
</ItemGroup>
<ItemGroup>
<ClCompile Include="Math3D.cpp">
@ -404,6 +403,5 @@
<ClCompile Include="Vulkan\FramebufferVulkan.cpp" />
<ClCompile Include="Vulkan\FragmentShaderGeneratorVulkan.cpp" />
<ClCompile Include="Vulkan\ShaderManagerVulkan.cpp" />
<ClCompile Include="Vulkan\ShaderCompiler.cpp" />
</ItemGroup>
</Project>

23
GPU/Vulkan/ShaderCompiler.cpp
View file

@ -1,23 +0,0 @@
// Copyright (c) 2015- PPSSPP Project.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0 or later versions.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License 2.0 for more details.
// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/
// Official git repository and contact information can be found at
// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
#include "GPU/Vulkan/VulkanUtil.h"
#include "GPU/Vulkan/ShaderCompiler.h"
bool CompileGLSLVulkan(const char *code, std::vector<uint32_t> &spirv, std::string &errorMessage) {
return false;
}

27
GPU/Vulkan/ShaderCompiler.h
View file

@ -1,27 +0,0 @@
// Copyright (c) 2015- PPSSPP Project.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0 or later versions.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License 2.0 for more details.
// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/
// Official git repository and contact information can be found at
// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
#pragma once
#include <vector>
#include "GPU/Vulkan/VulkanUtil.h"
// Wrapper around the GLSL compiler library. Compiles GLSL into SPIR-V consumable by Vulkan.
bool CompileGLSLVulkan(const char *code, std::vector<uint32_t> &spirv, std::string &errorMessage);
// TODO: Compute shaders

41
GPU/Vulkan/ShaderManagerVulkan.cpp
View file

@ -37,7 +37,6 @@
#include "GPU/Vulkan/ShaderManagerVulkan.h"
#include "GPU/Vulkan/DrawEngineVulkan.h"
#include "GPU/Vulkan/FramebufferVulkan.h"
#include "GPU/Vulkan/ShaderCompiler.h"
#include "GPU/Vulkan/FragmentShaderGeneratorVulkan.h"
#include "GPU/Vulkan/VertexShaderGeneratorVulkan.h"
#include "UI/OnScreenDisplay.h"
@ -51,7 +50,8 @@ VulkanFragmentShader::VulkanFragmentShader(VkDevice device, ShaderID id, const c
std::string errorMessage;
std::vector<uint32_t> spirv;
bool success = CompileGLSLVulkan(code, spirv, errorMessage);
bool success = GLSLtoSPV(VK_SHADER_STAGE_FRAGMENT_BIT, code, spirv, &errorMessage);
if (!errorMessage.empty()) {
if (success) {
ERROR_LOG(G3D, "Warnings in shader compilation!");
@ -100,7 +100,7 @@ VulkanVertexShader::VulkanVertexShader(VkDevice device, ShaderID id, const char
#endif
std::string errorMessage;
std::vector<uint32_t> spirv;
bool success = CompileGLSLVulkan(code, spirv, errorMessage);
bool success = GLSLtoSPV(VK_SHADER_STAGE_VERTEX_BIT, code, spirv, &errorMessage);
if (!errorMessage.empty()) {
if (success) {
ERROR_LOG(G3D, "Warnings in shader compilation!");
@ -142,33 +142,12 @@ std::string VulkanVertexShader::GetShaderString(DebugShaderStringType type) cons
}
}
/*
// Utility
void ShaderManagerVulkan::VSSetMatrix4x3(int creg, const float *m4x3) {
float m4x4[16];
ConvertMatrix4x3To4x4Transposed(m4x4, m4x3);
pD3Ddevice->SetVertexShaderConstantF(creg, m4x4, 4);
}
void ShaderManagerVulkan::VSSetMatrix4x3_3(int creg, const float *m4x3) {
float m3x4[16];
ConvertMatrix4x3To3x4Transposed(m3x4, m4x3);
pD3Ddevice->SetVertexShaderConstantF(creg, m3x4, 3);
}
void ShaderManagerVulkan::VSSetMatrix(int creg, const float* pMatrix) {
float transp[16];
Transpose4x4(transp, pMatrix);
pD3Ddevice->SetVertexShaderConstantF(creg, transp, 4);
}
*/
// Depth in ogl is between -1;1 we need between 0;1 and optionally reverse it
static void ConvertProjMatrixToVulkan(Matrix4x4 &in, bool invertedX, bool invertedY, bool invertedZ) {
// Half pixel offset hack
float xoff = 0.5f / gstate_c.curRTRenderWidth;
xoff = gstate_c.vpXOffset + (invertedX ? xoff : -xoff);
float yoff = -0.5f / gstate_c.curRTRenderHeight;
float yoff = 0.5f / gstate_c.curRTRenderHeight;
yoff = gstate_c.vpYOffset + (invertedY ? yoff : -yoff);
if (invertedX)
@ -180,9 +159,7 @@ static void ConvertProjMatrixToVulkan(Matrix4x4 &in, bool invertedX, bool invert
}
static void ConvertProjMatrixToVulkanThrough(Matrix4x4 &in) {
float xoff = -0.5f / gstate_c.curRTRenderWidth;
float yoff = 0.5f / gstate_c.curRTRenderHeight;
in.translateAndScale(Vec3(xoff, yoff, 0.5f), Vec3(1.0f, 1.0f, 0.5f));
in.translateAndScale(Vec3(0.0f, 0.0f, 0.5f), Vec3(1.0f, 1.0f, 0.5f));
}
void ShaderManagerVulkan::PSUpdateUniforms(int dirtyUniforms) {
@ -402,20 +379,20 @@ void ShaderManagerVulkan::VSUpdateUniforms(int dirtyUniforms) {
// Lighting
if (dirtyUniforms & DIRTY_AMBIENT) {
Uint8x3ToFloat4_AlphaUint8(ub_lightGlobal.ambientColor, gstate.ambientcolor, gstate.getAmbientA());
Uint8x3ToFloat4_AlphaUint8(ub_lights.ambientColor, gstate.ambientcolor, gstate.getAmbientA());
}
if (dirtyUniforms & DIRTY_MATAMBIENTALPHA) {
// Note - this one is not in lighting but in transformCommon as it has uses beyond lighting
Uint8x3ToFloat4_AlphaUint8(ub_transformCommon.matAmbient, gstate.materialambient, gstate.getMaterialAmbientA());
}
if (dirtyUniforms & DIRTY_MATDIFFUSE) {
Uint8x3ToFloat4(ub_lightGlobal.materialDiffuse, gstate.materialdiffuse);
Uint8x3ToFloat4(ub_lights.materialDiffuse, gstate.materialdiffuse);
}
if (dirtyUniforms & DIRTY_MATEMISSIVE) {
Uint8x3ToFloat4(ub_lightGlobal.materialEmissive, gstate.materialemissive);
Uint8x3ToFloat4(ub_lights.materialEmissive, gstate.materialemissive);
}
if (dirtyUniforms & DIRTY_MATSPECULAR) {
Uint8x3ToFloat4_Alpha(ub_lightGlobal.materialEmissive, gstate.materialspecular, getFloat24(gstate.materialspecularcoef));
Uint8x3ToFloat4_Alpha(ub_lights.materialEmissive, gstate.materialspecular, getFloat24(gstate.materialspecularcoef));
}
for (int i = 0; i < 4; i++) {

27
GPU/Vulkan/ShaderManagerVulkan.h
View file

@ -96,6 +96,10 @@ R"(matrix4x4 proj;
)";
struct UB_VS_Lights {
float ambientColor[4];
float materialDiffuse[4];
float materialSpecular[4];
float materialEmissive[4];
float lpos[4][4];
float ldir[4][4];
float latt[4][4];
@ -107,7 +111,11 @@ struct UB_VS_Lights {
};
static const char *ub_vs_lightsStr =
R"(vec3 lpos[4];
R"(vec3 ambientColor;
vec3 materialDiffuse;
vec4 materialSpecular;
vec3 materialEmissive;
vec3 lpos[4];
vec3 ldir[4];
vec3 latt[4];
float lightAngle[4];
@ -117,26 +125,12 @@ R"(vec3 lpos[4];
vec3 lightSpecular[4];
)";
struct UB_VS_LightGlobal {
float ambientColor[4];
float materialDiffuse[4];
float materialSpecular[4];
float materialEmissive[4];
};
static const char *ub_vs_lightsGlobalStr =
R"(vec3 ambientColor;
vec3 materialDiffuse;
vec4 materialSpecular;
vec3 materialEmissive;
)";
struct UB_VS_Bones {
float bones[8][16];
};
static const char *ub_vs_bonesStr =
R"(matrix4x4 bone[8];
R"(matrix4x4 m[8];
)";
// Let's not bother splitting this, we'll just upload the lot for every draw call.
@ -242,7 +236,6 @@ private:
// Uniform block scratchpad. These (the relevant ones) are copied to the current pushbuffer at draw time.
UB_VS_TransformCommon ub_transformCommon;
UB_VS_LightGlobal ub_lightGlobal;
UB_VS_Lights ub_lights;
UB_VS_Bones ub_bones;
UB_FS_All ub_fragment;

22
GPU/Vulkan/StateMappingVulkan.cpp
View file

@ -176,22 +176,24 @@ void ConvertStateToVulkanKey(FramebufferManagerVulkan &fbManager, int prim, Vulk
bool alphaMask = gstate.isClearModeAlphaMask();
key.colorWriteMask = (colorMask ? (VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_A_BIT) : 0) | (alphaMask ? VK_COLOR_COMPONENT_A_BIT : 0);
GenericStencilFuncState stencilState;
ConvertStencilFuncState(stencilState);
// Stencil Test
if (alphaMask) {
if (stencilState.enabled) {
key.stencilTestEnable = true;
key.stencilCompareOp = VK_COMPARE_OP_ALWAYS;
key.stencilPassOp = VK_STENCIL_OP_REPLACE;
key.stencilFailOp = VK_STENCIL_OP_REPLACE;
key.stencilDepthFailOp = VK_STENCIL_OP_REPLACE;
// TODO: Are these right?
key.stencilCompareOp = compareOps[stencilState.testFunc];
key.stencilPassOp = stencilOps[stencilState.zPass];
key.stencilFailOp = stencilOps[stencilState.sFail];
key.stencilDepthFailOp = stencilOps[stencilState.zFail];
dynState.useStencil = true;
dynState.stencilRef = 0xFF;
dynState.stencilCompareMask = 0xFF;
dynState.stencilWriteMask = 0xFF;
dynState.stencilRef = stencilState.testRef;
dynState.stencilCompareMask = stencilState.testMask;
dynState.stencilWriteMask = stencilState.writeMask;
} else {
key.stencilTestEnable = false;
dynState.useStencil = false;
}
} else {
// Set cull
bool wantCull = !gstate.isModeThrough() && prim != GE_PRIM_RECTANGLES && gstate.isCullEnabled();

58
GPU/Vulkan/VertexShaderGeneratorVulkan.cpp
View file

@ -32,6 +32,7 @@
#include "GPU/Common/VertexDecoderCommon.h"
#include "GPU/Vulkan/VertexShaderGeneratorVulkan.h"
#include "GPU/Vulkan/PipelineManagerVulkan.h"
#include "GPU/Vulkan/ShaderManagerVulkan.h"
// "Varying" layout - must match fragment shader
// color0 = 0
@ -70,42 +71,6 @@ enum DoLightComputation {
LIGHT_FULL,
};
const char *vulkan_base_uniforms = R"(
layout(set=0, binding=4) uniform base {
mat4 proj;
mat4 world;
mat4 view;
mat4 texmtx;
vec4 uvscaleoffset;
vec2 fogcoef;
vec4 depthRange;
vec4 matambientalpha;
};
)";
const char *vulkan_light_uniforms = R"(
layout(set=0, binding=5) uniform light {
vec4 ambient;
vec3 matdiffuse;
vec4 matspecular;
vec3 matemissive;
vec3 pos[4];
// TODO: Make lighttype/comp uniforms too
vec3 att[4];
vec3 dir[4];
float angle[4];
float spotCoef[4];
vec3 ambient[4];
vec3 diffuse[4];
vec3 specular[4];
)";
const char *vulkan_bone_uniforms = R"(
layout(set=0, binding=6) uniform bone {
mat4 m[8];
)";
// Depth range and viewport
//
// After the multiplication with the projection matrix, we have a 4D vector in clip space.
@ -213,12 +178,11 @@ bool GenerateVulkanGLSLVertexShader(const ShaderID &id, char *buffer) {
// We will memcpy the parts into place in a big buffer so we can be quite dynamic about what parts
// are present and what parts aren't, but we will not be ultra detailed about it.
WRITE(p, "%s", vulkan_base_uniforms);
WRITE(p, "layout (binding=3) uniform base {\n%s\n}\n", ub_vs_transformCommonStr);
if (enableLighting)
WRITE(p, "%s", vulkan_light_uniforms);
WRITE(p, "layout (binding=4) uniform light {\n%s\n}\n", ub_vs_lightsStr);
if (enableBones)
WRITE(p, "%s", vulkan_bone_uniforms);
WRITE(p, "layout (binding=5) uniform bone {\n%s\n}\n", ub_vs_bonesStr);
bool prescale = false;
@ -409,10 +373,10 @@ bool GenerateVulkanGLSLVertexShader(const ShaderID &id, char *buffer) {
if (poweredDiffuse) {
// pow(0.0, 0.0) may be undefined, but the PSP seems to treat it as 1.0.
// Seen in Tales of the World: Radiant Mythology (#2424.)
WRITE(p, " if (dot%i == 0.0 && u_matspecular.a == 0.0) {\n", i);
WRITE(p, " if (dot%i == 0.0 && light.matspecular.a == 0.0) {\n", i);
WRITE(p, " dot%i = 1.0;\n", i);
WRITE(p, " } else {\n");
WRITE(p, " dot%i = pow(dot[%i], u_matspecular.a);\n", i, i);
WRITE(p, " dot%i = pow(dot[%i], light.matspecular.a);\n", i, i);
WRITE(p, " }\n");
}
@ -444,7 +408,7 @@ bool GenerateVulkanGLSLVertexShader(const ShaderID &id, char *buffer) {
if (doSpecular) {
WRITE(p, " dot[%i] = dot(normalize(toLight + vec3(0.0, 0.0, 1.0)), worldnormal);\n", i);
WRITE(p, " if (dot[%i] > 0.0)\n", i);
WRITE(p, " lightSum1 += light.specular[%i] * %s * (pow(dot[%i], u_matspecular.a) %s);\n", i, specularStr, i, timesLightScale);
WRITE(p, " lightSum1 += light.specular[%i] * %s * (pow(dot[%i], light.matspecular.a) %s);\n", i, specularStr, i, timesLightScale);
}
WRITE(p, " lightSum0.rgb += (light.ambient[%i] * %s.rgb + diffuse)%s;\n", i, ambientStr, timesLightScale);
}
@ -471,7 +435,7 @@ bool GenerateVulkanGLSLVertexShader(const ShaderID &id, char *buffer) {
if (hasColor) {
WRITE(p, " v_color0 = color0;\n");
} else {
WRITE(p, " v_color0 = u_matambientalpha;\n");
WRITE(p, " v_color0 = base.matambientalpha;\n");
}
if (lmode)
WRITE(p, " v_color1 = vec3(0.0);\n");
@ -490,9 +454,9 @@ bool GenerateVulkanGLSLVertexShader(const ShaderID &id, char *buffer) {
}
} else {
if (hasTexcoord) {
WRITE(p, " v_texcoord = texcoord * u_uvscaleoffset.xy + u_uvscaleoffset.zw;\n");
WRITE(p, " v_texcoord = texcoord * base.uvscaleoffset.xy + base.uvscaleoffset.zw;\n");
} else {
WRITE(p, " v_texcoord = u_uvscaleoffset.zw;\n");
WRITE(p, " v_texcoord = base.uvscaleoffset.zw;\n");
}
}
break;
@ -546,7 +510,7 @@ bool GenerateVulkanGLSLVertexShader(const ShaderID &id, char *buffer) {
// Compute fogdepth
if (enableFog)
WRITE(p, " v_fogdepth = (viewPos.z + u_fogcoef.x) * u_fogcoef.y;\n");
WRITE(p, " v_fogdepth = (viewPos.z + base.fogcoef.x) * base.fogcoef.y;\n");
}
WRITE(p, "}\n");
return true;

1
GPU/Vulkan/VulkanUtil.h
View file

@ -2,4 +2,5 @@
#define VK_PROTOTYPES
#include "ext/vulkan/vulkan.h"
#include "thin3d/vulkan_utils.h"

14
Windows/GPU/WindowsVulkanContext.cpp
View file

@ -100,7 +100,7 @@ const char *ObjTypeToString(VkDebugReportObjectTypeEXT type) {
}
static VkBool32 VKAPI_CALL Vulkan_Dbg(VkDebugReportFlagsEXT msgFlags, VkDebugReportObjectTypeEXT objType, uint64_t srcObject, size_t location, int32_t msgCode, const char* pLayerPrefix, const char* pMsg, void *pUserData) {
VulkanLogOptions *options = (VulkanLogOptions *)pUserData;
const VulkanLogOptions *options = (const VulkanLogOptions *)pUserData;
std::ostringstream message;
if (msgFlags & VK_DEBUG_REPORT_ERROR_BIT_EXT) {
@ -167,16 +167,10 @@ bool WindowsVulkanContext::Init(HINSTANCE hInst, HWND hWnd, std::string *error_m
_CrtCheckMemory();
VkClearValue clearVal[2];
memset(clearVal, 0, sizeof(clearVal));
clearVal[0].color.float32[0] = 0.5f;
g_Vulkan->BeginSurfaceRenderPass(clearVal);
return true;
}
void WindowsVulkanContext::Shutdown() {
g_Vulkan->EndSurfaceRenderPass();
g_Vulkan->DestroyObjects();
g_Vulkan->DestroyDebugMsgCallback();
g_Vulkan->DestroyDevice();
@ -191,12 +185,6 @@ Thin3DContext *WindowsVulkanContext::CreateThin3DContext() {
}
void WindowsVulkanContext::SwapBuffers() {
g_Vulkan->EndSurfaceRenderPass();
VkClearValue clearVal[2];
memset(clearVal, 0, sizeof(clearVal));
clearVal[0].color.float32[0] = 0.5f;
g_Vulkan->BeginSurfaceRenderPass(clearVal);
}
void WindowsVulkanContext::Resize() {

1
Windows/WindowsHost.cpp
View file

@ -187,6 +187,7 @@ void WindowsHost::SetDebugMode(bool mode) {
}
void WindowsHost::PollControllers(InputState &input_state) {
return;
bool doPad = true;
for (auto iter = this->input.begin(); iter != this->input.end(); iter++)
{

247
ext/native/thin3d/VulkanContext.cpp
View file

@ -42,7 +42,7 @@ VulkanContext::VulkanContext(const char *app_name, uint32_t flags)
: device_(nullptr),
gfx_queue_(nullptr),
connection(nullptr),
gfx_queue_family_index_(-1),
graphics_queue_family_index_(-1),
surface(nullptr),
window(nullptr),
prepared(false),
@ -50,6 +50,7 @@ VulkanContext::VulkanContext(const char *app_name, uint32_t flags)
instance_(nullptr),
width(0),
height(0),
flags_(flags),
swapchain_format(VK_FORMAT_UNDEFINED),
swapchainImageCount(0),
swap_chain_(nullptr),
@ -58,7 +59,8 @@ VulkanContext::VulkanContext(const char *app_name, uint32_t flags)
cmdInitActive_(false),
dbgCreateMsgCallback(nullptr),
dbgDestroyMsgCallback(nullptr),
queue_count(0)
queue_count(0),
curFrame_(0)
{
// List extensions to try to enable.
instance_extension_names.push_back(VK_KHR_SURFACE_EXTENSION_NAME);
@ -117,14 +119,14 @@ VulkanContext::VulkanContext(const char *app_name, uint32_t flags)
res = vkEnumeratePhysicalDevices(instance_, &gpu_count, physical_devices_.data());
assert(!res);
init_global_layer_properties();
init_global_extension_properties();
InitGlobalLayerProperties();
InitGlobalExtensionProperties();
if (!CheckLayers(instance_layer_properties, instance_layer_names)) {
exit(1);
}
init_device_layer_properties();
InitDeviceLayerProperties();
if (!CheckLayers(device_layer_properties, device_layer_names)) {
exit(1);
}
@ -134,7 +136,7 @@ VulkanContext::~VulkanContext() {
vkDestroyInstance(instance_, NULL);
}
void vk_transition_to_present(VkCommandBuffer cmd, VkImage image) {
void TransitionToPresent(VkCommandBuffer cmd, VkImage image) {
VkImageMemoryBarrier prePresentBarrier = {};
prePresentBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
prePresentBarrier.pNext = NULL;
@ -154,45 +156,39 @@ void vk_transition_to_present(VkCommandBuffer cmd, VkImage image) {
0, 0, nullptr, 0, nullptr, 1, &prePresentBarrier);
}
void vk_transition_from_present(VkCommandBuffer cmd, VkImage image) {
VkImageMemoryBarrier postPresentBarrier = {};
postPresentBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
postPresentBarrier.pNext = NULL;
postPresentBarrier.srcAccessMask = 0;
postPresentBarrier.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
postPresentBarrier.oldLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
postPresentBarrier.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
postPresentBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
postPresentBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
postPresentBarrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
postPresentBarrier.subresourceRange.baseMipLevel = 0;
postPresentBarrier.subresourceRange.levelCount = 1;
postPresentBarrier.subresourceRange.baseArrayLayer = 0;
postPresentBarrier.subresourceRange.layerCount = 1;
postPresentBarrier.image = image;
void TransitionFromPresent(VkCommandBuffer cmd, VkImage image) {
VkImageMemoryBarrier prePresentBarrier = {};
prePresentBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
prePresentBarrier.pNext = NULL;
prePresentBarrier.srcAccessMask = 0;
prePresentBarrier.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
prePresentBarrier.oldLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
prePresentBarrier.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
prePresentBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
prePresentBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
prePresentBarrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
prePresentBarrier.subresourceRange.baseMipLevel = 0;
prePresentBarrier.subresourceRange.levelCount = 1;
prePresentBarrier.subresourceRange.baseArrayLayer = 0;
prePresentBarrier.subresourceRange.layerCount = 1;
prePresentBarrier.image = image;
vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
0, 0, nullptr, 0, nullptr, 1, &postPresentBarrier);
0, 0, nullptr, 0, nullptr, 1, &prePresentBarrier);
}
VkCommandBuffer VulkanContext::BeginSurfaceRenderPass(VkClearValue clear_values[2]) {
VkSemaphoreCreateInfo acquireSemaphoreCreateInfo;
acquireSemaphoreCreateInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
acquireSemaphoreCreateInfo.pNext = NULL;
acquireSemaphoreCreateInfo.flags = 0;
FrameData *frame = &frame_[curFrame_];
VkResult res = vkCreateSemaphore(device_,
&acquireSemaphoreCreateInfo,
NULL,
&acquireSemaphore);
assert(res == VK_SUCCESS);
// Make sure the command buffer from the frame before the previous has been fully executed.
WaitAndResetFence(frame->fence);
// Get the index of the next available swapchain image, and a semaphore to block on.
res = fpAcquireNextImageKHR(device_, swap_chain_,
// Get the index of the next available swapchain image, and a semaphore to block command buffer execution on.
// Now, I wonder if we should do this early in the frame or late?
VkResult res = fpAcquireNextImageKHR(device_, swap_chain_,
UINT64_MAX,
acquireSemaphore,
NULL,
&current_buffer);
// TODO: Deal with the VK_SUBOPTIMAL_KHR and VK_ERROR_OUT_OF_DATE_KHR
// return codes
assert(res == VK_SUCCESS);
@ -202,9 +198,9 @@ VkCommandBuffer VulkanContext::BeginSurfaceRenderPass(VkClearValue clear_values[
begin.pNext = NULL;
begin.flags = 0;
begin.pInheritanceInfo = nullptr;
vkBeginCommandBuffer(cmd_, &begin);
res = vkBeginCommandBuffer(cmd_, &begin);
vk_transition_from_present(cmd_, swapChainBuffers[current_buffer].image);
TransitionFromPresent(frame->cmdBuf, swapChainBuffers[current_buffer].image);
VkRenderPassBeginInfo rp_begin;
rp_begin.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
@ -218,8 +214,8 @@ VkCommandBuffer VulkanContext::BeginSurfaceRenderPass(VkClearValue clear_values[
rp_begin.clearValueCount = 2;
rp_begin.pClearValues = clear_values;
vkCmdBeginRenderPass(cmd_, &rp_begin, VK_SUBPASS_CONTENTS_INLINE);
return cmd_;
vkCmdBeginRenderPass(frame->cmdBuf, &rp_begin, VK_SUBPASS_CONTENTS_INLINE);
return frame->cmdBuf;
}
void VulkanContext::WaitUntilQueueIdle() {
@ -274,6 +270,47 @@ void vk_submit_sync(VkDevice device, VkSemaphore waitForSemaphore, VkQueue queue
vkDestroyFence(device, drawFence, NULL);
}
void VulkanContext::EndSurfaceRenderPass() {
FrameData *frame = &frame_[curFrame_];
vkCmdEndRenderPass(frame->cmdBuf);
TransitionToPresent(frame->cmdBuf, swapChainBuffers[current_buffer].image);
VkResult res = vkEndCommandBuffer(frame->cmdBuf);
assert(res == VK_SUCCESS);
VkSubmitInfo submit_info = {};
submit_info.pNext = NULL;
submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submit_info.waitSemaphoreCount = 1;
submit_info.pWaitSemaphores = &acquireSemaphore;
submit_info.commandBufferCount = 1;
submit_info.pCommandBuffers = &frame->cmdBuf;
submit_info.signalSemaphoreCount = 0;
submit_info.pSignalSemaphores = NULL;
res = vkQueueSubmit(gfx_queue_, 1, &submit_info, frame->fence);
assert(res == VK_SUCCESS);
// At this point we are certain that acquireSemaphore is of no further use and can be destroyed.
VkPresentInfoKHR present;
present.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
present.pNext = NULL;
present.swapchainCount = 1;
present.pSwapchains = &swap_chain_;
present.pImageIndices = &current_buffer;
present.pWaitSemaphores = NULL;
present.waitSemaphoreCount = 0;
present.pResults = NULL;
res = fpQueuePresentKHR(gfx_queue_, &present);
// TODO: Deal with the VK_SUBOPTIMAL_WSI and VK_ERROR_OUT_OF_DATE_WSI
// return codes
assert(!res);
curFrame_ ^= 1;
}
void VulkanContext::BeginInitCommandBuffer() {
assert(!cmdInitActive_);
VulkanBeginCommandBuffer(cmd_);
@ -300,9 +337,33 @@ void VulkanContext::InitObjects(HINSTANCE hInstance, HWND hWnd, bool depthPresen
InitSurfaceRenderPass(depthPresent, true);
InitFramebuffers(depthPresent);
SubmitInitCommandBufferSync();
// Create frame data
VkCommandBufferAllocateInfo cmd = {};
cmd.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
cmd.pNext = NULL;
cmd.commandPool = cmd_pool_;
cmd.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
cmd.commandBufferCount = 2;
VkCommandBuffer cmdBuf[2];
VkResult res = vkAllocateCommandBuffers(device_, &cmd, cmdBuf);
assert(res == VK_SUCCESS);
frame_[0].cmdBuf = cmdBuf[0];
frame_[0].fence = CreateFence(true); // So it can be instantly waited on
frame_[1].cmdBuf = cmdBuf[1];
frame_[1].fence = CreateFence(true);
}
void VulkanContext::DestroyObjects() {
VkCommandBuffer cmdBuf[2] = { frame_[0].cmdBuf, frame_[1].cmdBuf };
vkFreeCommandBuffers(device_, cmd_pool_, 2, cmdBuf);
vkDestroyFence(device_, frame_[0].fence, nullptr);
vkDestroyFence(device_, frame_[1].fence, nullptr);
DestroyFramebuffers();
DestroySurfaceRenderPass();
DestroyDepthStencilBuffer();
@ -311,39 +372,7 @@ void VulkanContext::DestroyObjects() {
DestroyCommandPool();
}
void VulkanContext::EndSurfaceRenderPass() {
vkCmdEndRenderPass(cmd_);
vk_transition_to_present(cmd_, swapChainBuffers[current_buffer].image);
VkResult res = vkEndCommandBuffer(cmd_);
assert(res == VK_SUCCESS);
/* Make sure command buffer is finished before presenting */
vk_submit_sync(device_, acquireSemaphore, gfx_queue_, cmd_);
// At this point we are certain that acquireSemaphore is of no further use and can be destroyed.
/* Now present the image in the window */
VkPresentInfoKHR present;
present.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
present.pNext = NULL;
present.swapchainCount = 1;
present.pSwapchains = &swap_chain_;
present.pImageIndices = &current_buffer;
present.pWaitSemaphores = NULL;
present.waitSemaphoreCount = 0;
present.pResults = NULL;
res = fpQueuePresentKHR(gfx_queue_, &present);
// TODO: Deal with the VK_SUBOPTIMAL_WSI and VK_ERROR_OUT_OF_DATE_WSI
// return codes
assert(!res);
vkDestroySemaphore(device_, acquireSemaphore, NULL);
}
VkResult VulkanContext::init_layer_extension_properties(layer_properties &layer_props) {
VkResult VulkanContext::InitLayerExtensionProperties(layer_properties &layer_props) {
VkExtensionProperties *instance_extensions;
uint32_t instance_extension_count;
VkResult res;
@ -371,7 +400,7 @@ VkResult VulkanContext::init_layer_extension_properties(layer_properties &layer_
return res;
}
VkResult VulkanContext::init_global_extension_properties() {
VkResult VulkanContext::InitGlobalExtensionProperties() {
uint32_t instance_extension_count;
VkResult res;
@ -394,7 +423,7 @@ VkResult VulkanContext::init_global_extension_properties() {
return res;
}
VkResult VulkanContext::init_global_layer_properties() {
VkResult VulkanContext::InitGlobalLayerProperties() {
uint32_t instance_layer_count;
VkLayerProperties *vk_props = NULL;
VkResult res;
@ -429,7 +458,7 @@ VkResult VulkanContext::init_global_layer_properties() {
for (uint32_t i = 0; i < instance_layer_count; i++) {
layer_properties layer_props;
layer_props.properties = vk_props[i];
res = init_layer_extension_properties(layer_props);
res = InitLayerExtensionProperties(layer_props);
if (res)
return res;
instance_layer_properties.push_back(layer_props);
@ -439,7 +468,7 @@ VkResult VulkanContext::init_global_layer_properties() {
return res;
}
VkResult VulkanContext::init_device_extension_properties(layer_properties &layer_props) {
VkResult VulkanContext::InitDeviceExtensionProperties(layer_properties &layer_props) {
VkExtensionProperties *device_extensions;
uint32_t device_extension_count;
VkResult res;
@ -469,10 +498,7 @@ VkResult VulkanContext::init_device_extension_properties(layer_properties &layer
return res;
}
/*
* TODO: function description here
*/
VkResult VulkanContext::init_device_layer_properties() {
VkResult VulkanContext::InitDeviceLayerProperties() {
uint32_t device_layer_count;
VkLayerProperties *vk_props = NULL;
VkResult res;
@ -509,7 +535,7 @@ VkResult VulkanContext::init_device_layer_properties() {
for (uint32_t i = 0; i < device_layer_count; i++) {
layer_properties layer_props;
layer_props.properties = vk_props[i];
res = init_device_extension_properties(layer_props);
res = InitDeviceExtensionProperties(layer_props);
if (res)
return res;
device_layer_properties.push_back(layer_props);
@ -607,7 +633,6 @@ VkResult VulkanContext::InitDebugMsgCallback(PFN_vkDebugReportCallbackEXT dbgFun
std::cout << "GetInstanceProcAddr: Unable to find vkDbgCreateMsgCallback function." << std::endl;
return VK_ERROR_INITIALIZATION_FAILED;
}
std::cout << "Got dbgCreateMsgCallback function\n";
dbgDestroyMsgCallback = (PFN_vkDestroyDebugReportCallbackEXT)vkGetInstanceProcAddr(instance_, "vkDestroyDebugReportCallbackEXT");
if (!dbgDestroyMsgCallback) {
@ -624,7 +649,6 @@ VkResult VulkanContext::InitDebugMsgCallback(PFN_vkDebugReportCallbackEXT dbgFun
res = dbgCreateMsgCallback(instance_, &cb, nullptr, &msg_callback);
switch (res) {
case VK_SUCCESS:
puts("Successfully created message callback object\n");
msg_callbacks.push_back(msg_callback);
break;
case VK_ERROR_OUT_OF_HOST_MEMORY:
@ -805,7 +829,7 @@ void VulkanContext::InitSurfaceAndQueue(HINSTANCE conn, HWND wnd) {
exit(-1);
}
gfx_queue_family_index_ = graphicsQueueNodeIndex;
graphics_queue_family_index_ = graphicsQueueNodeIndex;
// Get the list of VkFormats that are supported:
uint32_t formatCount;
@ -829,7 +853,18 @@ void VulkanContext::InitSurfaceAndQueue(HINSTANCE conn, HWND wnd) {
}
delete[] surfFormats;
vkGetDeviceQueue(device_, gfx_queue_family_index_, 0, &gfx_queue_);
vkGetDeviceQueue(device_, graphics_queue_family_index_, 0, &gfx_queue_);
VkSemaphoreCreateInfo acquireSemaphoreCreateInfo;
acquireSemaphoreCreateInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
acquireSemaphoreCreateInfo.pNext = NULL;
acquireSemaphoreCreateInfo.flags = 0;
res = vkCreateSemaphore(device_,
&acquireSemaphoreCreateInfo,
NULL,
&acquireSemaphore);
assert(res == VK_SUCCESS);
}
void VulkanContext::InitSwapchain() {
@ -874,13 +909,13 @@ void VulkanContext::InitSwapchain() {
// always available.
VkPresentModeKHR swapchainPresentMode = VK_PRESENT_MODE_FIFO_KHR;
for (size_t i = 0; i < presentModeCount; i++) {
if (presentModes[i] == VK_PRESENT_MODE_MAILBOX_KHR) {
if ((flags_ & VULKAN_FLAG_PRESENT_MAILBOX) && presentModes[i] == VK_PRESENT_MODE_MAILBOX_KHR) {
swapchainPresentMode = VK_PRESENT_MODE_MAILBOX_KHR;
break;
}
if ((swapchainPresentMode != VK_PRESENT_MODE_MAILBOX_KHR) &&
(presentModes[i] == VK_PRESENT_MODE_IMMEDIATE_KHR)) {
if ((flags_ & VULKAN_FLAG_PRESENT_IMMEDIATE) && presentModes[i] == VK_PRESENT_MODE_IMMEDIATE_KHR) {
swapchainPresentMode = VK_PRESENT_MODE_IMMEDIATE_KHR;
break;
}
}
@ -1063,7 +1098,7 @@ void VulkanContext::InitCommandPool() {
VkCommandPoolCreateInfo cmd_pool_info = {};
cmd_pool_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
cmd_pool_info.pNext = NULL;
cmd_pool_info.queueFamilyIndex = gfx_queue_family_index_;
cmd_pool_info.queueFamilyIndex = graphics_queue_family_index_;
cmd_pool_info.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT | VK_COMMAND_POOL_CREATE_TRANSIENT_BIT;
res = vkCreateCommandPool(device_, &cmd_pool_info, NULL, &cmd_pool_);
@ -1295,7 +1330,7 @@ void VulkanTexture::Unlock(VulkanContext *vulkan) {
// that could be avoided with smarter code - for example we can check the fence the next
// time the texture is used and discard the staging image then.
VkFence fence = vulkan->CreateFence();
VkFence fence = vulkan->CreateFence(false);
res = vkQueueSubmit(vulkan->gfx_queue_, 1, submit_info, fence);
assert(res == VK_SUCCESS);
@ -1307,7 +1342,7 @@ void VulkanTexture::Unlock(VulkanContext *vulkan) {
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
imageLayout);
vulkan->WaitForFence(fence);
vulkan->WaitAndResetFence(fence);
/* Release the resources for the staging image */
vkFreeMemory(vulkan->device_, mappableMemory, NULL);
@ -1346,18 +1381,21 @@ void VulkanTexture::Destroy(VulkanContext *vulkan) {
mem = NULL;
}
VkFence VulkanContext::CreateFence() {
VkFence VulkanContext::CreateFence(bool presignalled) {
VkFence fence;
VkFenceCreateInfo fenceInfo;
fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
fenceInfo.pNext = NULL;
fenceInfo.flags = 0;
fenceInfo.flags = presignalled ? VK_FENCE_CREATE_SIGNALED_BIT : 0;
vkCreateFence(device_, &fenceInfo, NULL, &fence);
return fence;
}
void VulkanContext::WaitForFence(VkFence fence) {
vkWaitForFences(device_, 1, &fence, true, 0);
void VulkanContext::WaitAndResetFence(VkFence fence) {
VkResult res = vkWaitForFences(device_, 1, &fence, true, UINT64_MAX);
assert(!res);
res = vkResetFences(device_, 1, &fence);
assert(!res);
}
void VulkanContext::DestroyCommandBuffer() {
@ -1387,6 +1425,7 @@ void VulkanContext::DestroySwapChain() {
fpDestroySwapchainKHR(device_, swap_chain_, NULL);
swap_chain_ = nullptr;
swapChainBuffers.clear();
vkDestroySemaphore(device_, acquireSemaphore, NULL);
}
void VulkanContext::DestroyFramebuffers() {
@ -1426,7 +1465,6 @@ void TransitionImageLayout(
image_memory_barrier.subresourceRange.baseMipLevel = 0;
image_memory_barrier.subresourceRange.levelCount = 1;
image_memory_barrier.subresourceRange.layerCount = 1;
if (old_image_layout == VK_IMAGE_LAYOUT_PRESENT_SRC_KHR) {
image_memory_barrier.srcAccessMask = VK_ACCESS_MEMORY_READ_BIT;
}
@ -1442,7 +1480,9 @@ void TransitionImageLayout(
if (new_image_layout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) {
/* Make sure any Copy or CPU writes to image are flushed */
if (old_image_layout != VK_IMAGE_LAYOUT_UNDEFINED) {
image_memory_barrier.srcAccessMask = VK_ACCESS_HOST_WRITE_BIT | VK_ACCESS_TRANSFER_WRITE_BIT;
}
image_memory_barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
}
@ -1580,13 +1620,11 @@ EShLanguage FindLanguage(const VkShaderStageFlagBits shader_type) {
}
}
//
// Compile a given string containing GLSL into SPV for use by VK
// Return value of false means an error was encountered.
//
bool GLSLtoSPV(const VkShaderStageFlagBits shader_type,
const char *pshader,
std::vector<unsigned int> &spirv) {
std::vector<unsigned int> &spirv, std::string *errorMessage) {
glslang::TProgram& program = *new glslang::TProgram;
const char *shaderStrings[1];
@ -1605,6 +1643,10 @@ bool GLSLtoSPV(const VkShaderStageFlagBits shader_type,
if (!shader->parse(&Resources, 100, false, messages)) {
puts(shader->getInfoLog());
puts(shader->getInfoDebugLog());
if (errorMessage) {
*errorMessage = shader->getInfoLog();
(*errorMessage) += shader->getInfoDebugLog();
}
return false; // something didn't work
}
@ -1617,11 +1659,15 @@ bool GLSLtoSPV(const VkShaderStageFlagBits shader_type,
if (!program.link(messages)) {
puts(shader->getInfoLog());
puts(shader->getInfoDebugLog());
if (errorMessage) {
*errorMessage = shader->getInfoLog();
(*errorMessage) += shader->getInfoDebugLog();
}
return false;
}
// Can't fail, parsing worked, "linking" worked.
glslang::GlslangToSpv(*program.getIntermediate(stage), spirv);
return true;
}
@ -1663,5 +1709,4 @@ const char *VulkanResultToString(VkResult res) {
void VulkanAssertImpl(VkResult check, const char *function, const char *file, int line) {
const char *error = "(none)";
}

49
ext/native/thin3d/VulkanContext.h
View file

@ -54,6 +54,8 @@
enum {
VULKAN_FLAG_VALIDATE = 1,
VULKAN_FLAG_PRESENT_MAILBOX = 2,
VULKAN_FLAG_PRESENT_IMMEDIATE = 4,
};
// A layer can expose extensions, keep track of those extensions here.
@ -103,8 +105,8 @@ public:
void WaitUntilQueueIdle();
// Utility functions for shorter code
VkFence CreateFence();
void WaitForFence(VkFence fence);
VkFence CreateFence(bool presignalled);
void WaitAndResetFence(VkFence fence);
int GetWidth() { return width; }
int GetHeight() { return height; }
@ -120,32 +122,33 @@ public:
VkResult InitDebugMsgCallback(PFN_vkDebugReportCallbackEXT dbgFunc, int bits, void *userdata = nullptr);
void DestroyDebugMsgCallback();
VkSemaphore acquireSemaphore;
VkRenderPass GetSurfaceRenderPass() {
VkRenderPass GetSurfaceRenderPass() const {
return surface_render_pass_;
}
VkPhysicalDevice GetPhysicalDevice() {
VkPhysicalDevice GetPhysicalDevice() const {
return physical_devices_[0];
}
VkQueue GetGraphicsQueue() {
VkQueue GetGraphicsQueue() const {
return gfx_queue_;
}
int GetGraphicsQueueFamilyIndex() {
return gfx_queue_family_index_;
int GetGraphicsQueueFamilyIndex() const {
return graphics_queue_family_index_;
}
VkResult init_global_extension_properties();
VkResult init_layer_extension_properties(layer_properties &layer_props);
VkResult init_global_layer_properties();
VkResult InitGlobalExtensionProperties();
VkResult InitLayerExtensionProperties(layer_properties &layer_props);
VkResult init_device_extension_properties(layer_properties &layer_props);
VkResult init_device_layer_properties();
VkResult InitGlobalLayerProperties();
VkResult InitDeviceExtensionProperties(layer_properties &layer_props);
VkResult InitDeviceLayerProperties();
VkSemaphore acquireSemaphore;
#ifdef _WIN32
#define APP_NAME_STR_LEN 80
@ -182,7 +185,7 @@ public:
std::vector<VkExtensionProperties> device_extension_properties;
std::vector<VkPhysicalDevice> physical_devices_;
uint32_t gfx_queue_family_index_;
uint32_t graphics_queue_family_index_;
VkPhysicalDeviceProperties gpu_props;
std::vector<VkQueueFamilyProperties> queue_props;
VkPhysicalDeviceMemoryProperties memory_properties;
@ -195,12 +198,21 @@ private:
// Swap chain
int width, height;
int flags_;
VkFormat swapchain_format;
std::vector<VkFramebuffer> framebuffers_;
uint32_t swapchainImageCount;
VkSwapchainKHR swap_chain_;
std::vector<swap_chain_buffer> swapChainBuffers;
// Manages flipping command buffers for the backbuffer render pass.
// It is recommended to do the same for other rendering passes.
struct FrameData {
VkFence fence;
VkCommandBuffer cmdBuf;
};
FrameData frame_[2];
int curFrame_;
// Simple loader for the WSI extension.
PFN_vkGetPhysicalDeviceSurfaceSupportKHR fpGetPhysicalDeviceSurfaceSupportKHR;
@ -265,7 +277,7 @@ void vk_submit_sync(VkDevice device, VkSemaphore waitForSemaphore, VkQueue queue
void init_glslang();
void finalize_glslang();
bool GLSLtoSPV(const VkShaderStageFlagBits shader_type, const char *pshader, std::vector<unsigned int> &spirv);
bool GLSLtoSPV(const VkShaderStageFlagBits shader_type, const char *pshader, std::vector<uint32_t> &spirv, std::string *errorMessage = nullptr);
void TransitionImageLayout(
VkCommandBuffer cmd,
@ -274,10 +286,5 @@ void TransitionImageLayout(
VkImageLayout old_image_layout,
VkImageLayout new_image_layout);
void VulkanAssertImpl(VkResult check, const char *function, const char *file, int line);
// DO NOT call vulkan functions within this! Instead, store the result in a variable and check that.
#define VulkanAssert(x) if ((x) != VK_SUCCESS) VulkanAssertImpl((x), __FUNCTION__, __FILE__, __LINE__);
#endif // UTIL_INIT

6
ext/native/thin3d/thin3d.cpp
View file

@ -34,7 +34,7 @@ static const char * const vulkan_fsTexCol =
"layout(location = 0) in vec4 oColor0;\n"
"layout(location = 1) in vec2 oTexCoord0;\n"
"layout(location = 0) out vec4 fragColor0\n;"
"layout(binding = 2) uniform sampler2D Sampler0;\n"
"layout(set = 0, binding = 1) uniform sampler2D Sampler0;\n"
"void main() { fragColor0 = texture(Sampler0, oTexCoord0) * oColor0; }\n";
static const char * const glsl_fsCol =
@ -87,7 +87,7 @@ static const char * const vulkan_vsCol =
"#version 140\n"
"#extension GL_ARB_separate_shader_objects : enable\n"
"#extension GL_ARB_shading_language_420pack : enable\n"
"layout (std140, binding = 1) uniform bufferVals {\n"
"layout (std140, set = 0, binding = 0) uniform bufferVals {\n"
" mat4 WorldViewProj;\n"
"} myBufferVals;\n"
"layout (location = 0) in vec4 pos;\n"
@ -128,7 +128,7 @@ static const char * const vulkan_vsTexCol =
"#version 140\n"
"#extension GL_ARB_separate_shader_objects : enable\n"
"#extension GL_ARB_shading_language_420pack : enable\n"
"layout (std140, binding = 1) uniform bufferVals {\n"
"layout (std140, set = 0, binding = 0) uniform bufferVals {\n"
" mat4 WorldViewProj;\n"
"} myBufferVals;\n"
"layout (location = 0) in vec4 pos;\n"

175
ext/native/thin3d/thin3d_vulkan.cpp
View file

@ -33,9 +33,10 @@
#include "thin3d/VulkanContext.h"
// We use a simple descriptor set for all rendering: 1 sampler, 1 texture, 1 UBO binding point.
// binding 0 - vertex data
// binding 1 - uniform data
// binding 2 - sampler
// binding 0 - uniform data
// binding 1 - sampler
//
// Vertex data lives in a separate namespace (location = 0, 1, etc)
#define VK_PROTOTYPES
#include "ext/vulkan/vulkan.h"
@ -383,6 +384,10 @@ public:
void SetVector(const char *name, float *value, int n) override;
void SetMatrix4x4(const char *name, const float value[16]) override;
int GetUBOSize() const {
return uboSize_;
}
Thin3DVKShader *vshader;
Thin3DVKShader *fshader;
@ -426,6 +431,7 @@ struct DescriptorSetKey {
if (texture_ < other.texture_) return true; else if (texture_ > other.texture_) return false;
if (vertexFormat_ < other.vertexFormat_) return true; else if (vertexFormat_ > other.vertexFormat_) return false;
if (sampler_ < other.sampler_) return true; else if (sampler_ > other.sampler_) return false;
if (frame < other.frame) return true; else if (frame > other.frame) return false;
return false;
}
};
@ -507,7 +513,6 @@ private:
void DirtyDynamicState();
void BeginInitCommands();
void EndInitCommands();
VulkanContext *vulkan_;
@ -527,17 +532,13 @@ private:
std::map<DescriptorSetKey, VkDescriptorSet> descSets_;
VkDescriptorPool descriptorPool_;
VkDescriptorSet descriptorSet_;
VkDescriptorSetLayout descriptorSetLayout_;
VkPipelineLayout pipelineLayout_;
VkPipelineCache pipelineCache_;
VkCommandPool cmdPool_;
VkInstance instance_;
VkPhysicalDevice physicalDevice_;
VkDevice device_;
VkQueue queue_;
VkRenderPass renderPass_;
int queueFamilyIndex_;
// State to apply at the next draw call if viewportDirty or scissorDirty are true.
@ -557,20 +558,11 @@ private:
VkCommandBuffer initCmd_;
bool hasInitCommands_;
VkFence initFence_;
bool pendingInitFence_;
// TODO: Transpose this into a struct FrameObject[2].
// We write to one, while we wait for the draws from the other to complete.
// Then, at the end of the frame, they switch roles.
// cmdBuf_ for commands, pushBuffer_ for data. cmd_ will often refer to push_.
VkCommandBuffer cmdBuffer_[2];
VkCommandBuffer cmd_; // The current one
VkFence cmdFences_[2];
VkFence cmdFence_;
VulkanPushBuffer *pushBuffer_[2];
int frameNum_;
VulkanPushBuffer *push_;
@ -674,7 +666,6 @@ private:
VulkanImage staging_;
VkImageView view_;
int32_t width_, height_, depth_;
int mipLevels_;
T3DImageFormat format_;
@ -682,14 +673,22 @@ private:
};
Thin3DVKContext::Thin3DVKContext(VulkanContext *vulkan)
: viewportDirty_(false), scissorDirty_(false), vulkan_(vulkan) {
: viewportDirty_(false), scissorDirty_(false), vulkan_(vulkan), frameNum_(0) {
device_ = vulkan->GetDevice();
queue_ = vulkan->GetGraphicsQueue();
queueFamilyIndex_ = vulkan->GetGraphicsQueueFamilyIndex();
noScissor_.offset.x = 0;
noScissor_.offset.y = 0;
noScissor_.extent.width = pixel_xres;
noScissor_.extent.height = pixel_yres;
scissor_ = noScissor_;
viewport_.x = 0;
viewport_.y = 0;
viewport_.width = pixel_xres;
viewport_.height = pixel_yres;
viewport_.minDepth = 0.0f;
viewport_.maxDepth = 0.0f;
memset(boundTextures_, 0, sizeof(boundTextures_));
CreatePresets();
@ -703,18 +702,16 @@ Thin3DVKContext::Thin3DVKContext(VulkanContext *vulkan)
VkResult res = vkCreateCommandPool(device_, &p, nullptr, &cmdPool_);
assert(VK_SUCCESS == res);
VkDescriptorPoolSize dpTypes[3];
VkDescriptorPoolSize dpTypes[2];
dpTypes[0].descriptorCount = 200;
dpTypes[0].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
dpTypes[1].descriptorCount = 1;
dpTypes[1].descriptorCount = 2;
dpTypes[1].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC;
dpTypes[2].descriptorCount = 1;
dpTypes[2].type = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT;
VkDescriptorPoolCreateInfo dp;
dp.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
dp.pNext = nullptr;
dp.flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT; // We want to individually alloc and free descriptor sets. (do we?)
dp.flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT; // We want to individually alloc and free descriptor sets. (do we? or one per "frame"?)
dp.maxSets = 200; // One set for every texture available... sigh
dp.pPoolSizes = dpTypes;
dp.poolSizeCount = ARRAY_SIZE(dpTypes);
@ -723,31 +720,25 @@ Thin3DVKContext::Thin3DVKContext(VulkanContext *vulkan)
pushBuffer_[0] = new VulkanPushBuffer(device_, vulkan_, 1024 * 1024);
pushBuffer_[1] = new VulkanPushBuffer(device_, vulkan_, 1024 * 1024);
// binding 0 - vertex data
// binding 1 - uniform data
// binding 2 - sampler
// binding 3 - image
VkDescriptorSetLayoutBinding bindings[4];
// binding 0 - uniform data
// binding 1 - sampler
// binding 2 - image
VkDescriptorSetLayoutBinding bindings[2];
bindings[0].descriptorCount = 1;
bindings[0].pImmutableSamplers = nullptr;
bindings[0].descriptorType = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT;
bindings[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC;
bindings[0].stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
bindings[0].binding = 0;
bindings[1].descriptorCount = 1;
bindings[1].pImmutableSamplers = nullptr;
bindings[1].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC;
bindings[1].stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
bindings[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
bindings[1].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
bindings[1].binding = 1;
bindings[2].descriptorCount = 1;
bindings[2].pImmutableSamplers = nullptr;
bindings[2].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
bindings[2].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
bindings[2].binding = 2;
VkDescriptorSetLayoutCreateInfo dsl;
dsl.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
dsl.pNext = nullptr;
dsl.bindingCount = 3;
dsl.bindingCount = 2;
dsl.pBindings = bindings;
res = vkCreateDescriptorSetLayout(device_, &dsl, nullptr, &descriptorSetLayout_);
assert(VK_SUCCESS == res);
@ -768,10 +759,6 @@ Thin3DVKContext::Thin3DVKContext(VulkanContext *vulkan)
cb.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
cb.commandPool = cmdPool_;
cb.commandBufferCount = 1;
res = vkAllocateCommandBuffers(device_, &cb, &cmdBuffer_[0]);
assert(VK_SUCCESS == res);
res = vkAllocateCommandBuffers(device_, &cb, &cmdBuffer_[1]);
assert(VK_SUCCESS == res);
res = vkAllocateCommandBuffers(device_, &cb, &initCmd_);
assert(VK_SUCCESS == res);
hasInitCommands_ = false;
@ -780,16 +767,7 @@ Thin3DVKContext::Thin3DVKContext(VulkanContext *vulkan)
f.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
f.pNext = nullptr;
f.flags = 0;
res = vkCreateFence(device_, &f, nullptr, &cmdFences_[0]);
assert(VK_SUCCESS == res);
f.flags = VK_FENCE_CREATE_SIGNALED_BIT;
res = vkCreateFence(device_, &f, nullptr, &cmdFences_[1]);
assert(VK_SUCCESS == res);
// Create as already signalled, so we can wait for it the first time.
res = vkCreateFence(device_, &f, nullptr, &initFence_);
assert(VK_SUCCESS == res);
pendingInitFence_ = false;
vkCreateFence(device_, &f, nullptr, &initFence_);
VkPipelineCacheCreateInfo pc;
pc.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
@ -799,18 +777,12 @@ Thin3DVKContext::Thin3DVKContext(VulkanContext *vulkan)
pc.flags = 0;
res = vkCreatePipelineCache(device_, &pc, nullptr, &pipelineCache_);
assert(VK_SUCCESS == res);
push_ = pushBuffer_[0];
cmd_ = cmdBuffer_[0];
cmdFence_ = cmdFences_[0];
}
Thin3DVKContext::~Thin3DVKContext() {
for (auto x : pipelines_) {
vkDestroyPipeline(device_, x.second, nullptr);
}
vkFreeCommandBuffers(device_, cmdPool_, 2, cmdBuffer_);
vkFreeCommandBuffers(device_, cmdPool_, 1, &cmd_);
vkDestroyCommandPool(device_, cmdPool_, nullptr);
// This also destroys all descriptor sets.
vkDestroyDescriptorPool(device_, descriptorPool_, nullptr);
@ -820,24 +792,28 @@ Thin3DVKContext::~Thin3DVKContext() {
}
void Thin3DVKContext::Begin(bool clear, uint32_t colorval, float depthVal, int stencilVal) {
VkClearValue clearVal[2];
VkClearValue clearVal[2] = {};
Uint8x4ToFloat4(colorval, clearVal[0].color.float32);
if (frameNum_ & 1)
clearVal[0].color.float32[2] = 1.0f;
clearVal[1].depthStencil.depth = depthVal;
clearVal[1].depthStencil.stencil = stencilVal;
vulkan_->BeginSurfaceRenderPass(clearVal);
// Make sure we don't stomp over the old command buffer.
vkWaitForFences(device_, 1, &cmdFence_, true, 0);
cmd_ = vulkan_->BeginSurfaceRenderPass(clearVal);
push_ = pushBuffer_[frameNum_ & 1];
// OK, we now know that nothing is reading from this frame's data pushbuffer,
// and that the command buffer can be safely reset and reused. So let's do that.
push_->Begin(device_);
scissorDirty_ = true;
viewportDirty_ = true;
}
void Thin3DVKContext::BeginInitCommands() {
assert(!hasInitCommands_);
// Before we can begin, we must be sure that the command buffer is no longer in use, as we only have a single one for init
// tasks (for now).
VkCommandBufferBeginInfo begin;
begin.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
begin.pNext = nullptr;
@ -848,49 +824,34 @@ void Thin3DVKContext::BeginInitCommands() {
hasInitCommands_ = true;
}
void Thin3DVKContext::EndInitCommands() {
VkResult res = vkEndCommandBuffer(initCmd_);
assert(VK_SUCCESS == res);
}
void Thin3DVKContext::End() {
// Stop collecting data in the frame data buffer.
push_->End(device_);
vkCmdEndRenderPass(cmd_);
VkResult endRes = vkEndCommandBuffer(cmd_);
// IF something needs to be uploaded etc, sneak it in before we actually run the main command buffer.
if (hasInitCommands_) {
assert(!pendingInitFence_);
EndInitCommands();
VkResult res = vkEndCommandBuffer(initCmd_);
assert(VK_SUCCESS == res);
// Run the texture uploads etc _before_ we execute the ordinary command buffer
pendingInitFence_ = true;
VkSubmitInfo submit = {};
submit.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submit.pCommandBuffers = &initCmd_;
submit.commandBufferCount = 1;
VkResult res = vkQueueSubmit(queue_, 1, &submit, initFence_);
res = vkQueueSubmit(queue_, 1, &submit, initFence_);
assert(VK_SUCCESS == res);
// Before we can begin, we must be sure that the command buffer is no longer in use, as we only have a single one for init
// tasks (for now).
vulkan_->WaitAndResetFence(initFence_);
hasInitCommands_ = false;
// Init cmd buffer is again available for writing.
}
if (VK_SUCCESS != endRes) {
ELOG("vkEndCommandBuffer failed");
vkResetCommandBuffer(cmd_, 0);
} else {
VkSubmitInfo submit = {};
submit.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submit.pCommandBuffers = &cmd_;
submit.commandBufferCount = 1;
VkResult res = vkQueueSubmit(queue_, 1, &submit, cmdFence_);
assert(VK_SUCCESS == res);
}
vulkan_->EndSurfaceRenderPass();
frameNum_++;
push_ = pushBuffer_[frameNum_ & 1];
cmd_ = cmdBuffer_[frameNum_ & 1];
cmdFence_ = cmdFences_[frameNum_ & 1];
cmd_ = nullptr; // will be set on the next begin
push_ = nullptr;
DirtyDynamicState();
}
@ -917,14 +878,13 @@ VkDescriptorSet Thin3DVKContext::GetOrCreateDescriptorSet() {
VkResult res = vkAllocateDescriptorSets(device_, &alloc, &descSet);
assert(VK_SUCCESS == res);
// bindings[0].descriptorType = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT;
// bindings[1].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC;
// bindings[2].descriptorType = VK_DESCRIPTOR_TYPE_SAMPLER;
// bindings[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC;
// bindings[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
VkDescriptorBufferInfo bufferDesc;
bufferDesc.buffer = push_->GetVkBuffer();
bufferDesc.offset = 0;
bufferDesc.range = 16 * 4;
bufferDesc.range = curShaderSet_->GetUBOSize();
VkDescriptorImageInfo imageDesc;
imageDesc.imageView = boundTextures_[0]->GetImageView();
@ -937,7 +897,7 @@ VkDescriptorSet Thin3DVKContext::GetOrCreateDescriptorSet() {
writes[0].pNext = nullptr;
writes[0].dstSet = descSet;
writes[0].dstArrayElement = 0;
writes[0].dstBinding = 1;
writes[0].dstBinding = 0;
writes[0].pBufferInfo = &bufferDesc;
writes[0].descriptorCount = 1;
writes[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC;
@ -946,7 +906,7 @@ VkDescriptorSet Thin3DVKContext::GetOrCreateDescriptorSet() {
writes[1].pNext = nullptr;
writes[1].dstSet = descSet;
writes[1].dstArrayElement = 0;
writes[1].dstBinding = 2;
writes[1].dstBinding = 1;
writes[1].pImageInfo = &imageDesc;
writes[1].descriptorCount = 1;
writes[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
@ -1062,7 +1022,7 @@ VkPipeline Thin3DVKContext::GetOrCreatePipeline() {
info.pViewportState = &vs; // Must set viewport and scissor counts even if we set the actual state dynamically.
info.layout = pipelineLayout_;
info.subpass = 0;
info.renderPass = renderPass_;
info.renderPass = vulkan_->GetSurfaceRenderPass();
// OK, need to create a new pipeline.
VkPipeline pipeline;
@ -1136,8 +1096,8 @@ void Thin3DVKTexture::SetImageData(int x, int y, int z, int width, int height, i
// So we need to do a staging copy. We upload the data to the staging buffer immediately, then we actually do the final copy once it's used the first time
// as we need a command buffer and the architecture of Thin3D doesn't really work the way we want..
if (!image_.IsValid()) {
staging_.Create2D(vulkan_, vulkanFormat, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, width, height);
image_.Create2D(vulkan_, vulkanFormat, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, (VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT), width, height);
staging_.Create2D(vulkan_, vulkanFormat, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, VK_IMAGE_TILING_LINEAR, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, width, height);
image_.Create2D(vulkan_, vulkanFormat, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, VK_IMAGE_TILING_OPTIMAL, (VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT), width, height);
}
VkImageViewCreateInfo iv;
@ -1162,6 +1122,8 @@ void Thin3DVKTexture::SetImageData(int x, int y, int z, int width, int height, i
// TODO: Support setting only parts of the image efficiently.
staging_.SetImageData2D(vulkan_->GetDevice(), data, width, height, stride);
state_ = TextureState::STAGED;
width_ = width;
height_ = height;
}
void Thin3DVKTexture::Finalize(int zim_flags) {
@ -1173,7 +1135,10 @@ bool Thin3DVKTexture::NeedsUpload() {
}
void Thin3DVKTexture::Upload(VkCommandBuffer cmd) {
if (state_ == TextureState::STAGED) {
if (state_ != TextureState::STAGED) {
return;
}
// Before we can texture, we need to Copy and ChangeLayout.
VkImageCopy copy_region;
copy_region.srcSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1 };
@ -1184,9 +1149,9 @@ void Thin3DVKTexture::Upload(VkCommandBuffer cmd) {
vkCmdCopyImage(cmd, staging_.GetImage(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, image_.GetImage(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &copy_region);
image_.ChangeLayout(cmd, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
// From this point on, the image can be used for texturing.
// Even before this function call (but after SetImageData), the image object can be referenced in a descriptor set.
// Even before this function call (but after SetImageData), the image object can be referenced in a descriptor set. Better make sure that the image is uploaded
// before it's actually used though...
state_ = TextureState::INITIALIZED;
}
}
static bool isPowerOf2(int n) {
@ -1317,6 +1282,7 @@ void Thin3DVKContext::SetRenderState(T3DRenderState rs, uint32_t value) {
}
void Thin3DVKContext::Draw(T3DPrimitive prim, Thin3DShaderSet *shaderSet, Thin3DVertexFormat *format, Thin3DBuffer *vdata, int vertexCount, int offset) {
return;
ApplyDynamicState();
curPrim_ = primToVK[prim];
@ -1338,6 +1304,7 @@ void Thin3DVKContext::Draw(T3DPrimitive prim, Thin3DShaderSet *shaderSet, Thin3D
}
void Thin3DVKContext::DrawIndexed(T3DPrimitive prim, Thin3DShaderSet *shaderSet, Thin3DVertexFormat *format, Thin3DBuffer *vdata, Thin3DBuffer *idata, int vertexCount, int offset) {
return;
ApplyDynamicState();
curPrim_ = primToVK[prim];

19
ext/native/thin3d/vulkan_utils.cpp
View file

@ -40,12 +40,12 @@
#include "thin3d/vulkan_utils.h"
void VulkanImage::Create2D(VulkanContext *vulkan, VkFormat format, VkFlags required_props, VkImageUsageFlags usage, int width, int height) {
void VulkanImage::Create2D(VulkanContext *vulkan, VkFormat format, VkFlags required_props, VkImageTiling tiling, VkImageUsageFlags usage, int width, int height) {
VkDevice device = vulkan->GetDevice();
width_ = width;
height_ = height;
VkImageCreateInfo i;
VkImageCreateInfo i = {};
i.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
i.pNext = NULL;
i.imageType = VK_IMAGE_TYPE_2D;
@ -54,13 +54,13 @@ void VulkanImage::Create2D(VulkanContext *vulkan, VkFormat format, VkFlags requi
i.mipLevels = 1;
i.arrayLayers = 1;
i.samples = VK_SAMPLE_COUNT_1_BIT;
i.tiling = VK_IMAGE_TILING_LINEAR;
i.tiling = tiling;
i.usage = usage;
i.flags = 0;
i.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
i.queueFamilyIndexCount = 0;
i.pQueueFamilyIndices = nullptr;
i.initialLayout = VK_IMAGE_LAYOUT_GENERAL;
i.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
VkMemoryRequirements mem_reqs;
@ -81,6 +81,7 @@ void VulkanImage::Create2D(VulkanContext *vulkan, VkFormat format, VkFlags requi
assert(!err);
err = vkBindImageMemory(device, image_, memory_, 0); // at offset 0.
assert(!err);
}
void VulkanImage::SetImageData2D(VkDevice device, const uint8_t *data, int width, int height, int pitch) {
@ -121,14 +122,18 @@ void VulkanImage::ChangeLayout(VkCommandBuffer cmd, VkImageAspectFlags aspectMas
image_memory_barrier.subresourceRange.baseMipLevel = 0;
image_memory_barrier.subresourceRange.levelCount = 1;
if (old_image_layout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) {
image_memory_barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
}
if (new_image_layout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) {
/* Make sure anything that was copying from this image has completed */
// Make sure anything that was copying from this image has completed
image_memory_barrier.srcAccessMask = VK_ACCESS_MEMORY_READ_BIT;
}
if (new_image_layout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) {
/* Make sure any Copy or CPU writes to image are flushed */
image_memory_barrier.dstAccessMask = VK_ACCESS_HOST_WRITE_BIT | VK_ACCESS_TRANSFER_WRITE_BIT;
// Make sure any Copy or CPU writes to image are flushed
image_memory_barrier.dstAccessMask = VK_ACCESS_HOST_WRITE_BIT | VK_ACCESS_TRANSFER_WRITE_BIT | VK_ACCESS_SHADER_READ_BIT;
}
VkPipelineStageFlags src_stages = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;

6
ext/native/thin3d/vulkan_utils.h
View file

@ -23,7 +23,7 @@
#include "ext/vulkan/vulkan.h"
#include "VulkanContext.h"
class VulkanContext;
// Utility class to handle images without going insane.
// Allocates its own memory.
class VulkanImage {
@ -32,7 +32,7 @@ public:
bool IsValid() const { return image_ != nullptr; }
// This can be done completely unsynchronized.
void Create2D(VulkanContext *vulkan, VkFormat format, VkFlags required_props, VkImageUsageFlags usage, int width, int height);
void Create2D(VulkanContext *vulkan, VkFormat format, VkFlags required_props, VkImageTiling tiling, VkImageUsageFlags usage, int width, int height);
// This can only be used if you pass in VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT in required_props in Create2D.
void SetImageData2D(VkDevice device, const uint8_t *data, int width, int height, int pitch);
@ -54,6 +54,4 @@ class Thin3DPipelineCache {
};
bool GLSLtoSPV(const VkShaderStageFlagBits shader_type, const char *pshader, std::vector<uint32_t> &spirv);
bool CreateShaderModule(VkDevice device, const std::vector<uint32_t> &spirv, VkShaderModule *shaderModule);