inksoul
/
plumageRender
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity

update MICRO for plumage render

pull/2/head
ink-soul 2023-06-02 09:56:49 +08:00
parent b2178a2ab6
commit 2c6eaa4dc9
4 changed files with 102 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

136
base/vulkanexamplebase.h
View File

@ -401,134 +401,134 @@ public:
// OS specific macros for the example main entry points // OS specific macros for the example main entry points
#if defined(_WIN32) #if defined(_WIN32)
// Windows entry point // Windows entry point
#define VULKAN_EXAMPLE_MAIN() \ #define PLUMAGE_RENDER_MAIN() \
VulkanExample *vulkanExample; \ PlumageRender *plumageRender; \
LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) \ LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) \
{ \ { \
if (vulkanExample != NULL) \ if (plumageRender != NULL) \
{ \ { \
vulkanExample->handleMessages(hWnd, uMsg, wParam, lParam); \ plumageRender->handleMessages(hWnd, uMsg, wParam, lParam); \
} \ } \
return (DefWindowProc(hWnd, uMsg, wParam, lParam)); \ return (DefWindowProc(hWnd, uMsg, wParam, lParam)); \
} \ } \
int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE, LPSTR, int) \ int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE, LPSTR, int) \
{ \ { \
for (int32_t i = 0; i < __argc; i++) { VulkanExample::args.push_back(__argv[i]); }; \ for (int32_t i = 0; i < __argc; i++) { PlumageRender::args.push_back(__argv[i]); }; \
vulkanExample = new VulkanExample(); \ plumageRender = new PlumageRender(); \
vulkanExample->initVulkan(); \ plumageRender->initVulkan(); \
vulkanExample->setupWindow(hInstance, WndProc); \ plumageRender->setupWindow(hInstance, WndProc); \
vulkanExample->prepare(); \ plumageRender->prepare(); \
vulkanExample->renderLoop(); \ plumageRender->renderLoop(); \
delete(vulkanExample); \ delete(plumageRender); \
return 0; \ return 0; \
} }
#elif defined(VK_USE_PLATFORM_ANDROID_KHR) #elif defined(VK_USE_PLATFORM_ANDROID_KHR)
// Android entry point // Android entry point
#define VULKAN_EXAMPLE_MAIN() \ #define PLUMAGE_RENDER_MAIN() \
VulkanExample *vulkanExample; \ PlumageRender *plumageRender; \
void android_main(android_app* state) \ void android_main(android_app* state) \
{ \ { \
vulkanExample = new VulkanExample(); \ plumageRender = new PlumageRender(); \
state->userData = vulkanExample; \ state->userData = plumageRender; \
state->onAppCmd = VulkanExample::handleAppCommand; \ state->onAppCmd = PlumageRender::handleAppCommand; \
state->onInputEvent = VulkanExample::handleAppInput; \ state->onInputEvent = PlumageRender::handleAppInput; \
androidApp = state; \ androidApp = state; \
vks::android::getDeviceConfig(); \ vks::android::getDeviceConfig(); \
vulkanExample->renderLoop(); \ plumageRender->renderLoop(); \
delete(vulkanExample); \ delete(plumageRender); \
} }
#elif defined(_DIRECT2DISPLAY) #elif defined(_DIRECT2DISPLAY)
// Linux entry point with direct to display wsi // Linux entry point with direct to display wsi
#define VULKAN_EXAMPLE_MAIN() \ #define PLUMAGE_RENDER_MAIN() \
VulkanExample *vulkanExample; \ PlumageRender *plumageRender; \
static void handleEvent() \ static void handleEvent() \
{ \ { \
} \ } \
int main(const int argc, const char *argv[]) \ int main(const int argc, const char *argv[]) \
{ \ { \
for (size_t i = 0; i < argc; i++) { VulkanExample::args.push_back(argv[i]); }; \ for (size_t i = 0; i < argc; i++) { PlumageRender::args.push_back(argv[i]); }; \
vulkanExample = new VulkanExample(); \ plumageRender = new PlumageRender(); \
vulkanExample->initVulkan(); \ plumageRender->initVulkan(); \
vulkanExample->prepare(); \ plumageRender->prepare(); \
vulkanExample->renderLoop(); \ plumageRender->renderLoop(); \
delete(vulkanExample); \ delete(plumageRender); \
return 0; \ return 0; \
} }
#elif defined(VK_USE_PLATFORM_DIRECTFB_EXT) #elif defined(VK_USE_PLATFORM_DIRECTFB_EXT)
#define VULKAN_EXAMPLE_MAIN() \ #define PLUMAGE_RENDER_MAIN() \
VulkanExample *vulkanExample; \ PlumageRender *plumageRender; \
static void handleEvent(const DFBWindowEvent *event) \ static void handleEvent(const DFBWindowEvent *event) \
{ \ { \
if (vulkanExample != NULL) \ if (plumageRender != NULL) \
{ \ { \
vulkanExample->handleEvent(event); \ plumageRender->handleEvent(event); \
} \ } \
} \ } \
int main(const int argc, const char *argv[]) \ int main(const int argc, const char *argv[]) \
{ \ { \
for (size_t i = 0; i < argc; i++) { VulkanExample::args.push_back(argv[i]); }; \ for (size_t i = 0; i < argc; i++) { PlumageRender::args.push_back(argv[i]); }; \
vulkanExample = new VulkanExample(); \ plumageRender = new PlumageRender(); \
vulkanExample->initVulkan(); \ plumageRender->initVulkan(); \
vulkanExample->setupWindow(); \ plumageRender->setupWindow(); \
vulkanExample->prepare(); \ plumageRender->prepare(); \
vulkanExample->renderLoop(); \ plumageRender->renderLoop(); \
delete(vulkanExample); \ delete(plumageRender); \
return 0; \ return 0; \
} }
#elif (defined(VK_USE_PLATFORM_WAYLAND_KHR) || defined(VK_USE_PLATFORM_HEADLESS_EXT)) #elif (defined(VK_USE_PLATFORM_WAYLAND_KHR) || defined(VK_USE_PLATFORM_HEADLESS_EXT))
#define VULKAN_EXAMPLE_MAIN() \ #define PLUMAGE_RENDER_MAIN() \
VulkanExample *vulkanExample; \ PlumageRender *plumageRender; \
int main(const int argc, const char *argv[]) \ int main(const int argc, const char *argv[]) \
{ \ { \
for (size_t i = 0; i < argc; i++) { VulkanExample::args.push_back(argv[i]); }; \ for (size_t i = 0; i < argc; i++) { PlumageRender::args.push_back(argv[i]); }; \
vulkanExample = new VulkanExample(); \ plumageRender = new PlumageRender(); \
vulkanExample->initVulkan(); \ plumageRender->initVulkan(); \
vulkanExample->setupWindow(); \ plumageRender->setupWindow(); \
vulkanExample->prepare(); \ plumageRender->prepare(); \
vulkanExample->renderLoop(); \ plumageRender->renderLoop(); \
delete(vulkanExample); \ delete(plumageRender); \
return 0; \ return 0; \
} }
#elif defined(VK_USE_PLATFORM_XCB_KHR) #elif defined(VK_USE_PLATFORM_XCB_KHR)
#define VULKAN_EXAMPLE_MAIN() \ #define PLUMAGE_RENDER_MAIN() \
VulkanExample *vulkanExample; \ PlumageRender *plumageRender; \
static void handleEvent(const xcb_generic_event_t *event) \ static void handleEvent(const xcb_generic_event_t *event) \
{ \ { \
if (vulkanExample != NULL) \ if (plumageRender != NULL) \
{ \ { \
vulkanExample->handleEvent(event); \ plumageRender->handleEvent(event); \
} \ } \
} \ } \
int main(const int argc, const char *argv[]) \ int main(const int argc, const char *argv[]) \
{ \ { \
for (size_t i = 0; i < argc; i++) { VulkanExample::args.push_back(argv[i]); }; \ for (size_t i = 0; i < argc; i++) { PlumageRender::args.push_back(argv[i]); }; \
vulkanExample = new VulkanExample(); \ plumageRender = new VulkanExample(); \
vulkanExample->initVulkan(); \ plumageRender->initVulkan(); \
vulkanExample->setupWindow(); \ plumageRender->setupWindow(); \
vulkanExample->prepare(); \ plumageRender->prepare(); \
vulkanExample->renderLoop(); \ plumageRender->renderLoop(); \
delete(vulkanExample); \ delete(plumageRender); \
return 0; \ return 0; \
} }
#elif (defined(VK_USE_PLATFORM_IOS_MVK) || defined(VK_USE_PLATFORM_MACOS_MVK)) #elif (defined(VK_USE_PLATFORM_IOS_MVK) || defined(VK_USE_PLATFORM_MACOS_MVK))
#if defined(VK_EXAMPLE_XCODE_GENERATED) #if defined(VK_EXAMPLE_XCODE_GENERATED)
#define VULKAN_EXAMPLE_MAIN() \ #define PLUMAGE_RENDER_MAIN() \
VulkanExample *vulkanExample; \ PlumageRender *plumageRender; \
int main(const int argc, const char *argv[]) \ int main(const int argc, const char *argv[]) \
{ \ { \
@autoreleasepool \ @autoreleasepool \
{ \ { \
for (size_t i = 0; i < argc; i++) { VulkanExample::args.push_back(argv[i]); }; \ for (size_t i = 0; i < argc; i++) { PlumageRender::args.push_back(argv[i]); }; \
vulkanExample = new VulkanExample(); \ plumageRender = new PlumageRender(); \
vulkanExample->initVulkan(); \ plumageRender->initVulkan(); \
vulkanExample->setupWindow(nullptr); \ plumageRender->setupWindow(nullptr); \
vulkanExample->prepare(); \ plumageRender->prepare(); \
vulkanExample->renderLoop(); \ plumageRender->renderLoop(); \
delete(vulkanExample); \ delete(plumageRender); \
} \ } \
return 0; \ return 0; \
} }
#else #else
#define VULKAN_EXAMPLE_MAIN() #define PLUMAGE_RENDER_MAIN()
#endif #endif
#endif #endif

3
src/render/GUIFunction.cpp
View File

@ -24,7 +24,8 @@ std::string GUIFunction::openFileFolderDialog()
COMDLG_FILTERSPEC fileType[] = COMDLG_FILTERSPEC fileType[] =
{ {
{L"compled shader",L"*.spv*"}, {L"all files",L"*.*"},
{L"compiled shader",L"*.spv*"},
{L"gltf model files",L"*.gltf*"}, {L"gltf model files",L"*.gltf*"},
{L"gltf model files",L"*.GLTF*"}, {L"gltf model files",L"*.GLTF*"},

50
src/render/render.cpp
View File

@ -34,7 +34,7 @@
VulkanExample::VulkanExample(): PlumageRender::PlumageRender():
VulkanExampleBase(ENABLE_VALIDATION) VulkanExampleBase(ENABLE_VALIDATION)
{ {
title = "render"; title = "render";
@ -45,7 +45,7 @@
camera.setPerspective(60.0f, (float)width / (float)height, 0.1f, 256.0f); camera.setPerspective(60.0f, (float)width / (float)height, 0.1f, 256.0f);
} }
void VulkanExample::getEnabledFeatures() void PlumageRender::getEnabledFeatures()
{ {
// Fill mode non solid is required for wireframe display // Fill mode non solid is required for wireframe display
if (deviceFeatures.fillModeNonSolid) { if (deviceFeatures.fillModeNonSolid) {
@ -53,7 +53,7 @@
}; };
} }
void VulkanExample::setupFrameBuffer() void PlumageRender::setupFrameBuffer()
{ {
VulkanExampleBase::setupFrameBuffer(); VulkanExampleBase::setupFrameBuffer();
if (pbrFrameBuffer.bCreate && (pbrFrameBuffer.fbo.width != width || pbrFrameBuffer.fbo.height != height)) if (pbrFrameBuffer.bCreate && (pbrFrameBuffer.fbo.width != width || pbrFrameBuffer.fbo.height != height))
@ -165,7 +165,7 @@
pbrFrameBuffer.bCreate = true; pbrFrameBuffer.bCreate = true;
} }
void VulkanExample::buildCommandBuffers() void PlumageRender::buildCommandBuffers()
{ {
VkCommandBufferBeginInfo cmdBufInfo = vks::initializers::commandBufferBeginInfo(); VkCommandBufferBeginInfo cmdBufInfo = vks::initializers::commandBufferBeginInfo();
@ -222,7 +222,7 @@
} }
} }
void VulkanExample::loadglTFFile(std::string filename, VulkanglTFModel& model, bool bSkyboxFlag = false) void PlumageRender::loadglTFFile(std::string filename, VulkanglTFModel& model, bool bSkyboxFlag = false)
{ {
tinygltf::Model glTFInput; tinygltf::Model glTFInput;
tinygltf::TinyGLTF gltfContext; tinygltf::TinyGLTF gltfContext;
@ -334,14 +334,14 @@
vkFreeMemory(device, indexStaging.memory, nullptr); vkFreeMemory(device, indexStaging.memory, nullptr);
} }
// TO DO:reconstruct with getting file path through struct // TO DO:reconstruct with getting file path through struct
void VulkanExample::loadAssets() void PlumageRender::loadAssets()
{ {
loadglTFFile(filePath.glTFModelFilePath, glTFModel); loadglTFFile(filePath.glTFModelFilePath, glTFModel);
loadglTFFile(filePath.skyboxModleFilePath, skyboxModel, true); loadglTFFile(filePath.skyboxModleFilePath, skyboxModel, true);
ibltextures.skyboxCube.loadFromFile(filePath.iblTexturesFilePath, VK_FORMAT_R16G16B16A16_SFLOAT, vulkanDevice, queue); ibltextures.skyboxCube.loadFromFile(filePath.iblTexturesFilePath, VK_FORMAT_R16G16B16A16_SFLOAT, vulkanDevice, queue);
} }
void VulkanExample::setupDescriptors() void PlumageRender::setupDescriptors()
{ {
/* /*
This sample uses separate descriptor sets (and layouts) for the matrices and materials (textures) This sample uses separate descriptor sets (and layouts) for the matrices and materials (textures)
@ -448,7 +448,7 @@
} }
} }
void VulkanExample::preparePipelines() void PlumageRender::preparePipelines()
{ {
VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateCI = vks::initializers::pipelineInputAssemblyStateCreateInfo(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, 0, VK_FALSE); VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateCI = vks::initializers::pipelineInputAssemblyStateCreateInfo(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, 0, VK_FALSE);
VkPipelineRasterizationStateCreateInfo rasterizationStateCI = vks::initializers::pipelineRasterizationStateCreateInfo(VK_POLYGON_MODE_FILL, VK_CULL_MODE_BACK_BIT, VK_FRONT_FACE_COUNTER_CLOCKWISE, 0); VkPipelineRasterizationStateCreateInfo rasterizationStateCI = vks::initializers::pipelineRasterizationStateCreateInfo(VK_POLYGON_MODE_FILL, VK_CULL_MODE_BACK_BIT, VK_FRONT_FACE_COUNTER_CLOCKWISE, 0);
@ -506,7 +506,7 @@
CreateToneMappingPipeline(); CreateToneMappingPipeline();
} }
void VulkanExample::CreateToneMappingPipeline() void PlumageRender::CreateToneMappingPipeline()
{ {
if (pipelines.toneMapping != VK_NULL_HANDLE) if (pipelines.toneMapping != VK_NULL_HANDLE)
{ {
@ -549,7 +549,7 @@
//----------------------------Prepare precompute Lighting or BRDF LUT-----------------------------------------------// //----------------------------Prepare precompute Lighting or BRDF LUT-----------------------------------------------//
//Irradiance map for diffuse lighting //Irradiance map for diffuse lighting
void VulkanExample::GenerateIrradianceCubemap() void PlumageRender::GenerateIrradianceCubemap()
{ {
auto tStart = std::chrono::high_resolution_clock::now(); auto tStart = std::chrono::high_resolution_clock::now();
@ -905,7 +905,7 @@
std::cout << "Generating irradiance cube with " << numMips << " mip levels took " << tDiff << " ms" << std::endl; std::cout << "Generating irradiance cube with " << numMips << " mip levels took " << tDiff << " ms" << std::endl;
} }
void VulkanExample::GeneratePrefilteredCubemap() void PlumageRender::GeneratePrefilteredCubemap()
{ {
auto tStart = std::chrono::high_resolution_clock::now(); auto tStart = std::chrono::high_resolution_clock::now();
@ -1290,7 +1290,7 @@
std::cout << "Generating pre-filtered environment cube with " << numMips << " mip levels took " << tDiff << " ms" << std::endl; std::cout << "Generating pre-filtered environment cube with " << numMips << " mip levels took " << tDiff << " ms" << std::endl;
} }
void VulkanExample::GenerateBRDFLUT() void PlumageRender::GenerateBRDFLUT()
{ {
auto tStart = std::chrono::high_resolution_clock::now(); auto tStart = std::chrono::high_resolution_clock::now();
@ -1497,7 +1497,7 @@
//----------------------------End Precompute brick------------------------------------------------------------------// //----------------------------End Precompute brick------------------------------------------------------------------//
#pragma region pbr render pass setting #pragma region pbr render pass setting
void VulkanExample::createAttachment( void PlumageRender::createAttachment(
VkFormat format, VkFormat format,
VkImageUsageFlagBits usage, VkImageUsageFlagBits usage,
FrameBufferAttachment* attachment, FrameBufferAttachment* attachment,
@ -1558,7 +1558,7 @@
#pragma endregion #pragma endregion
// Prepare and initialize uniform buffer containing shader uniforms // Prepare and initialize uniform buffer containing shader uniforms
void VulkanExample::prepareUniformBuffers() void PlumageRender::prepareUniformBuffers()
{ {
// Vertex shader uniform buffer block // Vertex shader uniform buffer block
VK_CHECK_RESULT(vulkanDevice->createBuffer( VK_CHECK_RESULT(vulkanDevice->createBuffer(
@ -1590,7 +1590,7 @@
updateUniformBuffers(); updateUniformBuffers();
} }
void VulkanExample::updateUniformBuffers() void PlumageRender::updateUniformBuffers()
{ {
shaderData.values.projection = camera.matrices.perspective; shaderData.values.projection = camera.matrices.perspective;
shaderData.values.model = camera.matrices.view; shaderData.values.model = camera.matrices.view;
@ -1600,7 +1600,7 @@
memcpy(shaderData.buffer.mapped, &shaderData.values, sizeof(shaderData.values)); memcpy(shaderData.buffer.mapped, &shaderData.values, sizeof(shaderData.values));
} }
void VulkanExample::prepare() void PlumageRender::prepare()
{ {
VulkanExampleBase::prepare(); VulkanExampleBase::prepare();
loadAssets(); loadAssets();
@ -1614,7 +1614,7 @@
prepared = true; prepared = true;
} }
void VulkanExample::render() void PlumageRender::render()
{ {
renderFrame(); renderFrame();
if (camera.updated) { if (camera.updated) {
@ -1627,12 +1627,12 @@
} }
void VulkanExample::viewChanged() void PlumageRender::viewChanged()
{ {
updateUniformBuffers(); updateUniformBuffers();
} }
void VulkanExample::OnUpdateUIOverlay(vks::UIOverlay *overlay) void PlumageRender::OnUpdateUIOverlay(vks::UIOverlay *overlay)
{ {
GUIFunction guiFunc{}; GUIFunction guiFunc{};
if (overlay->header("Settings")) { if (overlay->header("Settings")) {
@ -1664,7 +1664,7 @@
std::string strModelFilePath; std::string strModelFilePath;
strModelFilePath = guiFunc.openFileFolderDialog(); strModelFilePath = guiFunc.openFileFolderDialog();
filePath.glTFModelFilePath = strModelFilePath; filePath.glTFModelFilePath = strModelFilePath;
loadAssets(); PlumageRender::prepare();
} }
if(overlay->button("select vertexShader")) if(overlay->button("select vertexShader"))
@ -1680,4 +1680,12 @@
} }
VULKAN_EXAMPLE_MAIN() PlumageRender* plumageRender; LRESULT __stdcall WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
if (plumageRender != 0) {
plumageRender->handleMessages(hWnd, uMsg, wParam, lParam);
} return (DefWindowProcA(hWnd, uMsg, wParam, lParam));
} int __stdcall WinMain(HINSTANCE hInstance, HINSTANCE, LPSTR, int) {
for (int32_t i = 0; i < (*__p___argc()); i++) {
PlumageRender::args.push_back((*__p___argv())[i]);
}; plumageRender = new PlumageRender(); plumageRender->initVulkan(); plumageRender->setupWindow(hInstance, WndProc); plumageRender->prepare(); plumageRender->renderLoop(); delete(plumageRender); return 0;
}

6
src/render/render.h
View File

@ -9,7 +9,7 @@
class VulkanExample : public VulkanExampleBase class PlumageRender : public VulkanExampleBase
{ {
public: public:
bool wireframe = false; bool wireframe = false;
@ -156,8 +156,8 @@ public:
VulkanglTFModel skyboxModel; VulkanglTFModel skyboxModel;
VulkanExample(); PlumageRender();
~VulkanExample() ~PlumageRender()
{ {
// Clean up used Vulkan resources // Clean up used Vulkan resources
// Note : Inherited destructor cleans up resources stored in base class // Note : Inherited destructor cleans up resources stored in base class