diff options
Diffstat (limited to 'demo')
53 files changed, 3704 insertions, 970 deletions
diff --git a/demo/DemoApp/DemoApp.vcxproj b/demo/DemoApp/DemoApp.vcxproj index 4cae61f..ba4e592 100644 --- a/demo/DemoApp/DemoApp.vcxproj +++ b/demo/DemoApp/DemoApp.vcxproj @@ -141,6 +141,12 @@ copy "$(SolutionDir)Lib\$(PlatformName)\*.dll" "$(outDir)"</Command> <CustomBuildStep> <Outputs>SDL2.dll</Outputs> </CustomBuildStep> + <PreBuildEvent> + <Command>"$(outDir)DemoAppCodeGen$(Configuration)_$(PlatformName).exe"</Command> + </PreBuildEvent> + <PreBuildEvent> + <Message>Code Generation</Message> + </PreBuildEvent> </ItemDefinitionGroup> <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'"> <ClCompile> @@ -172,6 +178,12 @@ copy "$(SolutionDir)Lib\$(PlatformName)\*.dll" "$(outDir)"</Command> <CustomBuildStep> <Outputs>SDL2.dll</Outputs> </CustomBuildStep> + <PreBuildEvent> + <Command>"$(outDir)DemoAppCodeGen$(Configuration)_$(PlatformName).exe"</Command> + </PreBuildEvent> + <PreBuildEvent> + <Message>Code Generation</Message> + </PreBuildEvent> </ItemDefinitionGroup> <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'"> <ClCompile> @@ -207,6 +219,12 @@ copy "$(SolutionDir)Lib\$(PlatformName)\*.dll" "$(outDir)"</Command> <CustomBuildStep> <Outputs>SDL2.dll</Outputs> </CustomBuildStep> + <PreBuildEvent> + <Command>"$(outDir)DemoAppCodeGen$(Configuration)_$(PlatformName).exe"</Command> + </PreBuildEvent> + <PreBuildEvent> + <Message>Code Generation</Message> + </PreBuildEvent> </ItemDefinitionGroup> <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'"> <ClCompile> @@ -242,6 +260,12 @@ copy "$(SolutionDir)Lib\$(PlatformName)\*.dll" "$(outDir)"</Command> <CustomBuildStep> <Outputs>SDL2.dll</Outputs> </CustomBuildStep> + <PreBuildEvent> + <Command>"$(outDir)DemoAppCodeGen$(Configuration)_$(PlatformName).exe"</Command> + </PreBuildEvent> + <PreBuildEvent> + <Message>Code Generation</Message> + </PreBuildEvent> </ItemDefinitionGroup> <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'"> <LocalDebuggerWorkingDirectory>$(OutDir)</LocalDebuggerWorkingDirectory> @@ -276,6 +300,7 @@ copy "$(SolutionDir)Lib\$(PlatformName)\*.dll" "$(outDir)"</Command> <ClCompile Include="scene.cpp" /> <ClCompile Include="scene2DTextureEmitter.cpp" /> <ClCompile Include="sceneCustomEmit.cpp" /> + <ClCompile Include="sceneEmitSubStep.cpp" /> <ClCompile Include="sceneFlow.cpp" /> <ClCompile Include="sceneSDF.cpp" /> <ClCompile Include="sceneSimpleFlame.cpp" /> diff --git a/demo/DemoApp/DemoApp.vcxproj.filters b/demo/DemoApp/DemoApp.vcxproj.filters index 94b9d93..b6bfb93 100644 --- a/demo/DemoApp/DemoApp.vcxproj.filters +++ b/demo/DemoApp/DemoApp.vcxproj.filters @@ -78,6 +78,9 @@ <ClCompile Include="sceneFlow.cpp"> <Filter>Source Files</Filter> </ClCompile> + <ClCompile Include="sceneEmitSubStep.cpp"> + <Filter>Source Files</Filter> + </ClCompile> </ItemGroup> <ItemGroup> <Manifest Include="app.manifest"> diff --git a/demo/DemoApp/NvFlowInteropLoader.cpp b/demo/DemoApp/NvFlowInteropLoader.cpp index 6224373..082afcf 100644 --- a/demo/DemoApp/NvFlowInteropLoader.cpp +++ b/demo/DemoApp/NvFlowInteropLoader.cpp @@ -14,50 +14,6 @@ #include "NvFlowInterop.h" -namespace -{ - ModuleLoader<16u, SDL_LoadObject, SDL_UnloadObject, SDL_LoadFunction> g_loader; -} +#include <stdio.h> -void loadNvFlowInterop(AppGraphCtxType type) -{ - const char* moduleName = demoAppDLLName(type); - - g_loader.loadModule(moduleName); -} - -void unloadNvFlowInterop() -{ - g_loader.unloadModule(); -} - -// Functions -NvFlowContext* NvFlowInteropCreateContext(AppGraphCtx* appctx) -{ - return g_loader.function<0>(NvFlowInteropCreateContext, "NvFlowInteropCreateContext", appctx); -} - -NvFlowDepthStencilView* NvFlowInteropCreateDepthStencilView(AppGraphCtx* appctx, NvFlowContext* flowctx) -{ - return g_loader.function<1>(NvFlowInteropCreateDepthStencilView, "NvFlowInteropCreateDepthStencilView", appctx, flowctx); -} - -NvFlowRenderTargetView* NvFlowInteropCreateRenderTargetView(AppGraphCtx* appctx, NvFlowContext* flowctx) -{ - return g_loader.function<2>(NvFlowInteropCreateRenderTargetView, "NvFlowInteropCreateRenderTargetView", appctx, flowctx); -} - -void NvFlowInteropUpdateContext(NvFlowContext* context, AppGraphCtx* appctx) -{ - return g_loader.function<3>(NvFlowInteropUpdateContext, "NvFlowInteropUpdateContext", context, appctx); -} - -void NvFlowInteropUpdateDepthStencilView(NvFlowDepthStencilView* view, AppGraphCtx* appctx, NvFlowContext* flowctx) -{ - return g_loader.function<4>(NvFlowInteropUpdateDepthStencilView, "NvFlowInteropUpdateDepthStencilView", view, appctx, flowctx); -} - -void NvFlowInteropUpdateRenderTargetView(NvFlowRenderTargetView* view, AppGraphCtx* appctx, NvFlowContext* flowctx) -{ - return g_loader.function<5>(NvFlowInteropUpdateRenderTargetView, "NvFlowInteropUpdateRenderTargetView", view, appctx, flowctx); -}
\ No newline at end of file +#include "NvFlowInteropLoaderGenerated.h"
\ No newline at end of file diff --git a/demo/DemoApp/NvFlowInteropLoaderGenerated.h b/demo/DemoApp/NvFlowInteropLoaderGenerated.h new file mode 100644 index 0000000..dad9989 --- /dev/null +++ b/demo/DemoApp/NvFlowInteropLoaderGenerated.h @@ -0,0 +1,96 @@ +/* +* Copyright (c) 2014-2017, NVIDIA CORPORATION. All rights reserved. +* +* NVIDIA CORPORATION and its licensors retain all intellectual property +* and proprietary rights in and to this software, related documentation +* and any modifications thereto. Any use, reproduction, disclosure or +* distribution of this software and related documentation without an express +* license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +typedef NvFlowContext* (*NvFlowInteropCreateContext_ptr_t)(AppGraphCtx* appctx); +typedef NvFlowDepthStencilView* (*NvFlowInteropCreateDepthStencilView_ptr_t)(AppGraphCtx* appctx, NvFlowContext* flowctx); +typedef NvFlowRenderTargetView* (*NvFlowInteropCreateRenderTargetView_ptr_t)(AppGraphCtx* appctx, NvFlowContext* flowctx); +typedef void (*NvFlowInteropUpdateContext_ptr_t)(NvFlowContext* context, AppGraphCtx* appctx); +typedef void (*NvFlowInteropUpdateDepthStencilView_ptr_t)(NvFlowDepthStencilView* view, AppGraphCtx* appctx, NvFlowContext* flowctx); +typedef void (*NvFlowInteropUpdateRenderTargetView_ptr_t)(NvFlowRenderTargetView* view, AppGraphCtx* appctx, NvFlowContext* flowctx); + +struct NvFlowInteropLoader +{ + void* module = nullptr; + const char* suffix = ""; + char buf[1024u]; + + NvFlowInteropCreateContext_ptr_t NvFlowInteropCreateContext_ptr; + NvFlowInteropCreateDepthStencilView_ptr_t NvFlowInteropCreateDepthStencilView_ptr; + NvFlowInteropCreateRenderTargetView_ptr_t NvFlowInteropCreateRenderTargetView_ptr; + NvFlowInteropUpdateContext_ptr_t NvFlowInteropUpdateContext_ptr; + NvFlowInteropUpdateDepthStencilView_ptr_t NvFlowInteropUpdateDepthStencilView_ptr; + NvFlowInteropUpdateRenderTargetView_ptr_t NvFlowInteropUpdateRenderTargetView_ptr; + +}gNvFlowInteropLoader; + +NvFlowContext* NvFlowInteropCreateContext(AppGraphCtx* appctx) +{ + return gNvFlowInteropLoader.NvFlowInteropCreateContext_ptr(appctx); +} + +NvFlowDepthStencilView* NvFlowInteropCreateDepthStencilView(AppGraphCtx* appctx, NvFlowContext* flowctx) +{ + return gNvFlowInteropLoader.NvFlowInteropCreateDepthStencilView_ptr(appctx, flowctx); +} + +NvFlowRenderTargetView* NvFlowInteropCreateRenderTargetView(AppGraphCtx* appctx, NvFlowContext* flowctx) +{ + return gNvFlowInteropLoader.NvFlowInteropCreateRenderTargetView_ptr(appctx, flowctx); +} + +void NvFlowInteropUpdateContext(NvFlowContext* context, AppGraphCtx* appctx) +{ + return gNvFlowInteropLoader.NvFlowInteropUpdateContext_ptr(context, appctx); +} + +void NvFlowInteropUpdateDepthStencilView(NvFlowDepthStencilView* view, AppGraphCtx* appctx, NvFlowContext* flowctx) +{ + return gNvFlowInteropLoader.NvFlowInteropUpdateDepthStencilView_ptr(view, appctx, flowctx); +} + +void NvFlowInteropUpdateRenderTargetView(NvFlowRenderTargetView* view, AppGraphCtx* appctx, NvFlowContext* flowctx) +{ + return gNvFlowInteropLoader.NvFlowInteropUpdateRenderTargetView_ptr(view, appctx, flowctx); +} + +void* nvFlowInteropLoaderLoadFunction(NvFlowInteropLoader* inst, const char* name) +{ + snprintf(inst->buf, 1024u, "%s%s", name, inst->suffix); + + return SDL_LoadFunction(inst->module, inst->buf); +} + +void loadNvFlowInterop(AppGraphCtxType type) +{ + const char* moduleName = demoAppDLLName(type); + + gNvFlowInteropLoader.suffix = demoAppBackendSuffix(type); + + gNvFlowInteropLoader.module = SDL_LoadObject(moduleName); + + gNvFlowInteropLoader.NvFlowInteropCreateContext_ptr = (NvFlowInteropCreateContext_ptr_t)(nvFlowInteropLoaderLoadFunction(&gNvFlowInteropLoader, "NvFlowInteropCreateContext")); + gNvFlowInteropLoader.NvFlowInteropCreateDepthStencilView_ptr = (NvFlowInteropCreateDepthStencilView_ptr_t)(nvFlowInteropLoaderLoadFunction(&gNvFlowInteropLoader, "NvFlowInteropCreateDepthStencilView")); + gNvFlowInteropLoader.NvFlowInteropCreateRenderTargetView_ptr = (NvFlowInteropCreateRenderTargetView_ptr_t)(nvFlowInteropLoaderLoadFunction(&gNvFlowInteropLoader, "NvFlowInteropCreateRenderTargetView")); + gNvFlowInteropLoader.NvFlowInteropUpdateContext_ptr = (NvFlowInteropUpdateContext_ptr_t)(nvFlowInteropLoaderLoadFunction(&gNvFlowInteropLoader, "NvFlowInteropUpdateContext")); + gNvFlowInteropLoader.NvFlowInteropUpdateDepthStencilView_ptr = (NvFlowInteropUpdateDepthStencilView_ptr_t)(nvFlowInteropLoaderLoadFunction(&gNvFlowInteropLoader, "NvFlowInteropUpdateDepthStencilView")); + gNvFlowInteropLoader.NvFlowInteropUpdateRenderTargetView_ptr = (NvFlowInteropUpdateRenderTargetView_ptr_t)(nvFlowInteropLoaderLoadFunction(&gNvFlowInteropLoader, "NvFlowInteropUpdateRenderTargetView")); +} + +void unloadNvFlowInterop() +{ + gNvFlowInteropLoader.NvFlowInteropCreateContext_ptr = nullptr; + gNvFlowInteropLoader.NvFlowInteropCreateDepthStencilView_ptr = nullptr; + gNvFlowInteropLoader.NvFlowInteropCreateRenderTargetView_ptr = nullptr; + gNvFlowInteropLoader.NvFlowInteropUpdateContext_ptr = nullptr; + gNvFlowInteropLoader.NvFlowInteropUpdateDepthStencilView_ptr = nullptr; + gNvFlowInteropLoader.NvFlowInteropUpdateRenderTargetView_ptr = nullptr; + + SDL_UnloadObject(gNvFlowInteropLoader.module); +} diff --git a/demo/DemoApp/appGraphCtx.h b/demo/DemoApp/appGraphCtx.h index 2f41c36..f1f0f75 100644 --- a/demo/DemoApp/appGraphCtx.h +++ b/demo/DemoApp/appGraphCtx.h @@ -16,6 +16,11 @@ struct SDL_Window; struct AppGraphCtx; +struct AppGraphColor +{ + float r, g, b, a; +}; + APP_GRAPH_CTX_API AppGraphCtx* AppGraphCtxCreate(int deviceID); APP_GRAPH_CTX_API bool AppGraphCtxUpdateSize(AppGraphCtx* context, SDL_Window* window, bool fullscreen); @@ -24,7 +29,7 @@ APP_GRAPH_CTX_API void AppGraphCtxReleaseRenderTarget(AppGraphCtx* context); APP_GRAPH_CTX_API void AppGraphCtxRelease(AppGraphCtx* context); -APP_GRAPH_CTX_API void AppGraphCtxFrameStart(AppGraphCtx* context, float clearColor[4]); +APP_GRAPH_CTX_API void AppGraphCtxFrameStart(AppGraphCtx* context, AppGraphColor clearColor); APP_GRAPH_CTX_API void AppGraphCtxFramePresent(AppGraphCtx* context, bool fullsync); diff --git a/demo/DemoApp/appGraphCtxLoader.cpp b/demo/DemoApp/appGraphCtxLoader.cpp index f724a93..6aa0f67 100644 --- a/demo/DemoApp/appGraphCtxLoader.cpp +++ b/demo/DemoApp/appGraphCtxLoader.cpp @@ -14,79 +14,6 @@ #include "appGraphCtx.h" -namespace -{ - ModuleLoader<16u, SDL_LoadObject, SDL_UnloadObject, SDL_LoadFunction> g_loader; -} +#include <stdio.h> -void loadAppGraphCtx(AppGraphCtxType type) -{ - const char* moduleName = demoAppDLLName(type); - - g_loader.loadModule(moduleName); -} - -void unloadAppGraphCtx() -{ - g_loader.unloadModule(); -} - -AppGraphCtx* AppGraphCtxCreate(int deviceID) -{ - return g_loader.function<0>(AppGraphCtxCreate, "AppGraphCtxCreate", deviceID); -} - -bool AppGraphCtxUpdateSize(AppGraphCtx* context, SDL_Window* window, bool fullscreen) -{ - return g_loader.function<1>(AppGraphCtxUpdateSize, "AppGraphCtxUpdateSize", context, window, fullscreen); -} - -void AppGraphCtxReleaseRenderTarget(AppGraphCtx* context) -{ - return g_loader.function<2>(AppGraphCtxReleaseRenderTarget, "AppGraphCtxReleaseRenderTarget", context); -} - -void AppGraphCtxRelease(AppGraphCtx* context) -{ - return g_loader.function<3>(AppGraphCtxRelease, "AppGraphCtxRelease", context); -} - -void AppGraphCtxFrameStart(AppGraphCtx* context, float clearColor[4]) -{ - return g_loader.function<4>(AppGraphCtxFrameStart, "AppGraphCtxFrameStart", context, clearColor); -} - -void AppGraphCtxFramePresent(AppGraphCtx* context, bool fullsync) -{ - return g_loader.function<5>(AppGraphCtxFramePresent, "AppGraphCtxFramePresent", context, fullsync); -} - -void AppGraphCtxWaitForFrames(AppGraphCtx* context, unsigned int maxFramesInFlight) -{ - return g_loader.function<6>(AppGraphCtxWaitForFrames, "AppGraphCtxWaitForFrames", context, maxFramesInFlight); -} - -void AppGraphCtxProfileEnable(AppGraphCtx* context, bool enabled) -{ - return g_loader.function<7>(AppGraphCtxProfileEnable, "AppGraphCtxProfileEnable", context, enabled); -} - -void AppGraphCtxProfileBegin(AppGraphCtx* context, const char* label) -{ - return g_loader.function<8>(AppGraphCtxProfileBegin, "AppGraphCtxProfileBegin", context, label); -} - -void AppGraphCtxProfileEnd(AppGraphCtx* context, const char* label) -{ - return g_loader.function<9>(AppGraphCtxProfileEnd, "AppGraphCtxProfileEnd", context, label); -} - -bool AppGraphCtxProfileGet(AppGraphCtx* context, const char** plabel, float* cpuTime, float* gpuTime, int index) -{ - return g_loader.function<10>(AppGraphCtxProfileGet, "AppGraphCtxProfileGet", context, plabel, cpuTime, gpuTime, index); -} - -size_t AppGraphCtxDedicatedVideoMemory(AppGraphCtx* context) -{ - return g_loader.function<11>(AppGraphCtxDedicatedVideoMemory, "AppGraphCtxDedicatedVideoMemory", context); -}
\ No newline at end of file +#include "appGraphCtxLoaderGenerated.h"
\ No newline at end of file diff --git a/demo/DemoApp/appGraphCtxLoaderGenerated.h b/demo/DemoApp/appGraphCtxLoaderGenerated.h new file mode 100644 index 0000000..7983c29 --- /dev/null +++ b/demo/DemoApp/appGraphCtxLoaderGenerated.h @@ -0,0 +1,150 @@ +/* +* Copyright (c) 2014-2017, NVIDIA CORPORATION. All rights reserved. +* +* NVIDIA CORPORATION and its licensors retain all intellectual property +* and proprietary rights in and to this software, related documentation +* and any modifications thereto. Any use, reproduction, disclosure or +* distribution of this software and related documentation without an express +* license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +typedef AppGraphCtx* (*AppGraphCtxCreate_ptr_t)(int deviceID); +typedef bool (*AppGraphCtxUpdateSize_ptr_t)(AppGraphCtx* context, SDL_Window* window, bool fullscreen); +typedef void (*AppGraphCtxReleaseRenderTarget_ptr_t)(AppGraphCtx* context); +typedef void (*AppGraphCtxRelease_ptr_t)(AppGraphCtx* context); +typedef void (*AppGraphCtxFrameStart_ptr_t)(AppGraphCtx* context, AppGraphColor clearColor); +typedef void (*AppGraphCtxFramePresent_ptr_t)(AppGraphCtx* context, bool fullsync); +typedef void (*AppGraphCtxWaitForFrames_ptr_t)(AppGraphCtx* context, unsigned int maxFramesInFlight); +typedef void (*AppGraphCtxProfileEnable_ptr_t)(AppGraphCtx* context, bool enabled); +typedef void (*AppGraphCtxProfileBegin_ptr_t)(AppGraphCtx* context, const char* label); +typedef void (*AppGraphCtxProfileEnd_ptr_t)(AppGraphCtx* context, const char* label); +typedef bool (*AppGraphCtxProfileGet_ptr_t)(AppGraphCtx* context, const char** plabel, float* cpuTime, float* gpuTime, int index); +typedef size_t (*AppGraphCtxDedicatedVideoMemory_ptr_t)(AppGraphCtx* context); + +struct AppGraphCtxLoader +{ + void* module = nullptr; + const char* suffix = ""; + char buf[1024u]; + + AppGraphCtxCreate_ptr_t AppGraphCtxCreate_ptr; + AppGraphCtxUpdateSize_ptr_t AppGraphCtxUpdateSize_ptr; + AppGraphCtxReleaseRenderTarget_ptr_t AppGraphCtxReleaseRenderTarget_ptr; + AppGraphCtxRelease_ptr_t AppGraphCtxRelease_ptr; + AppGraphCtxFrameStart_ptr_t AppGraphCtxFrameStart_ptr; + AppGraphCtxFramePresent_ptr_t AppGraphCtxFramePresent_ptr; + AppGraphCtxWaitForFrames_ptr_t AppGraphCtxWaitForFrames_ptr; + AppGraphCtxProfileEnable_ptr_t AppGraphCtxProfileEnable_ptr; + AppGraphCtxProfileBegin_ptr_t AppGraphCtxProfileBegin_ptr; + AppGraphCtxProfileEnd_ptr_t AppGraphCtxProfileEnd_ptr; + AppGraphCtxProfileGet_ptr_t AppGraphCtxProfileGet_ptr; + AppGraphCtxDedicatedVideoMemory_ptr_t AppGraphCtxDedicatedVideoMemory_ptr; + +}gAppGraphCtxLoader; + +AppGraphCtx* AppGraphCtxCreate(int deviceID) +{ + return gAppGraphCtxLoader.AppGraphCtxCreate_ptr(deviceID); +} + +bool AppGraphCtxUpdateSize(AppGraphCtx* context, SDL_Window* window, bool fullscreen) +{ + return gAppGraphCtxLoader.AppGraphCtxUpdateSize_ptr(context, window, fullscreen); +} + +void AppGraphCtxReleaseRenderTarget(AppGraphCtx* context) +{ + return gAppGraphCtxLoader.AppGraphCtxReleaseRenderTarget_ptr(context); +} + +void AppGraphCtxRelease(AppGraphCtx* context) +{ + return gAppGraphCtxLoader.AppGraphCtxRelease_ptr(context); +} + +void AppGraphCtxFrameStart(AppGraphCtx* context, AppGraphColor clearColor) +{ + return gAppGraphCtxLoader.AppGraphCtxFrameStart_ptr(context, clearColor); +} + +void AppGraphCtxFramePresent(AppGraphCtx* context, bool fullsync) +{ + return gAppGraphCtxLoader.AppGraphCtxFramePresent_ptr(context, fullsync); +} + +void AppGraphCtxWaitForFrames(AppGraphCtx* context, unsigned int maxFramesInFlight) +{ + return gAppGraphCtxLoader.AppGraphCtxWaitForFrames_ptr(context, maxFramesInFlight); +} + +void AppGraphCtxProfileEnable(AppGraphCtx* context, bool enabled) +{ + return gAppGraphCtxLoader.AppGraphCtxProfileEnable_ptr(context, enabled); +} + +void AppGraphCtxProfileBegin(AppGraphCtx* context, const char* label) +{ + return gAppGraphCtxLoader.AppGraphCtxProfileBegin_ptr(context, label); +} + +void AppGraphCtxProfileEnd(AppGraphCtx* context, const char* label) +{ + return gAppGraphCtxLoader.AppGraphCtxProfileEnd_ptr(context, label); +} + +bool AppGraphCtxProfileGet(AppGraphCtx* context, const char** plabel, float* cpuTime, float* gpuTime, int index) +{ + return gAppGraphCtxLoader.AppGraphCtxProfileGet_ptr(context, plabel, cpuTime, gpuTime, index); +} + +size_t AppGraphCtxDedicatedVideoMemory(AppGraphCtx* context) +{ + return gAppGraphCtxLoader.AppGraphCtxDedicatedVideoMemory_ptr(context); +} + +void* appGraphCtxLoaderLoadFunction(AppGraphCtxLoader* inst, const char* name) +{ + snprintf(inst->buf, 1024u, "%s%s", name, inst->suffix); + + return SDL_LoadFunction(inst->module, inst->buf); +} + +void loadAppGraphCtx(AppGraphCtxType type) +{ + const char* moduleName = demoAppDLLName(type); + + gAppGraphCtxLoader.suffix = demoAppBackendSuffix(type); + + gAppGraphCtxLoader.module = SDL_LoadObject(moduleName); + + gAppGraphCtxLoader.AppGraphCtxCreate_ptr = (AppGraphCtxCreate_ptr_t)(appGraphCtxLoaderLoadFunction(&gAppGraphCtxLoader, "AppGraphCtxCreate")); + gAppGraphCtxLoader.AppGraphCtxUpdateSize_ptr = (AppGraphCtxUpdateSize_ptr_t)(appGraphCtxLoaderLoadFunction(&gAppGraphCtxLoader, "AppGraphCtxUpdateSize")); + gAppGraphCtxLoader.AppGraphCtxReleaseRenderTarget_ptr = (AppGraphCtxReleaseRenderTarget_ptr_t)(appGraphCtxLoaderLoadFunction(&gAppGraphCtxLoader, "AppGraphCtxReleaseRenderTarget")); + gAppGraphCtxLoader.AppGraphCtxRelease_ptr = (AppGraphCtxRelease_ptr_t)(appGraphCtxLoaderLoadFunction(&gAppGraphCtxLoader, "AppGraphCtxRelease")); + gAppGraphCtxLoader.AppGraphCtxFrameStart_ptr = (AppGraphCtxFrameStart_ptr_t)(appGraphCtxLoaderLoadFunction(&gAppGraphCtxLoader, "AppGraphCtxFrameStart")); + gAppGraphCtxLoader.AppGraphCtxFramePresent_ptr = (AppGraphCtxFramePresent_ptr_t)(appGraphCtxLoaderLoadFunction(&gAppGraphCtxLoader, "AppGraphCtxFramePresent")); + gAppGraphCtxLoader.AppGraphCtxWaitForFrames_ptr = (AppGraphCtxWaitForFrames_ptr_t)(appGraphCtxLoaderLoadFunction(&gAppGraphCtxLoader, "AppGraphCtxWaitForFrames")); + gAppGraphCtxLoader.AppGraphCtxProfileEnable_ptr = (AppGraphCtxProfileEnable_ptr_t)(appGraphCtxLoaderLoadFunction(&gAppGraphCtxLoader, "AppGraphCtxProfileEnable")); + gAppGraphCtxLoader.AppGraphCtxProfileBegin_ptr = (AppGraphCtxProfileBegin_ptr_t)(appGraphCtxLoaderLoadFunction(&gAppGraphCtxLoader, "AppGraphCtxProfileBegin")); + gAppGraphCtxLoader.AppGraphCtxProfileEnd_ptr = (AppGraphCtxProfileEnd_ptr_t)(appGraphCtxLoaderLoadFunction(&gAppGraphCtxLoader, "AppGraphCtxProfileEnd")); + gAppGraphCtxLoader.AppGraphCtxProfileGet_ptr = (AppGraphCtxProfileGet_ptr_t)(appGraphCtxLoaderLoadFunction(&gAppGraphCtxLoader, "AppGraphCtxProfileGet")); + gAppGraphCtxLoader.AppGraphCtxDedicatedVideoMemory_ptr = (AppGraphCtxDedicatedVideoMemory_ptr_t)(appGraphCtxLoaderLoadFunction(&gAppGraphCtxLoader, "AppGraphCtxDedicatedVideoMemory")); +} + +void unloadAppGraphCtx() +{ + gAppGraphCtxLoader.AppGraphCtxCreate_ptr = nullptr; + gAppGraphCtxLoader.AppGraphCtxUpdateSize_ptr = nullptr; + gAppGraphCtxLoader.AppGraphCtxReleaseRenderTarget_ptr = nullptr; + gAppGraphCtxLoader.AppGraphCtxRelease_ptr = nullptr; + gAppGraphCtxLoader.AppGraphCtxFrameStart_ptr = nullptr; + gAppGraphCtxLoader.AppGraphCtxFramePresent_ptr = nullptr; + gAppGraphCtxLoader.AppGraphCtxWaitForFrames_ptr = nullptr; + gAppGraphCtxLoader.AppGraphCtxProfileEnable_ptr = nullptr; + gAppGraphCtxLoader.AppGraphCtxProfileBegin_ptr = nullptr; + gAppGraphCtxLoader.AppGraphCtxProfileEnd_ptr = nullptr; + gAppGraphCtxLoader.AppGraphCtxProfileGet_ptr = nullptr; + gAppGraphCtxLoader.AppGraphCtxDedicatedVideoMemory_ptr = nullptr; + + SDL_UnloadObject(gAppGraphCtxLoader.module); +} diff --git a/demo/DemoApp/computeContextLoader.cpp b/demo/DemoApp/computeContextLoader.cpp index 593b2ce..396f8b5 100644 --- a/demo/DemoApp/computeContextLoader.cpp +++ b/demo/DemoApp/computeContextLoader.cpp @@ -14,134 +14,6 @@ #include "computeContext.h" -namespace -{ - ModuleLoader<32u, SDL_LoadObject, SDL_UnloadObject, SDL_LoadFunction> g_loader; -} +#include <stdio.h> -void loadComputeContext(AppGraphCtxType type) -{ - const char* moduleName = demoAppDLLName(type); - - g_loader.loadModule(moduleName); -} - -void unloadComputeContext() -{ - g_loader.unloadModule(); -} - -ComputeContext* ComputeContextCreate(ComputeContextDesc* desc) -{ - return g_loader.function<0>(ComputeContextCreate, "ComputeContextCreate", desc); -} - -void ComputeContextUpdate(ComputeContext* context, ComputeContextDesc* desc) -{ - return g_loader.function<1>(ComputeContextUpdate, "ComputeContextUpdate", context, desc); -} - -void ComputeContextRelease(ComputeContext* context) -{ - return g_loader.function<2>(ComputeContextRelease, "ComputeContextRelease", context); -} - -ComputeShader* ComputeShaderCreate(ComputeContext* context, const ComputeShaderDesc* desc) -{ - return g_loader.function<3>(ComputeShaderCreate, "ComputeShaderCreate", context, desc); -} - -void ComputeShaderRelease(ComputeShader* shader) -{ - return g_loader.function<4>(ComputeShaderRelease, "ComputeShaderRelease", shader); -} - -ComputeConstantBuffer* ComputeConstantBufferCreate(ComputeContext* context, const ComputeConstantBufferDesc* desc) -{ - return g_loader.function<5>(ComputeConstantBufferCreate, "ComputeConstantBufferCreate", context, desc); -} - -void ComputeConstantBufferRelease(ComputeConstantBuffer* constantBuffer) -{ - return g_loader.function<6>(ComputeConstantBufferRelease, "ComputeConstantBufferRelease", constantBuffer); -} - -void* ComputeConstantBufferMap(ComputeContext* context, ComputeConstantBuffer* constantBuffer) -{ - return g_loader.function<7>(ComputeConstantBufferMap, "ComputeConstantBufferMap", context, constantBuffer); -} - -void ComputeConstantBufferUnmap(ComputeContext* context, ComputeConstantBuffer* constantBuffer) -{ - return g_loader.function<8>(ComputeConstantBufferUnmap, "ComputeConstantBufferUnmap", context, constantBuffer); -} - -ComputeResource* ComputeResourceCreate(ComputeContext* context, const ComputeResourceDesc* desc) -{ - return g_loader.function<9>(ComputeResourceCreate, "ComputeResourceCreate", context, desc); -} - -void ComputeResourceUpdate(ComputeContext* context, ComputeResource* resource, const ComputeResourceDesc* desc) -{ - return g_loader.function<10>(ComputeResourceUpdate, "ComputeResourceUpdate", context, resource, desc); -} - -void ComputeResourceRelease(ComputeResource* resource) -{ - return g_loader.function<11>(ComputeResourceRelease, "ComputeResourceRelease", resource); -} - -ComputeResourceRW* ComputeResourceRWCreate(ComputeContext* context, const ComputeResourceRWDesc* desc) -{ - return g_loader.function<12>(ComputeResourceRWCreate, "ComputeResourceRWCreate", context, desc); -} - -void ComputeResourceRWUpdate(ComputeContext* context, ComputeResourceRW* resourceRW, const ComputeResourceRWDesc* desc) -{ - return g_loader.function<13>(ComputeResourceRWUpdate, "ComputeResourceRWUpdate", context, resourceRW, desc); -} - -void ComputeResourceRWRelease(ComputeResourceRW* resourceRW) -{ - return g_loader.function<14>(ComputeResourceRWRelease, "ComputeResourceRWRelease", resourceRW); -} - -void ComputeContextDispatch(ComputeContext* context, const ComputeDispatchParams* params) -{ - return g_loader.function<15>(ComputeContextDispatch, "ComputeContextDispatch", context, params); -} - -ComputeContext* ComputeContextNvFlowContextCreate(NvFlowContext* flowContext) -{ - return g_loader.function<16>(ComputeContextNvFlowContextCreate, "ComputeContextNvFlowContextCreate", flowContext); -} - -void ComputeContextNvFlowContextUpdate(ComputeContext* computeContext, NvFlowContext* flowContext) -{ - return g_loader.function<17>(ComputeContextNvFlowContextUpdate, "ComputeContextNvFlowContextUpdate", computeContext, flowContext); -} - -ComputeResource* ComputeResourceNvFlowCreate(ComputeContext* context, NvFlowContext* flowContext, NvFlowResource* flowResource) -{ - return g_loader.function<18>(ComputeResourceNvFlowCreate, "ComputeResourceNvFlowCreate", context, flowContext, flowResource); -} - -void ComputeResourceNvFlowUpdate(ComputeContext* context, ComputeResource* resource, NvFlowContext* flowContext, NvFlowResource* flowResource) -{ - return g_loader.function<19>(ComputeResourceNvFlowUpdate, "ComputeResourceNvFlowUpdate", context, resource, flowContext, flowResource); -} - -ComputeResourceRW* ComputeResourceRWNvFlowCreate(ComputeContext* context, NvFlowContext* flowContext, NvFlowResourceRW* flowResourceRW) -{ - return g_loader.function<20>(ComputeResourceRWNvFlowCreate, "ComputeResourceRWNvFlowCreate", context, flowContext, flowResourceRW); -} - -void ComputeResourceRWNvFlowUpdate(ComputeContext* context, ComputeResourceRW* resourceRW, NvFlowContext* flowContext, NvFlowResourceRW* flowResourceRW) -{ - return g_loader.function<21>(ComputeResourceRWNvFlowUpdate, "ComputeResourceRWNvFlowUpdate", context, resourceRW, flowContext, flowResourceRW); -} - -ComputeResource* ComputeResourceRWGetResource(ComputeResourceRW* resourceRW) -{ - return g_loader.function<22>(ComputeResourceRWGetResource, "ComputeResourceRWGetResource", resourceRW); -}
\ No newline at end of file +#include "computeContextLoaderGenerated.h"
\ No newline at end of file diff --git a/demo/DemoApp/computeContextLoaderGenerated.h b/demo/DemoApp/computeContextLoaderGenerated.h new file mode 100644 index 0000000..b15775e --- /dev/null +++ b/demo/DemoApp/computeContextLoaderGenerated.h @@ -0,0 +1,249 @@ +/* +* Copyright (c) 2014-2017, NVIDIA CORPORATION. All rights reserved. +* +* NVIDIA CORPORATION and its licensors retain all intellectual property +* and proprietary rights in and to this software, related documentation +* and any modifications thereto. Any use, reproduction, disclosure or +* distribution of this software and related documentation without an express +* license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +typedef ComputeContext* (*ComputeContextCreate_ptr_t)(ComputeContextDesc* desc); +typedef void (*ComputeContextUpdate_ptr_t)(ComputeContext* context, ComputeContextDesc* desc); +typedef void (*ComputeContextRelease_ptr_t)(ComputeContext* context); +typedef ComputeShader* (*ComputeShaderCreate_ptr_t)(ComputeContext* context, const ComputeShaderDesc* desc); +typedef void (*ComputeShaderRelease_ptr_t)(ComputeShader* shader); +typedef ComputeConstantBuffer* (*ComputeConstantBufferCreate_ptr_t)(ComputeContext* context, const ComputeConstantBufferDesc* desc); +typedef void (*ComputeConstantBufferRelease_ptr_t)(ComputeConstantBuffer* constantBuffer); +typedef void* (*ComputeConstantBufferMap_ptr_t)(ComputeContext* context, ComputeConstantBuffer* constantBuffer); +typedef void (*ComputeConstantBufferUnmap_ptr_t)(ComputeContext* context, ComputeConstantBuffer* constantBuffer); +typedef ComputeResource* (*ComputeResourceCreate_ptr_t)(ComputeContext* context, const ComputeResourceDesc* desc); +typedef void (*ComputeResourceUpdate_ptr_t)(ComputeContext* context, ComputeResource* resource, const ComputeResourceDesc* desc); +typedef void (*ComputeResourceRelease_ptr_t)(ComputeResource* resource); +typedef ComputeResourceRW* (*ComputeResourceRWCreate_ptr_t)(ComputeContext* context, const ComputeResourceRWDesc* desc); +typedef void (*ComputeResourceRWUpdate_ptr_t)(ComputeContext* context, ComputeResourceRW* resourceRW, const ComputeResourceRWDesc* desc); +typedef void (*ComputeResourceRWRelease_ptr_t)(ComputeResourceRW* resourceRW); +typedef ComputeResource* (*ComputeResourceRWGetResource_ptr_t)(ComputeResourceRW* resourceRW); +typedef void (*ComputeContextDispatch_ptr_t)(ComputeContext* context, const ComputeDispatchParams* params); +typedef ComputeContext* (*ComputeContextNvFlowContextCreate_ptr_t)(NvFlowContext* flowContext); +typedef void (*ComputeContextNvFlowContextUpdate_ptr_t)(ComputeContext* computeContext, NvFlowContext* flowContext); +typedef ComputeResource* (*ComputeResourceNvFlowCreate_ptr_t)(ComputeContext* context, NvFlowContext* flowContext, NvFlowResource* flowResource); +typedef void (*ComputeResourceNvFlowUpdate_ptr_t)(ComputeContext* context, ComputeResource* resource, NvFlowContext* flowContext, NvFlowResource* flowResource); +typedef ComputeResourceRW* (*ComputeResourceRWNvFlowCreate_ptr_t)(ComputeContext* context, NvFlowContext* flowContext, NvFlowResourceRW* flowResourceRW); +typedef void (*ComputeResourceRWNvFlowUpdate_ptr_t)(ComputeContext* context, ComputeResourceRW* resourceRW, NvFlowContext* flowContext, NvFlowResourceRW* flowResourceRW); + +struct ComputeContextLoader +{ + void* module = nullptr; + const char* suffix = ""; + char buf[1024u]; + + ComputeContextCreate_ptr_t ComputeContextCreate_ptr; + ComputeContextUpdate_ptr_t ComputeContextUpdate_ptr; + ComputeContextRelease_ptr_t ComputeContextRelease_ptr; + ComputeShaderCreate_ptr_t ComputeShaderCreate_ptr; + ComputeShaderRelease_ptr_t ComputeShaderRelease_ptr; + ComputeConstantBufferCreate_ptr_t ComputeConstantBufferCreate_ptr; + ComputeConstantBufferRelease_ptr_t ComputeConstantBufferRelease_ptr; + ComputeConstantBufferMap_ptr_t ComputeConstantBufferMap_ptr; + ComputeConstantBufferUnmap_ptr_t ComputeConstantBufferUnmap_ptr; + ComputeResourceCreate_ptr_t ComputeResourceCreate_ptr; + ComputeResourceUpdate_ptr_t ComputeResourceUpdate_ptr; + ComputeResourceRelease_ptr_t ComputeResourceRelease_ptr; + ComputeResourceRWCreate_ptr_t ComputeResourceRWCreate_ptr; + ComputeResourceRWUpdate_ptr_t ComputeResourceRWUpdate_ptr; + ComputeResourceRWRelease_ptr_t ComputeResourceRWRelease_ptr; + ComputeResourceRWGetResource_ptr_t ComputeResourceRWGetResource_ptr; + ComputeContextDispatch_ptr_t ComputeContextDispatch_ptr; + ComputeContextNvFlowContextCreate_ptr_t ComputeContextNvFlowContextCreate_ptr; + ComputeContextNvFlowContextUpdate_ptr_t ComputeContextNvFlowContextUpdate_ptr; + ComputeResourceNvFlowCreate_ptr_t ComputeResourceNvFlowCreate_ptr; + ComputeResourceNvFlowUpdate_ptr_t ComputeResourceNvFlowUpdate_ptr; + ComputeResourceRWNvFlowCreate_ptr_t ComputeResourceRWNvFlowCreate_ptr; + ComputeResourceRWNvFlowUpdate_ptr_t ComputeResourceRWNvFlowUpdate_ptr; + +}gComputeContextLoader; + +ComputeContext* ComputeContextCreate(ComputeContextDesc* desc) +{ + return gComputeContextLoader.ComputeContextCreate_ptr(desc); +} + +void ComputeContextUpdate(ComputeContext* context, ComputeContextDesc* desc) +{ + return gComputeContextLoader.ComputeContextUpdate_ptr(context, desc); +} + +void ComputeContextRelease(ComputeContext* context) +{ + return gComputeContextLoader.ComputeContextRelease_ptr(context); +} + +ComputeShader* ComputeShaderCreate(ComputeContext* context, const ComputeShaderDesc* desc) +{ + return gComputeContextLoader.ComputeShaderCreate_ptr(context, desc); +} + +void ComputeShaderRelease(ComputeShader* shader) +{ + return gComputeContextLoader.ComputeShaderRelease_ptr(shader); +} + +ComputeConstantBuffer* ComputeConstantBufferCreate(ComputeContext* context, const ComputeConstantBufferDesc* desc) +{ + return gComputeContextLoader.ComputeConstantBufferCreate_ptr(context, desc); +} + +void ComputeConstantBufferRelease(ComputeConstantBuffer* constantBuffer) +{ + return gComputeContextLoader.ComputeConstantBufferRelease_ptr(constantBuffer); +} + +void* ComputeConstantBufferMap(ComputeContext* context, ComputeConstantBuffer* constantBuffer) +{ + return gComputeContextLoader.ComputeConstantBufferMap_ptr(context, constantBuffer); +} + +void ComputeConstantBufferUnmap(ComputeContext* context, ComputeConstantBuffer* constantBuffer) +{ + return gComputeContextLoader.ComputeConstantBufferUnmap_ptr(context, constantBuffer); +} + +ComputeResource* ComputeResourceCreate(ComputeContext* context, const ComputeResourceDesc* desc) +{ + return gComputeContextLoader.ComputeResourceCreate_ptr(context, desc); +} + +void ComputeResourceUpdate(ComputeContext* context, ComputeResource* resource, const ComputeResourceDesc* desc) +{ + return gComputeContextLoader.ComputeResourceUpdate_ptr(context, resource, desc); +} + +void ComputeResourceRelease(ComputeResource* resource) +{ + return gComputeContextLoader.ComputeResourceRelease_ptr(resource); +} + +ComputeResourceRW* ComputeResourceRWCreate(ComputeContext* context, const ComputeResourceRWDesc* desc) +{ + return gComputeContextLoader.ComputeResourceRWCreate_ptr(context, desc); +} + +void ComputeResourceRWUpdate(ComputeContext* context, ComputeResourceRW* resourceRW, const ComputeResourceRWDesc* desc) +{ + return gComputeContextLoader.ComputeResourceRWUpdate_ptr(context, resourceRW, desc); +} + +void ComputeResourceRWRelease(ComputeResourceRW* resourceRW) +{ + return gComputeContextLoader.ComputeResourceRWRelease_ptr(resourceRW); +} + +ComputeResource* ComputeResourceRWGetResource(ComputeResourceRW* resourceRW) +{ + return gComputeContextLoader.ComputeResourceRWGetResource_ptr(resourceRW); +} + +void ComputeContextDispatch(ComputeContext* context, const ComputeDispatchParams* params) +{ + return gComputeContextLoader.ComputeContextDispatch_ptr(context, params); +} + +ComputeContext* ComputeContextNvFlowContextCreate(NvFlowContext* flowContext) +{ + return gComputeContextLoader.ComputeContextNvFlowContextCreate_ptr(flowContext); +} + +void ComputeContextNvFlowContextUpdate(ComputeContext* computeContext, NvFlowContext* flowContext) +{ + return gComputeContextLoader.ComputeContextNvFlowContextUpdate_ptr(computeContext, flowContext); +} + +ComputeResource* ComputeResourceNvFlowCreate(ComputeContext* context, NvFlowContext* flowContext, NvFlowResource* flowResource) +{ + return gComputeContextLoader.ComputeResourceNvFlowCreate_ptr(context, flowContext, flowResource); +} + +void ComputeResourceNvFlowUpdate(ComputeContext* context, ComputeResource* resource, NvFlowContext* flowContext, NvFlowResource* flowResource) +{ + return gComputeContextLoader.ComputeResourceNvFlowUpdate_ptr(context, resource, flowContext, flowResource); +} + +ComputeResourceRW* ComputeResourceRWNvFlowCreate(ComputeContext* context, NvFlowContext* flowContext, NvFlowResourceRW* flowResourceRW) +{ + return gComputeContextLoader.ComputeResourceRWNvFlowCreate_ptr(context, flowContext, flowResourceRW); +} + +void ComputeResourceRWNvFlowUpdate(ComputeContext* context, ComputeResourceRW* resourceRW, NvFlowContext* flowContext, NvFlowResourceRW* flowResourceRW) +{ + return gComputeContextLoader.ComputeResourceRWNvFlowUpdate_ptr(context, resourceRW, flowContext, flowResourceRW); +} + +void* computeContextLoaderLoadFunction(ComputeContextLoader* inst, const char* name) +{ + snprintf(inst->buf, 1024u, "%s%s", name, inst->suffix); + + return SDL_LoadFunction(inst->module, inst->buf); +} + +void loadComputeContext(AppGraphCtxType type) +{ + const char* moduleName = demoAppDLLName(type); + + gComputeContextLoader.suffix = demoAppBackendSuffix(type); + + gComputeContextLoader.module = SDL_LoadObject(moduleName); + + gComputeContextLoader.ComputeContextCreate_ptr = (ComputeContextCreate_ptr_t)(computeContextLoaderLoadFunction(&gComputeContextLoader, "ComputeContextCreate")); + gComputeContextLoader.ComputeContextUpdate_ptr = (ComputeContextUpdate_ptr_t)(computeContextLoaderLoadFunction(&gComputeContextLoader, "ComputeContextUpdate")); + gComputeContextLoader.ComputeContextRelease_ptr = (ComputeContextRelease_ptr_t)(computeContextLoaderLoadFunction(&gComputeContextLoader, "ComputeContextRelease")); + gComputeContextLoader.ComputeShaderCreate_ptr = (ComputeShaderCreate_ptr_t)(computeContextLoaderLoadFunction(&gComputeContextLoader, "ComputeShaderCreate")); + gComputeContextLoader.ComputeShaderRelease_ptr = (ComputeShaderRelease_ptr_t)(computeContextLoaderLoadFunction(&gComputeContextLoader, "ComputeShaderRelease")); + gComputeContextLoader.ComputeConstantBufferCreate_ptr = (ComputeConstantBufferCreate_ptr_t)(computeContextLoaderLoadFunction(&gComputeContextLoader, "ComputeConstantBufferCreate")); + gComputeContextLoader.ComputeConstantBufferRelease_ptr = (ComputeConstantBufferRelease_ptr_t)(computeContextLoaderLoadFunction(&gComputeContextLoader, "ComputeConstantBufferRelease")); + gComputeContextLoader.ComputeConstantBufferMap_ptr = (ComputeConstantBufferMap_ptr_t)(computeContextLoaderLoadFunction(&gComputeContextLoader, "ComputeConstantBufferMap")); + gComputeContextLoader.ComputeConstantBufferUnmap_ptr = (ComputeConstantBufferUnmap_ptr_t)(computeContextLoaderLoadFunction(&gComputeContextLoader, "ComputeConstantBufferUnmap")); + gComputeContextLoader.ComputeResourceCreate_ptr = (ComputeResourceCreate_ptr_t)(computeContextLoaderLoadFunction(&gComputeContextLoader, "ComputeResourceCreate")); + gComputeContextLoader.ComputeResourceUpdate_ptr = (ComputeResourceUpdate_ptr_t)(computeContextLoaderLoadFunction(&gComputeContextLoader, "ComputeResourceUpdate")); + gComputeContextLoader.ComputeResourceRelease_ptr = (ComputeResourceRelease_ptr_t)(computeContextLoaderLoadFunction(&gComputeContextLoader, "ComputeResourceRelease")); + gComputeContextLoader.ComputeResourceRWCreate_ptr = (ComputeResourceRWCreate_ptr_t)(computeContextLoaderLoadFunction(&gComputeContextLoader, "ComputeResourceRWCreate")); + gComputeContextLoader.ComputeResourceRWUpdate_ptr = (ComputeResourceRWUpdate_ptr_t)(computeContextLoaderLoadFunction(&gComputeContextLoader, "ComputeResourceRWUpdate")); + gComputeContextLoader.ComputeResourceRWRelease_ptr = (ComputeResourceRWRelease_ptr_t)(computeContextLoaderLoadFunction(&gComputeContextLoader, "ComputeResourceRWRelease")); + gComputeContextLoader.ComputeResourceRWGetResource_ptr = (ComputeResourceRWGetResource_ptr_t)(computeContextLoaderLoadFunction(&gComputeContextLoader, "ComputeResourceRWGetResource")); + gComputeContextLoader.ComputeContextDispatch_ptr = (ComputeContextDispatch_ptr_t)(computeContextLoaderLoadFunction(&gComputeContextLoader, "ComputeContextDispatch")); + gComputeContextLoader.ComputeContextNvFlowContextCreate_ptr = (ComputeContextNvFlowContextCreate_ptr_t)(computeContextLoaderLoadFunction(&gComputeContextLoader, "ComputeContextNvFlowContextCreate")); + gComputeContextLoader.ComputeContextNvFlowContextUpdate_ptr = (ComputeContextNvFlowContextUpdate_ptr_t)(computeContextLoaderLoadFunction(&gComputeContextLoader, "ComputeContextNvFlowContextUpdate")); + gComputeContextLoader.ComputeResourceNvFlowCreate_ptr = (ComputeResourceNvFlowCreate_ptr_t)(computeContextLoaderLoadFunction(&gComputeContextLoader, "ComputeResourceNvFlowCreate")); + gComputeContextLoader.ComputeResourceNvFlowUpdate_ptr = (ComputeResourceNvFlowUpdate_ptr_t)(computeContextLoaderLoadFunction(&gComputeContextLoader, "ComputeResourceNvFlowUpdate")); + gComputeContextLoader.ComputeResourceRWNvFlowCreate_ptr = (ComputeResourceRWNvFlowCreate_ptr_t)(computeContextLoaderLoadFunction(&gComputeContextLoader, "ComputeResourceRWNvFlowCreate")); + gComputeContextLoader.ComputeResourceRWNvFlowUpdate_ptr = (ComputeResourceRWNvFlowUpdate_ptr_t)(computeContextLoaderLoadFunction(&gComputeContextLoader, "ComputeResourceRWNvFlowUpdate")); +} + +void unloadComputeContext() +{ + gComputeContextLoader.ComputeContextCreate_ptr = nullptr; + gComputeContextLoader.ComputeContextUpdate_ptr = nullptr; + gComputeContextLoader.ComputeContextRelease_ptr = nullptr; + gComputeContextLoader.ComputeShaderCreate_ptr = nullptr; + gComputeContextLoader.ComputeShaderRelease_ptr = nullptr; + gComputeContextLoader.ComputeConstantBufferCreate_ptr = nullptr; + gComputeContextLoader.ComputeConstantBufferRelease_ptr = nullptr; + gComputeContextLoader.ComputeConstantBufferMap_ptr = nullptr; + gComputeContextLoader.ComputeConstantBufferUnmap_ptr = nullptr; + gComputeContextLoader.ComputeResourceCreate_ptr = nullptr; + gComputeContextLoader.ComputeResourceUpdate_ptr = nullptr; + gComputeContextLoader.ComputeResourceRelease_ptr = nullptr; + gComputeContextLoader.ComputeResourceRWCreate_ptr = nullptr; + gComputeContextLoader.ComputeResourceRWUpdate_ptr = nullptr; + gComputeContextLoader.ComputeResourceRWRelease_ptr = nullptr; + gComputeContextLoader.ComputeResourceRWGetResource_ptr = nullptr; + gComputeContextLoader.ComputeContextDispatch_ptr = nullptr; + gComputeContextLoader.ComputeContextNvFlowContextCreate_ptr = nullptr; + gComputeContextLoader.ComputeContextNvFlowContextUpdate_ptr = nullptr; + gComputeContextLoader.ComputeResourceNvFlowCreate_ptr = nullptr; + gComputeContextLoader.ComputeResourceNvFlowUpdate_ptr = nullptr; + gComputeContextLoader.ComputeResourceRWNvFlowCreate_ptr = nullptr; + gComputeContextLoader.ComputeResourceRWNvFlowUpdate_ptr = nullptr; + + SDL_UnloadObject(gComputeContextLoader.module); +} diff --git a/demo/DemoApp/imguiGraphLoader.cpp b/demo/DemoApp/imguiGraphLoader.cpp index 155e9f3..f628196 100644 --- a/demo/DemoApp/imguiGraphLoader.cpp +++ b/demo/DemoApp/imguiGraphLoader.cpp @@ -15,111 +15,6 @@ #include "imguiGraph.h" #include "imguiInterop.h" -namespace -{ - ModuleLoader<24u, SDL_LoadObject, SDL_UnloadObject, SDL_LoadFunction> g_loader; -} +#include <stdio.h> -void loadImgui(AppGraphCtxType type) -{ - const char* moduleName = demoAppDLLName(type); - - g_loader.loadModule(moduleName); -} - -void unloadImgui() -{ - g_loader.unloadModule(); -} - -// Below are the functions that must be implemented per graphics API - -void imguiGraphContextInit(const ImguiGraphDesc* desc) -{ - return g_loader.function<0>(imguiGraphContextInit, "imguiGraphContextInit", desc); -} - -void imguiGraphContextUpdate(const ImguiGraphDesc* desc) -{ - return g_loader.function<1>(imguiGraphContextUpdate, "imguiGraphContextUpdate", desc); -} - -void imguiGraphContextDestroy() -{ - return g_loader.function<2>(imguiGraphContextDestroy, "imguiGraphContextDestroy"); -} - -void imguiGraphRecordBegin() -{ - return g_loader.function<3>(imguiGraphRecordBegin, "imguiGraphRecordBegin"); -} - -void imguiGraphRecordEnd() -{ - return g_loader.function<4>(imguiGraphRecordEnd, "imguiGraphRecordEnd"); -} - -void imguiGraphVertex2f(float x, float y) -{ - return g_loader.function<5>(imguiGraphVertex2f, "imguiGraphVertex2f", x, y); -} - -void imguiGraphVertex2fv(const float* v) -{ - return g_loader.function<6>(imguiGraphVertex2fv, "imguiGraphVertex2fv", v); -} - -void imguiGraphTexCoord2f(float u, float v) -{ - return g_loader.function<7>(imguiGraphTexCoord2f, "imguiGraphTexCoord2f", u, v); -} - -void imguiGraphColor4ub(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha) -{ - return g_loader.function<8>(imguiGraphColor4ub, "imguiGraphColor4ub", red, green, blue, alpha); -} - -void imguiGraphColor4ubv(const uint8_t* v) -{ - return g_loader.function<9>(imguiGraphColor4ubv, "imguiGraphColor4ubv", v); -} - -void imguiGraphFontTextureEnable() -{ - return g_loader.function<10>(imguiGraphFontTextureEnable, "imguiGraphFontTextureEnable"); -} - -void imguiGraphFontTextureDisable() -{ - return g_loader.function<11>(imguiGraphFontTextureDisable, "imguiGraphFontTextureDisable"); -} - -void imguiGraphEnableScissor(int x, int y, int width, int height) -{ - return g_loader.function<12>(imguiGraphEnableScissor, "imguiGraphEnableScissor", x, y, width, height); -} - -void imguiGraphDisableScissor() -{ - return g_loader.function<13>(imguiGraphDisableScissor, "imguiGraphDisableScissor"); -} - -void imguiGraphFontTextureInit(unsigned char* data) -{ - return g_loader.function<14>(imguiGraphFontTextureInit, "imguiGraphFontTextureInit",data); -} - -void imguiGraphFontTextureRelease() -{ - return g_loader.function<15>(imguiGraphFontTextureRelease, "imguiGraphFontTextureRelease"); -} - -bool imguiInteropGraphInit(imguiGraphInit_t func, const char* fontpath, AppGraphCtx* appctx) -{ - return g_loader.function<16>(imguiInteropGraphInit, "imguiInteropGraphInit", func, fontpath, appctx); -} - -void imguiInteropGraphUpdate(imguiGraphUpdate_t func, AppGraphCtx* appctx) -{ - return g_loader.function<17>(imguiInteropGraphUpdate, "imguiInteropGraphUpdate", func, appctx); -}
\ No newline at end of file +#include "imguiGraphLoaderGenerated.h"
\ No newline at end of file diff --git a/demo/DemoApp/imguiGraphLoaderGenerated.h b/demo/DemoApp/imguiGraphLoaderGenerated.h new file mode 100644 index 0000000..ab7ae55 --- /dev/null +++ b/demo/DemoApp/imguiGraphLoaderGenerated.h @@ -0,0 +1,204 @@ +/* +* Copyright (c) 2014-2017, NVIDIA CORPORATION. All rights reserved. +* +* NVIDIA CORPORATION and its licensors retain all intellectual property +* and proprietary rights in and to this software, related documentation +* and any modifications thereto. Any use, reproduction, disclosure or +* distribution of this software and related documentation without an express +* license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +typedef void (*imguiGraphContextInit_ptr_t)(const ImguiGraphDesc* desc); +typedef void (*imguiGraphContextUpdate_ptr_t)(const ImguiGraphDesc* desc); +typedef void (*imguiGraphContextDestroy_ptr_t)(); +typedef void (*imguiGraphRecordBegin_ptr_t)(); +typedef void (*imguiGraphRecordEnd_ptr_t)(); +typedef void (*imguiGraphVertex2f_ptr_t)(float x, float y); +typedef void (*imguiGraphVertex2fv_ptr_t)(const float* v); +typedef void (*imguiGraphTexCoord2f_ptr_t)(float u, float v); +typedef void (*imguiGraphColor4ub_ptr_t)(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha); +typedef void (*imguiGraphColor4ubv_ptr_t)(const uint8_t* v); +typedef void (*imguiGraphFontTextureEnable_ptr_t)(); +typedef void (*imguiGraphFontTextureDisable_ptr_t)(); +typedef void (*imguiGraphEnableScissor_ptr_t)(int x, int y, int width, int height); +typedef void (*imguiGraphDisableScissor_ptr_t)(); +typedef void (*imguiGraphFontTextureInit_ptr_t)(unsigned char* data); +typedef void (*imguiGraphFontTextureRelease_ptr_t)(); +typedef bool (*imguiInteropGraphInit_ptr_t)(imguiGraphInit_t func, const char* fontpath, AppGraphCtx* appctx); +typedef void (*imguiInteropGraphUpdate_ptr_t)(imguiGraphUpdate_t func, AppGraphCtx* appctx); + +struct ImguiLoader +{ + void* module = nullptr; + const char* suffix = ""; + char buf[1024u]; + + imguiGraphContextInit_ptr_t imguiGraphContextInit_ptr; + imguiGraphContextUpdate_ptr_t imguiGraphContextUpdate_ptr; + imguiGraphContextDestroy_ptr_t imguiGraphContextDestroy_ptr; + imguiGraphRecordBegin_ptr_t imguiGraphRecordBegin_ptr; + imguiGraphRecordEnd_ptr_t imguiGraphRecordEnd_ptr; + imguiGraphVertex2f_ptr_t imguiGraphVertex2f_ptr; + imguiGraphVertex2fv_ptr_t imguiGraphVertex2fv_ptr; + imguiGraphTexCoord2f_ptr_t imguiGraphTexCoord2f_ptr; + imguiGraphColor4ub_ptr_t imguiGraphColor4ub_ptr; + imguiGraphColor4ubv_ptr_t imguiGraphColor4ubv_ptr; + imguiGraphFontTextureEnable_ptr_t imguiGraphFontTextureEnable_ptr; + imguiGraphFontTextureDisable_ptr_t imguiGraphFontTextureDisable_ptr; + imguiGraphEnableScissor_ptr_t imguiGraphEnableScissor_ptr; + imguiGraphDisableScissor_ptr_t imguiGraphDisableScissor_ptr; + imguiGraphFontTextureInit_ptr_t imguiGraphFontTextureInit_ptr; + imguiGraphFontTextureRelease_ptr_t imguiGraphFontTextureRelease_ptr; + imguiInteropGraphInit_ptr_t imguiInteropGraphInit_ptr; + imguiInteropGraphUpdate_ptr_t imguiInteropGraphUpdate_ptr; + +}gImguiLoader; + +void imguiGraphContextInit(const ImguiGraphDesc* desc) +{ + return gImguiLoader.imguiGraphContextInit_ptr(desc); +} + +void imguiGraphContextUpdate(const ImguiGraphDesc* desc) +{ + return gImguiLoader.imguiGraphContextUpdate_ptr(desc); +} + +void imguiGraphContextDestroy() +{ + return gImguiLoader.imguiGraphContextDestroy_ptr(); +} + +void imguiGraphRecordBegin() +{ + return gImguiLoader.imguiGraphRecordBegin_ptr(); +} + +void imguiGraphRecordEnd() +{ + return gImguiLoader.imguiGraphRecordEnd_ptr(); +} + +void imguiGraphVertex2f(float x, float y) +{ + return gImguiLoader.imguiGraphVertex2f_ptr(x, y); +} + +void imguiGraphVertex2fv(const float* v) +{ + return gImguiLoader.imguiGraphVertex2fv_ptr(v); +} + +void imguiGraphTexCoord2f(float u, float v) +{ + return gImguiLoader.imguiGraphTexCoord2f_ptr(u, v); +} + +void imguiGraphColor4ub(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha) +{ + return gImguiLoader.imguiGraphColor4ub_ptr(red, green, blue, alpha); +} + +void imguiGraphColor4ubv(const uint8_t* v) +{ + return gImguiLoader.imguiGraphColor4ubv_ptr(v); +} + +void imguiGraphFontTextureEnable() +{ + return gImguiLoader.imguiGraphFontTextureEnable_ptr(); +} + +void imguiGraphFontTextureDisable() +{ + return gImguiLoader.imguiGraphFontTextureDisable_ptr(); +} + +void imguiGraphEnableScissor(int x, int y, int width, int height) +{ + return gImguiLoader.imguiGraphEnableScissor_ptr(x, y, width, height); +} + +void imguiGraphDisableScissor() +{ + return gImguiLoader.imguiGraphDisableScissor_ptr(); +} + +void imguiGraphFontTextureInit(unsigned char* data) +{ + return gImguiLoader.imguiGraphFontTextureInit_ptr(data); +} + +void imguiGraphFontTextureRelease() +{ + return gImguiLoader.imguiGraphFontTextureRelease_ptr(); +} + +bool imguiInteropGraphInit(imguiGraphInit_t func, const char* fontpath, AppGraphCtx* appctx) +{ + return gImguiLoader.imguiInteropGraphInit_ptr(func, fontpath, appctx); +} + +void imguiInteropGraphUpdate(imguiGraphUpdate_t func, AppGraphCtx* appctx) +{ + return gImguiLoader.imguiInteropGraphUpdate_ptr(func, appctx); +} + +void* imguiLoaderLoadFunction(ImguiLoader* inst, const char* name) +{ + snprintf(inst->buf, 1024u, "%s%s", name, inst->suffix); + + return SDL_LoadFunction(inst->module, inst->buf); +} + +void loadImgui(AppGraphCtxType type) +{ + const char* moduleName = demoAppDLLName(type); + + gImguiLoader.suffix = demoAppBackendSuffix(type); + + gImguiLoader.module = SDL_LoadObject(moduleName); + + gImguiLoader.imguiGraphContextInit_ptr = (imguiGraphContextInit_ptr_t)(imguiLoaderLoadFunction(&gImguiLoader, "imguiGraphContextInit")); + gImguiLoader.imguiGraphContextUpdate_ptr = (imguiGraphContextUpdate_ptr_t)(imguiLoaderLoadFunction(&gImguiLoader, "imguiGraphContextUpdate")); + gImguiLoader.imguiGraphContextDestroy_ptr = (imguiGraphContextDestroy_ptr_t)(imguiLoaderLoadFunction(&gImguiLoader, "imguiGraphContextDestroy")); + gImguiLoader.imguiGraphRecordBegin_ptr = (imguiGraphRecordBegin_ptr_t)(imguiLoaderLoadFunction(&gImguiLoader, "imguiGraphRecordBegin")); + gImguiLoader.imguiGraphRecordEnd_ptr = (imguiGraphRecordEnd_ptr_t)(imguiLoaderLoadFunction(&gImguiLoader, "imguiGraphRecordEnd")); + gImguiLoader.imguiGraphVertex2f_ptr = (imguiGraphVertex2f_ptr_t)(imguiLoaderLoadFunction(&gImguiLoader, "imguiGraphVertex2f")); + gImguiLoader.imguiGraphVertex2fv_ptr = (imguiGraphVertex2fv_ptr_t)(imguiLoaderLoadFunction(&gImguiLoader, "imguiGraphVertex2fv")); + gImguiLoader.imguiGraphTexCoord2f_ptr = (imguiGraphTexCoord2f_ptr_t)(imguiLoaderLoadFunction(&gImguiLoader, "imguiGraphTexCoord2f")); + gImguiLoader.imguiGraphColor4ub_ptr = (imguiGraphColor4ub_ptr_t)(imguiLoaderLoadFunction(&gImguiLoader, "imguiGraphColor4ub")); + gImguiLoader.imguiGraphColor4ubv_ptr = (imguiGraphColor4ubv_ptr_t)(imguiLoaderLoadFunction(&gImguiLoader, "imguiGraphColor4ubv")); + gImguiLoader.imguiGraphFontTextureEnable_ptr = (imguiGraphFontTextureEnable_ptr_t)(imguiLoaderLoadFunction(&gImguiLoader, "imguiGraphFontTextureEnable")); + gImguiLoader.imguiGraphFontTextureDisable_ptr = (imguiGraphFontTextureDisable_ptr_t)(imguiLoaderLoadFunction(&gImguiLoader, "imguiGraphFontTextureDisable")); + gImguiLoader.imguiGraphEnableScissor_ptr = (imguiGraphEnableScissor_ptr_t)(imguiLoaderLoadFunction(&gImguiLoader, "imguiGraphEnableScissor")); + gImguiLoader.imguiGraphDisableScissor_ptr = (imguiGraphDisableScissor_ptr_t)(imguiLoaderLoadFunction(&gImguiLoader, "imguiGraphDisableScissor")); + gImguiLoader.imguiGraphFontTextureInit_ptr = (imguiGraphFontTextureInit_ptr_t)(imguiLoaderLoadFunction(&gImguiLoader, "imguiGraphFontTextureInit")); + gImguiLoader.imguiGraphFontTextureRelease_ptr = (imguiGraphFontTextureRelease_ptr_t)(imguiLoaderLoadFunction(&gImguiLoader, "imguiGraphFontTextureRelease")); + gImguiLoader.imguiInteropGraphInit_ptr = (imguiInteropGraphInit_ptr_t)(imguiLoaderLoadFunction(&gImguiLoader, "imguiInteropGraphInit")); + gImguiLoader.imguiInteropGraphUpdate_ptr = (imguiInteropGraphUpdate_ptr_t)(imguiLoaderLoadFunction(&gImguiLoader, "imguiInteropGraphUpdate")); +} + +void unloadImgui() +{ + gImguiLoader.imguiGraphContextInit_ptr = nullptr; + gImguiLoader.imguiGraphContextUpdate_ptr = nullptr; + gImguiLoader.imguiGraphContextDestroy_ptr = nullptr; + gImguiLoader.imguiGraphRecordBegin_ptr = nullptr; + gImguiLoader.imguiGraphRecordEnd_ptr = nullptr; + gImguiLoader.imguiGraphVertex2f_ptr = nullptr; + gImguiLoader.imguiGraphVertex2fv_ptr = nullptr; + gImguiLoader.imguiGraphTexCoord2f_ptr = nullptr; + gImguiLoader.imguiGraphColor4ub_ptr = nullptr; + gImguiLoader.imguiGraphColor4ubv_ptr = nullptr; + gImguiLoader.imguiGraphFontTextureEnable_ptr = nullptr; + gImguiLoader.imguiGraphFontTextureDisable_ptr = nullptr; + gImguiLoader.imguiGraphEnableScissor_ptr = nullptr; + gImguiLoader.imguiGraphDisableScissor_ptr = nullptr; + gImguiLoader.imguiGraphFontTextureInit_ptr = nullptr; + gImguiLoader.imguiGraphFontTextureRelease_ptr = nullptr; + gImguiLoader.imguiInteropGraphInit_ptr = nullptr; + gImguiLoader.imguiInteropGraphUpdate_ptr = nullptr; + + SDL_UnloadObject(gImguiLoader.module); +} diff --git a/demo/DemoApp/loader.h b/demo/DemoApp/loader.h index 3028325..f0c1aaf 100644 --- a/demo/DemoApp/loader.h +++ b/demo/DemoApp/loader.h @@ -28,6 +28,13 @@ namespace "DemoAppD3D11" XDEMOAPP_STR(DLL_SUFFIX) ".dll"; } + const char* demoAppBackendSuffix(AppGraphCtxType type) + { + return (type == APP_CONTEXT_D3D12) ? + "D3D12" : + "D3D11"; + } + const char* nvFlowDLLName(AppGraphCtxType type) { return (type == APP_CONTEXT_D3D12) ? @@ -52,61 +59,4 @@ void loadImgui(AppGraphCtxType type); void unloadImgui(); void loadComputeContext(AppGraphCtxType type); -void unloadComputeContext(); - -template<unsigned int maxFunctionCount, void* loadobject(const char*), void unloadobject(void*), void* loadfunction(void*,const char*)> -struct ModuleLoader -{ - static const int m_functionCount = maxFunctionCount; - void** m_functionPtrs[m_functionCount] = { nullptr }; - const char* m_functionNames[m_functionCount] = { nullptr }; - - void* m_module = nullptr; - - void* loadFunction(const char* name, int uid, void** ptr) - { - m_functionPtrs[uid] = ptr; - m_functionNames[uid] = name; - return SDL_LoadFunction(m_module, name); - } - - template <int uid, class ret, class ...Args> - ret function(ret(*)(Args...args), const char* name, Args...args) - { - static void* func = loadFunction(name, uid, &func); - - return ((ret(*)(Args...args))func)(args...); - } - - void loadModule(const char* moduleName) - { - m_module = loadobject(moduleName); - - // load functions with non-null names - for (int i = 0; i < m_functionCount; i++) - { - const char* name = m_functionNames[i]; - void** funcPtr = m_functionPtrs[i]; - if (name && funcPtr) - { - *funcPtr = loadfunction(m_module, name); - } - } - } - - void unloadModule() - { - unloadobject(m_module); - - for (int i = 0; i < m_functionCount; i++) - { - void** funcPtr = m_functionPtrs[i]; - if (funcPtr) - { - *funcPtr = nullptr; - } - } - } - - ModuleLoader() {} -};
\ No newline at end of file +void unloadComputeContext();
\ No newline at end of file diff --git a/demo/DemoApp/main.cpp b/demo/DemoApp/main.cpp index e35ea43..45ccfa8 100644 --- a/demo/DemoApp/main.cpp +++ b/demo/DemoApp/main.cpp @@ -67,24 +67,18 @@ bool gImguiActive = false; bool g_imguiHide = false; bool gClearDark = false; -float gClearVal[4] = { 0.33f,0.33f,0.33f,1.f }; +AppGraphColor gClearVal = { 0.33f,0.33f,0.33f,1.f }; void toggleDark() { gClearDark = !gClearDark; if (gClearDark) { - gClearVal[0] = 0.f; - gClearVal[1] = 0.f; - gClearVal[2] = 0.f; - gClearVal[3] = 1.f; + gClearVal = { 0.f, 0.f, 0.f, 1.f }; } else { - gClearVal[0] = 0.33f; - gClearVal[1] = 0.33f; - gClearVal[2] = 0.33f; - gClearVal[3] = 1.f; + gClearVal = { 0.33f, 0.33f, 0.33f, 1.f }; } } diff --git a/demo/DemoApp/meshLoader.cpp b/demo/DemoApp/meshLoader.cpp index 99e5e49..2d70414 100644 --- a/demo/DemoApp/meshLoader.cpp +++ b/demo/DemoApp/meshLoader.cpp @@ -15,69 +15,6 @@ #include "mesh.h" #include "meshInterop.h" -namespace -{ - ModuleLoader<16u, SDL_LoadObject, SDL_UnloadObject, SDL_LoadFunction> g_loader; -} +#include <stdio.h> -void loadMesh(AppGraphCtxType type) -{ - const char* moduleName = demoAppDLLName(type); - - g_loader.loadModule(moduleName); -} - -void unloadMesh() -{ - g_loader.unloadModule(); -} - -MeshContext* MeshContextCreate(const MeshContextDesc* desc) -{ - return g_loader.function<0>(MeshContextCreate, "MeshContextCreate", desc); -} - -void MeshContextUpdate(MeshContext* context, const MeshContextDesc* desc) -{ - return g_loader.function<1>(MeshContextUpdate, "MeshContextUpdate", context, desc); -} - -void MeshContextRelease(MeshContext* context) -{ - return g_loader.function<2>(MeshContextRelease, "MeshContextRelease", context); -} - -MeshIndexBuffer* MeshIndexBufferCreate(MeshContext* context, MeshUint* indices, MeshUint numIndices) -{ - return g_loader.function<3>(MeshIndexBufferCreate, "MeshIndexBufferCreate", context, indices, numIndices); -} - -void MeshIndexBufferRelease(MeshIndexBuffer* buffer) -{ - return g_loader.function<4>(MeshIndexBufferRelease, "MeshIndexBufferRelease", buffer); -} - -MeshVertexBuffer* MeshVertexBufferCreate(MeshContext* context, MeshVertex* vertices, MeshUint numVertices) -{ - return g_loader.function<5>(MeshVertexBufferCreate, "MeshVertexBufferCreate", context, vertices, numVertices); -} - -void MeshVertexBufferRelease(MeshVertexBuffer* buffer) -{ - return g_loader.function<6>(MeshVertexBufferRelease, "MeshVertexBufferRelease", buffer); -} - -void MeshContextDraw(MeshContext* context, const MeshContextDrawParams* params) -{ - return g_loader.function<7>(MeshContextDraw, "MeshContextDraw", context, params); -} - -MeshContext* MeshInteropContextCreate(AppGraphCtx* appctx) -{ - return g_loader.function<8>(MeshInteropContextCreate, "MeshInteropContextCreate", appctx); -} - -void MeshInteropContextUpdate(MeshContext* context, AppGraphCtx* appctx) -{ - return g_loader.function<9>(MeshInteropContextUpdate, "MeshInteropContextUpdate", context, appctx); -}
\ No newline at end of file +#include "meshLoaderGenerated.h"
\ No newline at end of file diff --git a/demo/DemoApp/meshLoaderGenerated.h b/demo/DemoApp/meshLoaderGenerated.h new file mode 100644 index 0000000..c931f4f --- /dev/null +++ b/demo/DemoApp/meshLoaderGenerated.h @@ -0,0 +1,132 @@ +/* +* Copyright (c) 2014-2017, NVIDIA CORPORATION. All rights reserved. +* +* NVIDIA CORPORATION and its licensors retain all intellectual property +* and proprietary rights in and to this software, related documentation +* and any modifications thereto. Any use, reproduction, disclosure or +* distribution of this software and related documentation without an express +* license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +typedef MeshContext* (*MeshContextCreate_ptr_t)(const MeshContextDesc* desc); +typedef void (*MeshContextUpdate_ptr_t)(MeshContext* context, const MeshContextDesc* desc); +typedef void (*MeshContextRelease_ptr_t)(MeshContext* context); +typedef MeshIndexBuffer* (*MeshIndexBufferCreate_ptr_t)(MeshContext* context, MeshUint* indices, MeshUint numIndices); +typedef void (*MeshIndexBufferRelease_ptr_t)(MeshIndexBuffer* buffer); +typedef MeshVertexBuffer* (*MeshVertexBufferCreate_ptr_t)(MeshContext* context, MeshVertex* vertices, MeshUint numVertices); +typedef void (*MeshVertexBufferRelease_ptr_t)(MeshVertexBuffer* buffer); +typedef void (*MeshContextDraw_ptr_t)(MeshContext* context, const MeshContextDrawParams* params); +typedef MeshContext* (*MeshInteropContextCreate_ptr_t)(AppGraphCtx* appctx); +typedef void (*MeshInteropContextUpdate_ptr_t)(MeshContext* context, AppGraphCtx* appctx); + +struct MeshLoader +{ + void* module = nullptr; + const char* suffix = ""; + char buf[1024u]; + + MeshContextCreate_ptr_t MeshContextCreate_ptr; + MeshContextUpdate_ptr_t MeshContextUpdate_ptr; + MeshContextRelease_ptr_t MeshContextRelease_ptr; + MeshIndexBufferCreate_ptr_t MeshIndexBufferCreate_ptr; + MeshIndexBufferRelease_ptr_t MeshIndexBufferRelease_ptr; + MeshVertexBufferCreate_ptr_t MeshVertexBufferCreate_ptr; + MeshVertexBufferRelease_ptr_t MeshVertexBufferRelease_ptr; + MeshContextDraw_ptr_t MeshContextDraw_ptr; + MeshInteropContextCreate_ptr_t MeshInteropContextCreate_ptr; + MeshInteropContextUpdate_ptr_t MeshInteropContextUpdate_ptr; + +}gMeshLoader; + +MeshContext* MeshContextCreate(const MeshContextDesc* desc) +{ + return gMeshLoader.MeshContextCreate_ptr(desc); +} + +void MeshContextUpdate(MeshContext* context, const MeshContextDesc* desc) +{ + return gMeshLoader.MeshContextUpdate_ptr(context, desc); +} + +void MeshContextRelease(MeshContext* context) +{ + return gMeshLoader.MeshContextRelease_ptr(context); +} + +MeshIndexBuffer* MeshIndexBufferCreate(MeshContext* context, MeshUint* indices, MeshUint numIndices) +{ + return gMeshLoader.MeshIndexBufferCreate_ptr(context, indices, numIndices); +} + +void MeshIndexBufferRelease(MeshIndexBuffer* buffer) +{ + return gMeshLoader.MeshIndexBufferRelease_ptr(buffer); +} + +MeshVertexBuffer* MeshVertexBufferCreate(MeshContext* context, MeshVertex* vertices, MeshUint numVertices) +{ + return gMeshLoader.MeshVertexBufferCreate_ptr(context, vertices, numVertices); +} + +void MeshVertexBufferRelease(MeshVertexBuffer* buffer) +{ + return gMeshLoader.MeshVertexBufferRelease_ptr(buffer); +} + +void MeshContextDraw(MeshContext* context, const MeshContextDrawParams* params) +{ + return gMeshLoader.MeshContextDraw_ptr(context, params); +} + +MeshContext* MeshInteropContextCreate(AppGraphCtx* appctx) +{ + return gMeshLoader.MeshInteropContextCreate_ptr(appctx); +} + +void MeshInteropContextUpdate(MeshContext* context, AppGraphCtx* appctx) +{ + return gMeshLoader.MeshInteropContextUpdate_ptr(context, appctx); +} + +void* meshLoaderLoadFunction(MeshLoader* inst, const char* name) +{ + snprintf(inst->buf, 1024u, "%s%s", name, inst->suffix); + + return SDL_LoadFunction(inst->module, inst->buf); +} + +void loadMesh(AppGraphCtxType type) +{ + const char* moduleName = demoAppDLLName(type); + + gMeshLoader.suffix = demoAppBackendSuffix(type); + + gMeshLoader.module = SDL_LoadObject(moduleName); + + gMeshLoader.MeshContextCreate_ptr = (MeshContextCreate_ptr_t)(meshLoaderLoadFunction(&gMeshLoader, "MeshContextCreate")); + gMeshLoader.MeshContextUpdate_ptr = (MeshContextUpdate_ptr_t)(meshLoaderLoadFunction(&gMeshLoader, "MeshContextUpdate")); + gMeshLoader.MeshContextRelease_ptr = (MeshContextRelease_ptr_t)(meshLoaderLoadFunction(&gMeshLoader, "MeshContextRelease")); + gMeshLoader.MeshIndexBufferCreate_ptr = (MeshIndexBufferCreate_ptr_t)(meshLoaderLoadFunction(&gMeshLoader, "MeshIndexBufferCreate")); + gMeshLoader.MeshIndexBufferRelease_ptr = (MeshIndexBufferRelease_ptr_t)(meshLoaderLoadFunction(&gMeshLoader, "MeshIndexBufferRelease")); + gMeshLoader.MeshVertexBufferCreate_ptr = (MeshVertexBufferCreate_ptr_t)(meshLoaderLoadFunction(&gMeshLoader, "MeshVertexBufferCreate")); + gMeshLoader.MeshVertexBufferRelease_ptr = (MeshVertexBufferRelease_ptr_t)(meshLoaderLoadFunction(&gMeshLoader, "MeshVertexBufferRelease")); + gMeshLoader.MeshContextDraw_ptr = (MeshContextDraw_ptr_t)(meshLoaderLoadFunction(&gMeshLoader, "MeshContextDraw")); + gMeshLoader.MeshInteropContextCreate_ptr = (MeshInteropContextCreate_ptr_t)(meshLoaderLoadFunction(&gMeshLoader, "MeshInteropContextCreate")); + gMeshLoader.MeshInteropContextUpdate_ptr = (MeshInteropContextUpdate_ptr_t)(meshLoaderLoadFunction(&gMeshLoader, "MeshInteropContextUpdate")); +} + +void unloadMesh() +{ + gMeshLoader.MeshContextCreate_ptr = nullptr; + gMeshLoader.MeshContextUpdate_ptr = nullptr; + gMeshLoader.MeshContextRelease_ptr = nullptr; + gMeshLoader.MeshIndexBufferCreate_ptr = nullptr; + gMeshLoader.MeshIndexBufferRelease_ptr = nullptr; + gMeshLoader.MeshVertexBufferCreate_ptr = nullptr; + gMeshLoader.MeshVertexBufferRelease_ptr = nullptr; + gMeshLoader.MeshContextDraw_ptr = nullptr; + gMeshLoader.MeshInteropContextCreate_ptr = nullptr; + gMeshLoader.MeshInteropContextUpdate_ptr = nullptr; + + SDL_UnloadObject(gMeshLoader.module); +} diff --git a/demo/DemoApp/preset0.h b/demo/DemoApp/preset0.h index aba3666..5e37ac4 100644 --- a/demo/DemoApp/preset0.h +++ b/demo/DemoApp/preset0.h @@ -13,7 +13,9 @@ const ImserNode g_root[] = { imserNodeValue1f("Velocity", 0.500000f), imserNodeValue1f("Smoke", 0.500000f), imserNodeGroupEnd(), - imserNodeValue1f("Vorticity Strength", 9.000000f), + imserNodeGroupBegin("Vorticity Confinement"), + imserNodeValue1f("Strength", 9.000000f), + imserNodeGroupEnd(), imserNodeGroupBegin("Combustion"), imserNodeValue1f("Ignition Temp", 0.050000f), imserNodeValue1f("Cooling Rate", 1.500000f), diff --git a/demo/DemoApp/preset1.h b/demo/DemoApp/preset1.h index dded481..2f502e6 100644 --- a/demo/DemoApp/preset1.h +++ b/demo/DemoApp/preset1.h @@ -13,7 +13,9 @@ const ImserNode g_root[] = { imserNodeValue1f("Velocity", 0.500000f), imserNodeValue1f("Smoke", 0.500000f), imserNodeGroupEnd(), - imserNodeValue1f("Vorticity Strength", 9.000000f), + imserNodeGroupBegin("Vorticity Confinement"), + imserNodeValue1f("Strength", 9.000000f), + imserNodeGroupEnd(), imserNodeGroupBegin("Combustion"), imserNodeValue1f("Ignition Temp", 0.050000f), imserNodeValue1f("Cooling Rate", 1.500000f), diff --git a/demo/DemoApp/scene.cpp b/demo/DemoApp/scene.cpp index 3ad7cce..399d4d8 100644 --- a/demo/DemoApp/scene.cpp +++ b/demo/DemoApp/scene.cpp @@ -43,8 +43,9 @@ namespace Scenes SceneSimpleFlameFuelMap sceneSimpleFlameFuelMap; SceneSimpleFlameParticleSurface sceneParticleSurface; SceneSimpleFlameBall sceneSimpleFlameBall; + SceneEmitSubStep sceneEmitSubStep; - const int count = 18; + const int count = 19; Scene* list[count] = { &scene2DTextureEmitter1, &scene2DTextureEmitter2, @@ -64,7 +65,8 @@ namespace Scenes &sceneSimpleFlame2, &sceneSimpleFlameFuelMap, &sceneParticleSurface, - &sceneSimpleFlameBall + &sceneSimpleFlameBall, + &sceneEmitSubStep }; }; @@ -115,6 +117,10 @@ void pointsToImage(NvFlowFloat4* image, int imageDim, const CurvePoint* pts, int void Scene::update(float dt) { + m_deltaTime = dt; + + doFrameUpdate(m_deltaTime); + int numSteps = m_timeStepper.getNumSteps(dt); for (int i = 0; i < numSteps; i++) @@ -233,6 +239,22 @@ void SceneFluid::imguiDesc() m_shouldGridReset = true; } + if (imguiCheck("Auto Reset", m_autoResetMode, true)) + { + m_autoResetMode = !m_autoResetMode; + m_autoResetTime = 0.f; + } + if (m_autoResetMode) + { + m_autoResetTime += m_deltaTime; + if (m_autoResetTime > m_autoResetThresh) + { + m_shouldReset = true; + m_autoResetTime = 0.f; + m_autoResetThresh = 5.f * (1.f / 255.f) * float((rand() & 255)); + } + } + float cellSizeLogf = float(m_flowGridActor.m_cellSizeLogScale); if (imguiserSlider("Cell Size Log Scale", &cellSizeLogf, -6.f, 6.f, 1.f, true)) { @@ -271,6 +293,11 @@ void SceneFluid::imguiFluidSim() imguiserSlider("Fuel", &m_flowGridActor.m_materialParams.fuel.fade, 0.f, 1.f, 0.01f, true); imguiserEndGroup(); + if (imguiCheck("Single Pass Advect", m_flowGridActor.m_gridParams.singlePassAdvection, true)) + { + m_flowGridActor.m_gridParams.singlePassAdvection = !m_flowGridActor.m_gridParams.singlePassAdvection; + } + imguiSeparator(); imguiLabel("MacCormack Correction"); imguiserBeginGroup("MacCormack Correction", nullptr); @@ -287,8 +314,16 @@ void SceneFluid::imguiFluidSim() imguiserSlider("Fuel", &m_flowGridActor.m_materialParams.fuel.macCormackBlendThreshold, 0.f, 0.01f, 0.001f, true); imguiserEndGroup(); - imguiserSlider("Vorticity Strength", &m_flowGridActor.m_materialParams.vorticityStrength, 0.f, 20.f, 0.1f, true); - imguiserSlider("Vorticity Vel Mask", &m_flowGridActor.m_materialParams.vorticityVelocityMask, 0.f, 1.f, 0.01f, true); + imguiSeparator(); + imguiLabel("Vorticity Confinement"); + imguiserBeginGroup("Vorticity Confinement", nullptr); + imguiserSlider("Strength", &m_flowGridActor.m_materialParams.vorticityStrength, 0.f, 20.f, 0.1f, true); + imguiserSlider("Velocity Mask", &m_flowGridActor.m_materialParams.vorticityVelocityMask, -1.f, 1.f, 0.01f, true); + imguiserSlider("Temperature Mask", &m_flowGridActor.m_materialParams.vorticityTemperatureMask, -1.f, 1.f, 0.01f, true); + imguiserSlider("Smoke Mask", &m_flowGridActor.m_materialParams.vorticitySmokeMask, -1.f, 1.f, 0.01f, true); + imguiserSlider("Fuel Mask", &m_flowGridActor.m_materialParams.vorticityFuelMask, -1.f, 1.f, 0.01f, true); + imguiserSlider("Constant Mask", &m_flowGridActor.m_materialParams.vorticityConstantMask, -1.f, 1.f, 0.01f, true); + imguiserEndGroup(); if (imguiCheck("Legacy Pressure", m_flowGridActor.m_gridParams.pressureLegacyMode, true)) { @@ -497,6 +532,21 @@ void SceneFluid::imguiFluidRender() imguiserSlider("Vector Length", &m_flowGridActor.m_crossSectionParams.vectorLengthScale, 0.1f, 2.f, 0.01f, true); } + imguiLabel("Grid Summary"); + imguiserBeginGroup("Grid Summary", nullptr); + if (imguiserCheck("Enabled", m_flowGridActor.m_enableGridSummary, true)) + { + m_flowGridActor.m_enableGridSummary = !m_flowGridActor.m_enableGridSummary; + } + if (m_flowGridActor.m_enableGridSummary) + { + if (imguiserCheck("Debug Render", m_flowGridActor.m_enableGridSummaryDebugVis, true)) + { + m_flowGridActor.m_enableGridSummaryDebugVis = !m_flowGridActor.m_enableGridSummaryDebugVis; + } + } + imguiserEndGroup(); + imguiFluidRenderExtra(); imguiserEndGroup(); } @@ -549,6 +599,12 @@ void SceneFluid::imguiFluidAlloc() imguiserSlider("Temp Threshold", &m_flowGridActor.m_materialParams.temperature.allocThreshold, 0.f, 1.f, 0.01f, true); imguiserSlider("Fuel Threshold", &m_flowGridActor.m_materialParams.fuel.allocThreshold, 0.f, 1.f, 0.01f, true); + if (imguiCheck("Translation Test", m_flowGridActor.m_enableTranslationTest, true)) + { + m_flowGridActor.m_enableTranslationTest = !m_flowGridActor.m_enableTranslationTest; + } + imguiSlider("Test Time Scale", &m_flowGridActor.m_translationTimeScale, 0.25f, 8.f, 0.1f, true); + imguiFluidAllocExtra(); imguiserEndGroup(); } @@ -678,37 +734,45 @@ bool SceneFluid::getStats(int lineIdx, int statIdx, char* buf) } case 1: { + float simRate = (1.f / m_flowContext.m_statUpdateDt) * + float(m_flowContext.m_statUpdateSuccessCount / + m_flowContext.m_statUpdateAttemptCount); + snprintf(buf, 79, "SimRate: %.3f Hz", simRate); + return true; + } + case 2: + { NvFlowUint numLayers = m_flowGridActor.m_statNumLayers; snprintf(buf, 79, "NumLayers: %d layers", numLayers); return true; } - case 2: + case 3: { NvFlowUint numBlocks = m_flowGridActor.m_statNumDensityBlocks; NvFlowUint maxBlocks = m_flowGridActor.m_statMaxDensityBlocks; snprintf(buf, 79, "Density: %d blocks active of %d", numBlocks, maxBlocks); return true; } - case 3: + case 4: { NvFlowUint numBlocks = m_flowGridActor.m_statNumVelocityBlocks; NvFlowUint maxBlocks = m_flowGridActor.m_statMaxVelocityBlocks; snprintf(buf, 79, "Velocity: %d blocks active of %d", numBlocks, maxBlocks); return true; } - case 4: + case 5: { NvFlowUint numCells = m_flowGridActor.m_statNumDensityCells; snprintf(buf, 79, "Density: %d cells active", numCells); return true; } - case 5: + case 6: { NvFlowUint numCells = m_flowGridActor.m_statNumVelocityCells; snprintf(buf, 79, "Velocity: %d cells active", numCells); return true; } - case 6: + case 7: { if (m_flowGridActor.m_statVolumeShadowBlocks > 0u) { @@ -718,7 +782,7 @@ bool SceneFluid::getStats(int lineIdx, int statIdx, char* buf) } return false; } - case 7: + case 8: { if (m_flowGridActor.m_statVolumeShadowCells > 0u) { diff --git a/demo/DemoApp/scene.h b/demo/DemoApp/scene.h index fee39e4..da88e1d 100644 --- a/demo/DemoApp/scene.h +++ b/demo/DemoApp/scene.h @@ -31,6 +31,7 @@ struct TimeStepper float m_timeError = 0.f; float m_fixedDt = (1.f / 60.f); int m_maxSteps = 1; + int m_numSteps = 0; TimeStepper() {} @@ -41,14 +42,15 @@ struct TimeStepper // compute time steps m_timeError += m_deltaTime; - int numSteps = int(m_timeError / m_fixedDt); - if (numSteps < 0) numSteps = 0; + m_numSteps = int(floorf((m_timeError / m_fixedDt))); - m_timeError -= m_fixedDt * float(numSteps); + if (m_numSteps < 0) m_numSteps = 0; - if (numSteps > m_maxSteps) numSteps = m_maxSteps; + m_timeError -= m_fixedDt * float(m_numSteps); - return numSteps; + if (m_numSteps > m_maxSteps) m_numSteps = m_maxSteps; + + return m_numSteps; } }; @@ -82,7 +84,10 @@ struct Scene int m_winw = 0; int m_winh = 0; + float m_deltaTime = 0.f; + protected: + virtual void doFrameUpdate(float dt) {} virtual void doUpdate(float dt) = 0; AppGraphCtx* m_context = nullptr; @@ -145,13 +150,17 @@ struct FlowContext int m_maxFramesInFlight = 3u; int m_framesInFlight = 0; + double m_statUpdateAttemptCount = 0.0; + double m_statUpdateSuccessCount = 0.0; + float m_statUpdateDt = 0.f; + FlowContext() {} ~FlowContext() {} void init(AppGraphCtx* appctx); void release(); - bool updateBegin(); + bool updateBegin(float dt); void updateEnd(); void preDrawBegin(); void preDrawEnd(); @@ -174,6 +183,8 @@ struct FlowGridActor NvFlowVolumeRender* m_volumeRender = nullptr; NvFlowVolumeShadow* m_volumeShadow = nullptr; NvFlowCrossSection* m_crossSection = nullptr; + NvFlowGridSummary* m_gridSummary = nullptr; + NvFlowGridSummaryStateCPU* m_gridSummaryStateCPU = nullptr; NvFlowGridDesc m_gridDesc; NvFlowGridParams m_gridParams; @@ -216,6 +227,16 @@ struct FlowGridActor float m_crossSectionBackgroundColor = 0.f; NvFlowFloat3 m_crossSectionLineColor = { 141.f / 255.f, 199.f / 255.f, 63.f / 255.f }; + bool m_enableGridSummary = false; + bool m_enableGridSummaryDebugVis = false; + + bool m_enableTranslationTest = false; + float m_translationTimeScale = 1.f; + bool m_enableTranslationTestOld = false; + float m_translationTestTime = 0.f; + NvFlowFloat3 m_translationOffsetA = { +4.f, 0.f, 0.f }; + NvFlowFloat3 m_translationOffsetB = { -4.f, 0.f, 0.f }; + NvFlowUint m_statNumLayers = 0u; NvFlowUint m_statNumDensityBlocks = 0u; NvFlowUint m_statNumDensityCells = 0u; @@ -341,6 +362,10 @@ struct SceneFluid : public Scene bool m_shouldGridReset = false; bool m_shouldLoadPreset = false; + bool m_autoResetMode = false; + float m_autoResetTime = 0.f; + float m_autoResetThresh = 0.f; + virtual bool shouldReset() { return m_shouldReset; } virtual void reset(); }; @@ -550,6 +575,22 @@ struct SceneSimpleFlameAnimated : public SceneSimpleFlame m_emitParams.bounds.w.x = 2.f * cosf(rate * time); m_emitParams.bounds.w.z = 2.f * sinf(rate * time); + // testing hack + //static int offset = 0; + //offset++; + //if (offset > 4) + //{ + // offset = 0; + //} + //m_emitParams.bounds.w.z += float(offset) - 4.f; + + //NvFlowFloat3 gridLocation = { m_emitParams.bounds.w.x, 0.f, m_emitParams.bounds.w.z }; + //NvFlowGridSetTargetLocation(m_flowGridActor.m_grid, gridLocation); + + //bool parity = (time - floorf(time)) > 0.5f; + //NvFlowFloat3 gridLocation = parity ? NvFlowFloat3{-4.f, 0.f, 0.f} : NvFlowFloat3{+4.f, 0.f, 0.f}; + //NvFlowGridSetTargetLocation(m_flowGridActor.m_grid, gridLocation); + m_emitParams.velocityLinear.x = +8.f * sinf(rate * time); m_emitParams.velocityLinear.y = -2.f; m_emitParams.velocityLinear.z = -8.f * cosf(rate * time); @@ -681,6 +722,8 @@ struct SceneSimpleFlameCapsule : public SceneSimpleFlame float m_capsuleLength = 0.75f; float m_distanceScale = 3.5f; bool m_boxMode = false; + bool m_flameSpread = false; + bool m_flameSpreadOld = false; }; struct Scene2DTextureEmitter : public SceneFluid @@ -831,6 +874,31 @@ struct SceneCustomEmit : public SceneFluid bool m_fullDomain = false; }; +struct SceneEmitSubStep : public SceneFluid +{ + SceneEmitSubStep() : SceneFluid("Emit Sub Step") {} + + virtual void initParams(); + virtual void init(AppGraphCtx* context, int winw, int winh); + virtual void doFrameUpdate(float dt); + virtual void doUpdate(float dt); + virtual void preDraw(); + virtual void draw(DirectX::CXMMATRIX projection, DirectX::CXMMATRIX view); + virtual void release(); + virtual void imgui(int x, int y, int w, int h); + + virtual void imguiFluidEmitterExtra(); + + void emitSubSteps(float t_old, float x_old, float t_new, float x_new, float frame_dt); + void emitImpulse(float x, float impulse_dt); + + float anim_t = 0.f; + float anim_x = -1.f; + float anim_x_old = 0.f; + + TimeStepper m_emitterTimeStepper; +}; + Scene* getScene(int index); void pointsToImage(NvFlowFloat4* image, int imageDim, const CurvePoint* pts, int numPts); diff --git a/demo/DemoApp/scene2DTextureEmitter.cpp b/demo/DemoApp/scene2DTextureEmitter.cpp index c2d3984..c5b0197 100644 --- a/demo/DemoApp/scene2DTextureEmitter.cpp +++ b/demo/DemoApp/scene2DTextureEmitter.cpp @@ -130,7 +130,7 @@ void Scene2DTextureEmitter::init(AppGraphCtx* appctx, int winw, int winh) void Scene2DTextureEmitter::doUpdate(float dt) { - bool shouldUpdate = m_flowContext.updateBegin(); + bool shouldUpdate = m_flowContext.updateBegin(dt); if (shouldUpdate) { AppGraphCtxProfileBegin(m_appctx, "Simulate"); diff --git a/demo/DemoApp/sceneCustomEmit.cpp b/demo/DemoApp/sceneCustomEmit.cpp index c52db59..8c97150 100644 --- a/demo/DemoApp/sceneCustomEmit.cpp +++ b/demo/DemoApp/sceneCustomEmit.cpp @@ -120,7 +120,7 @@ void SceneCustomEmit::init(AppGraphCtx* appctx, int winw, int winh) void SceneCustomEmit::doUpdate(float dt) { - bool shouldUpdate = m_flowContext.updateBegin(); + bool shouldUpdate = m_flowContext.updateBegin(dt); if (shouldUpdate) { ComputeContextNvFlowContextUpdate(m_customContext, m_flowContext.m_gridContext); diff --git a/demo/DemoApp/sceneEmitSubStep.cpp b/demo/DemoApp/sceneEmitSubStep.cpp new file mode 100644 index 0000000..76c0115 --- /dev/null +++ b/demo/DemoApp/sceneEmitSubStep.cpp @@ -0,0 +1,204 @@ +/* +* Copyright (c) 2014-2017, NVIDIA CORPORATION. All rights reserved. +* +* NVIDIA CORPORATION and its licensors retain all intellectual property +* and proprietary rights in and to this software, related documentation +* and any modifications thereto. Any use, reproduction, disclosure or +* distribution of this software and related documentation without an express +* license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +#include <stdio.h> +#include <string.h> + +#include "loader.h" +#include "imgui.h" +#include "imguiser.h" + +namespace PresetFlame +{ +#include "presetFlame.h" +} + +#include "scene.h" + +#include <SDL.h> + +void SceneEmitSubStep::initParams() +{ + m_flowGridActor.initParams(AppGraphCtxDedicatedVideoMemory(m_appctx)); + + // set emitter defaults + NvFlowGridEmitParamsDefaults(&m_emitParams); + + // configure emitter params + m_emitParams.bounds.x.x = 0.25f; + m_emitParams.bounds.y.y = 0.25f; + m_emitParams.bounds.z.z = 0.25f; + m_emitParams.velocityLinear.y = 8.f; + m_emitParams.fuel = 1.9f; + m_emitParams.smoke = 0.5f; + + m_shouldLoadPreset = true; +} + +void SceneEmitSubStep::init(AppGraphCtx* appctx, int winw, int winh) +{ + m_appctx = appctx; + + if (!m_shouldReset || m_isFirstRun) + { + initParams(); + m_isFirstRun = false; + } + + m_flowContext.init(appctx); + + m_flowGridActor.init(&m_flowContext, appctx); + + // create default color map + { + const int numPoints = 5; + const CurvePoint pts[numPoints] = { + { 0.f, 0.f,0.f,0.f,0.f }, + { 0.05f, 0.f,0.f,0.f,0.5f }, + { 0.6f, 213.f / 255.f,100.f / 255.f,30.f / 255.f,0.8f }, + { 0.85f, 255.f / 255.f,240.f / 255.f,0.f,0.8f }, + { 1.f, 1.f,1.f,1.f,0.7f } + }; + + auto& colorMap = m_flowGridActor.m_colorMap; + colorMap.initColorMap(m_flowContext.m_renderContext, pts, numPoints, (colorMap.m_curvePointsDefault.size() == 0)); + } + + m_projectile.init(m_appctx, m_flowContext.m_gridContext); + + resize(winw, winh); +} + +void SceneEmitSubStep::emitImpulse(float x, float impulse_dt) +{ + NvFlowShapeDesc shapeDesc; + shapeDesc.sphere.radius = 0.8f; + + m_emitParams.bounds.w.x = x; + + m_emitParams.localToWorld = m_emitParams.bounds; + m_emitParams.shapeType = eNvFlowShapeTypeSphere; + m_emitParams.deltaTime = impulse_dt; + + NvFlowGridEmit(m_flowGridActor.m_grid, &shapeDesc, 1u, &m_emitParams, 1u); +} + +void SceneEmitSubStep::emitSubSteps(float t_old, float x_old, float t_new, float x_new, float frame_dt) +{ + float emitImpulse_dt = m_emitterTimeStepper.m_fixedDt; + + int numSteps = m_emitterTimeStepper.getNumSteps(frame_dt); + + for (int i = 0; i < numSteps; i++) + { + int substep_i = numSteps - 1 - i; + + float substep_t = emitImpulse_dt * substep_i + m_emitterTimeStepper.m_timeError; + + float s = (substep_t - t_new) / (t_old - t_new); + float x = (1.f - s) * x_new + s * x_old; + + emitImpulse(x, emitImpulse_dt); + } +} + +void SceneEmitSubStep::doFrameUpdate(float frame_dt) +{ + m_emitterTimeStepper.m_fixedDt = 1.f / 1200.f; + m_emitterTimeStepper.m_maxSteps = 1000; + + anim_x_old = anim_x; + + anim_t += frame_dt; + + const float freq = 60.f; + const float k = 2.f * freq; + const float k_dt = 1.f / freq; + + if (anim_t > (2.f * k_dt)) + { + anim_t -= (2.f * k_dt); + } + + anim_x = k * fabs(anim_t - k_dt) - 1.f; + + float t_old = frame_dt; + float t_new = 0.f; + + emitSubSteps(t_old, anim_x_old, t_new, anim_x, frame_dt); +} + +void SceneEmitSubStep::doUpdate(float dt) +{ + bool shouldUpdate = m_flowContext.updateBegin(dt); + if (shouldUpdate) + { + AppGraphCtxProfileBegin(m_appctx, "Simulate"); + + m_flowGridActor.updatePreEmit(&m_flowContext, dt); + + // emit + { + m_projectile.update(m_flowContext.m_gridContext, m_flowGridActor.m_grid, dt); + } + + m_flowGridActor.updatePostEmit(&m_flowContext, dt, shouldUpdate, m_shouldGridReset); + + m_shouldGridReset = false; + + AppGraphCtxProfileEnd(m_appctx, "Simulate"); + } + m_flowContext.updateEnd(); +} + +void SceneEmitSubStep::preDraw() +{ + m_flowContext.preDrawBegin(); + + m_flowGridActor.preDraw(&m_flowContext); + + m_flowContext.preDrawEnd(); +} + +void SceneEmitSubStep::draw(DirectX::CXMMATRIX projection, DirectX::CXMMATRIX view) +{ + m_projectile.draw(projection, view); + + m_flowContext.drawBegin(); + + m_flowGridActor.draw(&m_flowContext, projection, view); + + m_flowContext.drawEnd(); +} + +void SceneEmitSubStep::release() +{ + m_projectile.release(); + + m_flowGridActor.release(); + + m_flowContext.release(); +} + +void SceneEmitSubStep::imgui(int xIn, int yIn, int wIn, int hIn) +{ + SceneFluid::imgui(xIn, yIn, wIn, hIn); + + if (m_shouldLoadPreset) + { + imguiserLoadC(PresetFlame::g_root, sizeof(PresetFlame::g_root)); + m_shouldLoadPreset = false; + } +} + +void SceneEmitSubStep::imguiFluidEmitterExtra() +{ + +}
\ No newline at end of file diff --git a/demo/DemoApp/sceneFlow.cpp b/demo/DemoApp/sceneFlow.cpp index 80f87b1..5cdb70a 100644 --- a/demo/DemoApp/sceneFlow.cpp +++ b/demo/DemoApp/sceneFlow.cpp @@ -205,7 +205,7 @@ void FlowContext::computeContextEnd() } } -bool FlowContext::updateBegin() +bool FlowContext::updateBegin(float dt) { m_framesInFlight = computeContextBegin(); bool shouldFlush = (m_framesInFlight < m_maxFramesInFlight); @@ -217,6 +217,12 @@ bool FlowContext::updateBegin() NvFlowContextFlushRequestPush(m_renderCopyContext); } + m_statUpdateAttemptCount += 1.0; + if (shouldFlush) m_statUpdateSuccessCount += 1.0; + m_statUpdateAttemptCount *= 0.99; + m_statUpdateSuccessCount *= 0.99; + m_statUpdateDt = dt; + return shouldFlush; } @@ -357,6 +363,12 @@ void FlowGridActor::init(FlowContext* flowContext, AppGraphCtx* appctx) m_crossSection = NvFlowCreateCrossSection(flowContext->m_renderContext, &crossSectionDesc); + NvFlowGridSummaryDesc gridSummaryDesc = {}; + gridSummaryDesc.gridExport = gridExport; + + m_gridSummary = NvFlowCreateGridSummary(flowContext->m_gridContext, &gridSummaryDesc); + m_gridSummaryStateCPU = NvFlowCreateGridSummaryStateCPU(m_gridSummary); + NvFlowRenderMaterialPoolDesc materialPoolDesc = {}; materialPoolDesc.colorMapResolution = 64u; m_colorMap.m_materialPool = NvFlowCreateRenderMaterialPool(flowContext->m_renderContext, &materialPoolDesc); @@ -393,6 +405,8 @@ void FlowGridActor::release() NvFlowReleaseGridProxy(m_gridProxy); NvFlowReleaseVolumeRender(m_volumeRender); NvFlowReleaseCrossSection(m_crossSection); + NvFlowReleaseGridSummary(m_gridSummary); + NvFlowReleaseGridSummaryStateCPU(m_gridSummaryStateCPU); NvFlowReleaseRenderMaterialPool(m_colorMap.m_materialPool); if (m_volumeShadow) NvFlowReleaseVolumeShadow(m_volumeShadow); m_volumeShadow = nullptr; @@ -405,6 +419,25 @@ void FlowGridActor::updatePreEmit(FlowContext* flowContext, float dt) NvFlowRenderMaterialUpdate(m_colorMap.m_materialDefault, &m_renderMaterialDefaultParams); NvFlowRenderMaterialUpdate(m_colorMap.m_material0, &m_renderMaterialMat0Params); NvFlowRenderMaterialUpdate(m_colorMap.m_material1, &m_renderMaterialMat1Params); + + if (m_enableTranslationTest) + { + m_enableTranslationTestOld = true; + + m_translationTestTime += m_translationTimeScale * dt; + if (m_translationTestTime > 120.f) m_translationTestTime = 0.f; + + bool parity = (m_translationTestTime - floorf(m_translationTestTime)) > 0.5f; + NvFlowFloat3 gridLocation = parity ? m_translationOffsetA : m_translationOffsetB; + NvFlowGridSetTargetLocation(m_grid, gridLocation); + } + else if(m_enableTranslationTestOld) + { + NvFlowFloat3 gridLocation = NvFlowFloat3{ 0.f, 0.f, 0.f }; + NvFlowGridSetTargetLocation(m_grid, gridLocation); + + m_enableTranslationTestOld = false; + } } void FlowGridActor::updatePostEmit(FlowContext* flowContext, float dt, bool shouldUpdate, bool shouldReset) @@ -492,6 +525,27 @@ void FlowGridActor::updatePostEmit(FlowContext* flowContext, float dt, bool shou } auto gridExport = NvFlowGridGetGridExport(flowContext->m_gridContext, m_grid); + + if (m_enableGridSummary) + { + NvFlowGridSummaryUpdateParams updateParams = {}; + updateParams.gridExport = gridExport; + updateParams.stateCPU = m_gridSummaryStateCPU; + + NvFlowGridSummaryUpdate(m_gridSummary, flowContext->m_gridContext, &updateParams); + + NvFlowUint numLayers = NvFlowGridSummaryGetNumLayers(m_gridSummaryStateCPU); + for (NvFlowUint layerIdx = 0u; layerIdx < numLayers; layerIdx++) + { + NvFlowGridSummaryResult* results = nullptr; + NvFlowUint numResults = 0u; + + NvFlowGridSummaryGetSummaries(m_gridSummaryStateCPU, &results, &numResults, layerIdx); + + //printf("GridSummary layer(%d) numResults(%d)", layerIdx, numResults); + } + } + NvFlowGridProxyFlushParams flushParams = {}; flushParams.gridContext = flowContext->m_gridContext; flushParams.gridCopyContext = flowContext->m_gridCopyContext; @@ -686,6 +740,20 @@ void FlowGridActor::draw(FlowContext* flowContext, DirectX::CXMMATRIX projection NvFlowVolumeShadowDebugRender(m_volumeShadow, flowContext->m_renderContext, ¶ms); } + + if (m_enableGridSummary && m_enableGridSummaryDebugVis) + { + NvFlowGridSummaryDebugRenderParams params = {}; + + params.stateCPU = m_gridSummaryStateCPU; + + params.renderTargetView = flowContext->m_rtv; + + memcpy(¶ms.projectionMatrix, &projection, sizeof(NvFlowFloat4x4)); + memcpy(¶ms.viewMatrix, &view, sizeof(NvFlowFloat4x4)); + + NvFlowGridSummaryDebugRender(m_gridSummary, flowContext->m_renderContext, ¶ms); + } } // *********************** Flow Color Map ***************************************** diff --git a/demo/DemoApp/sceneSDF.cpp b/demo/DemoApp/sceneSDF.cpp index 301e260..1e6ad08 100644 --- a/demo/DemoApp/sceneSDF.cpp +++ b/demo/DemoApp/sceneSDF.cpp @@ -138,7 +138,7 @@ void SceneSDFTest::init(AppGraphCtx* appctx, int winw, int winh) void SceneSDFTest::doUpdate(float dt) { - bool shouldUpdate = m_flowContext.updateBegin(); + bool shouldUpdate = m_flowContext.updateBegin(dt); if (shouldUpdate) { AppGraphCtxProfileBegin(m_appctx, "Simulate"); @@ -285,7 +285,7 @@ void SceneCustomLighting::init(AppGraphCtx* context, int winw, int winh) void SceneCustomLighting::doUpdate(float dt) { - bool shouldUpdate = m_flowContext.updateBegin(); + bool shouldUpdate = m_flowContext.updateBegin(dt); if (shouldUpdate) { ComputeContextNvFlowContextUpdate(m_computeContext, m_flowContext.m_renderContext); diff --git a/demo/DemoApp/sceneSimpleFlame.cpp b/demo/DemoApp/sceneSimpleFlame.cpp index 60b134b..5cd69cc 100644 --- a/demo/DemoApp/sceneSimpleFlame.cpp +++ b/demo/DemoApp/sceneSimpleFlame.cpp @@ -106,7 +106,7 @@ void SceneSimpleFlame::init(AppGraphCtx* appctx, int winw, int winh) void SceneSimpleFlame::doUpdate(float dt) { - bool shouldUpdate = m_flowContext.updateBegin(); + bool shouldUpdate = m_flowContext.updateBegin(dt); if (shouldUpdate) { AppGraphCtxProfileBegin(m_appctx, "Simulate"); @@ -191,6 +191,7 @@ void SceneSimpleFlameDouble::init(AppGraphCtx* context, int winw, int winh) materialParams.vorticityStrength = 5.f; materialParams.vorticityVelocityMask = 0.f; + materialParams.vorticityConstantMask = 1.f; materialParams.velocity.macCormackBlendFactor = 0.f; materialParams.smoke.macCormackBlendFactor = 0.75f; materialParams.buoyancyPerTemp *= 5.f; @@ -203,13 +204,17 @@ void SceneSimpleFlameDouble::init(AppGraphCtx* context, int winw, int winh) void SceneSimpleFlameDouble::doUpdate(float dt) { - bool shouldUpdate = m_flowContext.updateBegin(); + bool shouldUpdate = m_flowContext.updateBegin(dt); if (shouldUpdate) { AppGraphCtxProfileBegin(m_appctx, "Simulate"); m_flowGridActor.updatePreEmit(&m_flowContext, dt); + NvFlowGridMaterialHandle emitMaterials[2u] = { m_materialA, m_materialB }; + + NvFlowGridUpdateEmitMaterials(m_flowGridActor.m_grid, emitMaterials, 2u); + // emit { NvFlowShapeDesc shapeDesc; @@ -220,14 +225,14 @@ void SceneSimpleFlameDouble::doUpdate(float dt) m_emitParams.deltaTime = dt; m_emitParamsA = m_emitParams; - m_emitParamsA.material = m_materialA; + m_emitParamsA.emitMaterialIndex = 0u; m_emitParamsA.bounds.w.x = +0.25f; m_emitParamsA.localToWorld = m_emitParamsA.bounds; m_emitParamsA.velocityLinear.x = -8.f; NvFlowGridEmit(m_flowGridActor.m_grid, &shapeDesc, 1u, &m_emitParamsA, 1u); m_emitParamsB = m_emitParams; - m_emitParamsB.material = m_materialB; + m_emitParamsB.emitMaterialIndex = 1u; m_emitParamsB.bounds.w.x = -0.25f; m_emitParamsB.localToWorld = m_emitParamsB.bounds; m_emitParamsB.velocityLinear.x = +8.f; @@ -300,7 +305,7 @@ void SceneSimpleFlameFuelMap::init(AppGraphCtx* context, int winw, int winh) void SceneSimpleFlameFuelMap::doUpdate(float dt) { - bool shouldUpdate = m_flowContext.updateBegin(); + bool shouldUpdate = m_flowContext.updateBegin(dt); if (shouldUpdate) { AppGraphCtxProfileBegin(m_appctx, "Simulate"); @@ -452,7 +457,7 @@ void SceneSimpleFlameParticleSurface::doEmitCustomEmitDensityFunc(NvFlowUint* da void SceneSimpleFlameParticleSurface::doUpdate(float dt) { - bool shouldUpdate = m_flowContext.updateBegin(); + bool shouldUpdate = m_flowContext.updateBegin(dt); if (shouldUpdate) { // update emit params @@ -892,7 +897,7 @@ void SceneSimpleFlameCulling::initParams() void SceneSimpleFlameCulling::doUpdate(float dt) { - bool shouldUpdate = m_flowContext.updateBegin(); + bool shouldUpdate = m_flowContext.updateBegin(dt); if (shouldUpdate) { AppGraphCtxProfileBegin(m_appctx, "Simulate"); @@ -1005,7 +1010,7 @@ void SceneSimpleFlameConvex::initParams() void SceneSimpleFlameConvex::doUpdate(float dt) { - bool shouldUpdate = m_flowContext.updateBegin(); + bool shouldUpdate = m_flowContext.updateBegin(dt); if (shouldUpdate) { AppGraphCtxProfileBegin(m_appctx, "Simulate"); @@ -1083,7 +1088,7 @@ void SceneSimpleFlameCapsule::initParams() void SceneSimpleFlameCapsule::doUpdate(float dt) { - bool shouldUpdate = m_flowContext.updateBegin(); + bool shouldUpdate = m_flowContext.updateBegin(dt); if (shouldUpdate) { AppGraphCtxProfileBegin(m_appctx, "Simulate"); @@ -1123,6 +1128,29 @@ void SceneSimpleFlameCapsule::doUpdate(float dt) shapeDesc[0].box.halfSize.z = 0.5f * m_capsuleRadius; } + if (m_flameSpread && !m_flameSpreadOld) + { + m_shouldGridReset = true; + } + m_flameSpreadOld = m_flameSpread; + + if (m_flameSpread) + { + m_emitParams.fuel = 0.f; + m_emitParams.fuelRelease = 2.5f; + m_emitParams.temperature = 0.f; + m_emitParams.temperatureCoupleRate = 0.f; + m_emitParams.velocityLinear.y = 0.f; + } + else + { + m_emitParams.fuel = 2.5f; + m_emitParams.fuelRelease = 0.f; + m_emitParams.temperature = 2.f; + m_emitParams.temperatureCoupleRate = 0.5f; + m_emitParams.velocityLinear.y = 8.f; + } + NvFlowGridEmit(m_flowGridActor.m_grid, shapeDesc, 1u, &m_emitParams, 1u); m_projectile.update(m_flowContext.m_gridContext, m_flowGridActor.m_grid, dt); @@ -1152,5 +1180,10 @@ void SceneSimpleFlameCapsule::imguiFluidEmitterExtra() m_boxMode = !m_boxMode; } + if (imguiserCheck("Flame Spread", m_flameSpread, true)) + { + m_flameSpread = !m_flameSpread; + } + imguiserEndGroup(); }
\ No newline at end of file diff --git a/demo/DemoApp/sceneSimpleSmoke.cpp b/demo/DemoApp/sceneSimpleSmoke.cpp index da5440d..4c849b9 100644 --- a/demo/DemoApp/sceneSimpleSmoke.cpp +++ b/demo/DemoApp/sceneSimpleSmoke.cpp @@ -120,7 +120,7 @@ NvFlowFloat3 SceneSimpleSmoke::velocityFunc(float theta, float rate) void SceneSimpleSmoke::doUpdate(float dt) { - bool shouldUpdate = m_flowContext.updateBegin(); + bool shouldUpdate = m_flowContext.updateBegin(dt); if (shouldUpdate) { AppGraphCtxProfileBegin(m_appctx, "Simulate"); diff --git a/demo/DemoAppCodeGen/DemoAppCodeGen.vcxproj b/demo/DemoAppCodeGen/DemoAppCodeGen.vcxproj new file mode 100644 index 0000000..42bb3ae --- /dev/null +++ b/demo/DemoAppCodeGen/DemoAppCodeGen.vcxproj @@ -0,0 +1,280 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <ItemGroup Label="ProjectConfigurations"> + <ProjectConfiguration Include="Debug|Win32"> + <Configuration>Debug</Configuration> + <Platform>Win32</Platform> + </ProjectConfiguration> + <ProjectConfiguration Include="Release|Win32"> + <Configuration>Release</Configuration> + <Platform>Win32</Platform> + </ProjectConfiguration> + <ProjectConfiguration Include="Debug|x64"> + <Configuration>Debug</Configuration> + <Platform>x64</Platform> + </ProjectConfiguration> + <ProjectConfiguration Include="Release|x64"> + <Configuration>Release</Configuration> + <Platform>x64</Platform> + </ProjectConfiguration> + </ItemGroup> + <ItemGroup> + <ClCompile Include="demoAppCodeGen.cpp" /> + </ItemGroup> + <ItemGroup> + <ClInclude Include="functionDefinitionExtract.h" /> + <ClInclude Include="loaderCodeGen.h" /> + </ItemGroup> + <PropertyGroup Condition="'$(Platform)'=='Win32'"> + <PlatformName>win32</PlatformName> + </PropertyGroup> + <PropertyGroup Condition="'$(Platform)'=='x64'"> + <PlatformName>win64</PlatformName> + </PropertyGroup> + <PropertyGroup Label="Globals"> + <ProjectGuid>{15a2730a-1be6-4a99-be96-feb4b8944ac2}</ProjectGuid> + <Keyword>Win32Proj</Keyword> + <RootNamespace>DemoAppCodeGen</RootNamespace> + <WindowsTargetPlatformVersion>10.0.14393.0</WindowsTargetPlatformVersion> + </PropertyGroup> + <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" /> + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration"> + <ConfigurationType>Application</ConfigurationType> + <UseDebugLibraries>true</UseDebugLibraries> + <PlatformToolset>v140</PlatformToolset> + <CharacterSet>Unicode</CharacterSet> + <UseOfMfc>Static</UseOfMfc> + </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration"> + <ConfigurationType>Application</ConfigurationType> + <UseDebugLibraries>false</UseDebugLibraries> + <PlatformToolset>v140</PlatformToolset> + <WholeProgramOptimization>true</WholeProgramOptimization> + <CharacterSet>Unicode</CharacterSet> + <UseOfMfc>Static</UseOfMfc> + </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration"> + <ConfigurationType>Application</ConfigurationType> + <UseDebugLibraries>true</UseDebugLibraries> + <PlatformToolset>v140</PlatformToolset> + <CharacterSet>Unicode</CharacterSet> + <UseOfMfc>Static</UseOfMfc> + </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration"> + <ConfigurationType>Application</ConfigurationType> + <UseDebugLibraries>false</UseDebugLibraries> + <PlatformToolset>v140</PlatformToolset> + <WholeProgramOptimization>true</WholeProgramOptimization> + <CharacterSet>Unicode</CharacterSet> + <UseOfMfc>Static</UseOfMfc> + </PropertyGroup> + <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" /> + <ImportGroup Label="ExtensionSettings"> + </ImportGroup> + <ImportGroup Label="Shared"> + </ImportGroup> + <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'"> + <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" /> + </ImportGroup> + <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'"> + <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" /> + </ImportGroup> + <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'"> + <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" /> + </ImportGroup> + <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'"> + <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" /> + </ImportGroup> + <PropertyGroup Label="UserMacros" /> + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'"> + <LinkIncremental>true</LinkIncremental> + <IncludePath>$(SolutionDir)\include;$(SolutionDir)\NvFlow;$(SolutionDir)\NvFlowContext;$(SolutionDir)external\SDL2\include;$(VC_IncludePath);$(WindowsSDK_IncludePath)</IncludePath> + <LibraryPath>$(SolutionDir)lib\win32;$(SolutionDir)external\SDL2\lib\x86;$(VC_LibraryPath_x86);$(WindowsSDK_LibraryPath_x86);$(NETFXKitsDir)Lib\um\x86</LibraryPath> + <CustomBuildBeforeTargets>PostBuildEvent</CustomBuildBeforeTargets> + <OutDir>$(SolutionDir)bin\$(PlatformName)\</OutDir> + <IntDir>interm\$(Configuration)_$(PlatformName)\</IntDir> + </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'"> + <LinkIncremental>true</LinkIncremental> + <OutDir>$(SolutionDir)bin\$(PlatformName)\</OutDir> + <IntDir>interm\$(Configuration)_$(PlatformName)\</IntDir> + <IncludePath>$(SolutionDir)\include;$(SolutionDir)\NvFlow;$(SolutionDir)\NvFlowContext;$(SolutionDir)external\SDL2\include;$(VC_IncludePath);$(WindowsSDK_IncludePath)</IncludePath> + <LibraryPath>$(SolutionDir)lib\win64;$(SolutionDir)external\SDL2\lib\x64;$(VC_LibraryPath_x64);$(WindowsSDK_LibraryPath_x64);$(NETFXKitsDir)Lib\um\x64</LibraryPath> + <CustomBuildBeforeTargets>PostBuildEvent</CustomBuildBeforeTargets> + </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'"> + <LinkIncremental>false</LinkIncremental> + <IncludePath>$(SolutionDir)\include;$(SolutionDir)\NvFlow;$(SolutionDir)\NvFlowContext;$(SolutionDir)external\SDL2\include;$(VC_IncludePath);$(WindowsSDK_IncludePath)</IncludePath> + <LibraryPath>$(SolutionDir)lib\win32;$(SolutionDir)external\SDL2\lib\x86;$(VC_LibraryPath_x86);$(WindowsSDK_LibraryPath_x86);$(NETFXKitsDir)Lib\um\x86</LibraryPath> + <CustomBuildBeforeTargets>PostBuildEvent</CustomBuildBeforeTargets> + <OutDir>$(SolutionDir)bin\$(PlatformName)\</OutDir> + <IntDir>interm\$(Configuration)_$(PlatformName)\</IntDir> + </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'"> + <LinkIncremental>false</LinkIncremental> + <OutDir>$(SolutionDir)bin\$(PlatformName)\</OutDir> + <IntDir>interm\$(Configuration)_$(PlatformName)\</IntDir> + <IncludePath>$(SolutionDir)\include;$(SolutionDir)\NvFlow;$(SolutionDir)\NvFlowContext;$(SolutionDir)external\SDL2\include;$(VC_IncludePath);$(WindowsSDK_IncludePath)</IncludePath> + <LibraryPath>$(SolutionDir)lib\win64;$(SolutionDir)external\SDL2\lib\x64;$(VC_LibraryPath_x64);$(WindowsSDK_LibraryPath_x64);$(NETFXKitsDir)Lib\um\x64</LibraryPath> + <CustomBuildBeforeTargets>PostBuildEvent</CustomBuildBeforeTargets> + </PropertyGroup> + <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'"> + <ClCompile> + <PrecompiledHeader> + </PrecompiledHeader> + <WarningLevel>Level3</WarningLevel> + <Optimization>Disabled</Optimization> + <PreprocessorDefinitions>DLL_SUFFIX=$(Configuration)_$(PlatformName);WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions> + </ClCompile> + <Link> + <SubSystem>Windows</SubSystem> + <GenerateDebugInformation>true</GenerateDebugInformation> + <AdditionalDependencies>kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies> + <EntryPointSymbol>mainCRTStartup</EntryPointSymbol> + </Link> + <FxCompile> + <EntryPointName>%(filename)</EntryPointName> + <ShaderModel>5.0</ShaderModel> + <HeaderFileOutput>$(ProjectDir)%(Filename).hlsl.h</HeaderFileOutput> + <ObjectFileOutput /> + </FxCompile> + <CustomBuildStep> + <Command> + </Command> + </CustomBuildStep> + <CustomBuildStep> + <Message> + </Message> + </CustomBuildStep> + <CustomBuildStep> + <Outputs> + </Outputs> + </CustomBuildStep> + </ItemDefinitionGroup> + <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'"> + <ClCompile> + <PrecompiledHeader> + </PrecompiledHeader> + <WarningLevel>Level3</WarningLevel> + <Optimization>Disabled</Optimization> + <PreprocessorDefinitions>DLL_SUFFIX=$(Configuration)_$(PlatformName);_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions> + </ClCompile> + <Link> + <SubSystem>Windows</SubSystem> + <GenerateDebugInformation>true</GenerateDebugInformation> + <AdditionalDependencies>kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies> + <EntryPointSymbol>mainCRTStartup</EntryPointSymbol> + </Link> + <FxCompile> + <EntryPointName>%(filename)</EntryPointName> + <ShaderModel>5.0</ShaderModel> + <HeaderFileOutput>$(ProjectDir)%(Filename).hlsl.h</HeaderFileOutput> + <ObjectFileOutput /> + </FxCompile> + <CustomBuildStep> + <Command> + </Command> + </CustomBuildStep> + <CustomBuildStep> + <Message> + </Message> + </CustomBuildStep> + <CustomBuildStep> + <Outputs> + </Outputs> + </CustomBuildStep> + </ItemDefinitionGroup> + <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'"> + <ClCompile> + <WarningLevel>Level3</WarningLevel> + <PrecompiledHeader> + </PrecompiledHeader> + <Optimization>MaxSpeed</Optimization> + <FunctionLevelLinking>true</FunctionLevelLinking> + <IntrinsicFunctions>true</IntrinsicFunctions> + <PreprocessorDefinitions>DLL_SUFFIX=$(Configuration)_$(PlatformName);WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions> + </ClCompile> + <Link> + <SubSystem>Windows</SubSystem> + <GenerateDebugInformation>true</GenerateDebugInformation> + <EnableCOMDATFolding>true</EnableCOMDATFolding> + <OptimizeReferences>true</OptimizeReferences> + <AdditionalDependencies>kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies> + <EntryPointSymbol>mainCRTStartup</EntryPointSymbol> + </Link> + <FxCompile> + <EntryPointName>%(filename)</EntryPointName> + <ShaderModel>5.0</ShaderModel> + <HeaderFileOutput>$(ProjectDir)%(Filename).hlsl.h</HeaderFileOutput> + <ObjectFileOutput /> + </FxCompile> + <CustomBuildStep> + <Command> + </Command> + </CustomBuildStep> + <CustomBuildStep> + <Message> + </Message> + </CustomBuildStep> + <CustomBuildStep> + <Outputs> + </Outputs> + </CustomBuildStep> + </ItemDefinitionGroup> + <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'"> + <ClCompile> + <WarningLevel>Level3</WarningLevel> + <PrecompiledHeader> + </PrecompiledHeader> + <Optimization>MaxSpeed</Optimization> + <FunctionLevelLinking>true</FunctionLevelLinking> + <IntrinsicFunctions>true</IntrinsicFunctions> + <PreprocessorDefinitions>DLL_SUFFIX=$(Configuration)_$(PlatformName);NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions> + </ClCompile> + <Link> + <SubSystem>Windows</SubSystem> + <GenerateDebugInformation>true</GenerateDebugInformation> + <EnableCOMDATFolding>true</EnableCOMDATFolding> + <OptimizeReferences>true</OptimizeReferences> + <AdditionalDependencies>kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies> + <EntryPointSymbol>mainCRTStartup</EntryPointSymbol> + </Link> + <FxCompile> + <EntryPointName>%(filename)</EntryPointName> + <ShaderModel>5.0</ShaderModel> + <HeaderFileOutput>$(ProjectDir)%(Filename).hlsl.h</HeaderFileOutput> + <ObjectFileOutput /> + </FxCompile> + <CustomBuildStep> + <Command> + </Command> + </CustomBuildStep> + <CustomBuildStep> + <Message> + </Message> + </CustomBuildStep> + <CustomBuildStep> + <Outputs> + </Outputs> + </CustomBuildStep> + </ItemDefinitionGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'"> + <LocalDebuggerWorkingDirectory>$(OutDir)</LocalDebuggerWorkingDirectory> + <TargetName>$(ProjectName)$(Configuration)_$(PlatformName)</TargetName> + </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'"> + <LocalDebuggerWorkingDirectory>$(OutDir)</LocalDebuggerWorkingDirectory> + <TargetName>$(ProjectName)$(Configuration)_$(PlatformName)</TargetName> + </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'"> + <LocalDebuggerWorkingDirectory>$(OutDir)</LocalDebuggerWorkingDirectory> + <TargetName>$(ProjectName)$(Configuration)_$(PlatformName)</TargetName> + </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'"> + <LocalDebuggerWorkingDirectory>$(OutDir)</LocalDebuggerWorkingDirectory> + <TargetName>$(ProjectName)$(Configuration)_$(PlatformName)</TargetName> + </PropertyGroup> + <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" /> + <ImportGroup Label="ExtensionTargets"> + </ImportGroup> +</Project>
\ No newline at end of file diff --git a/demo/DemoAppCodeGen/DemoAppCodeGen.vcxproj.filters b/demo/DemoAppCodeGen/DemoAppCodeGen.vcxproj.filters new file mode 100644 index 0000000..c648f4f --- /dev/null +++ b/demo/DemoAppCodeGen/DemoAppCodeGen.vcxproj.filters @@ -0,0 +1,33 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <ItemGroup> + <Filter Include="Source Files"> + <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier> + <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions> + </Filter> + <Filter Include="Header Files"> + <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier> + <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions> + </Filter> + <Filter Include="Resource Files"> + <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier> + <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions> + </Filter> + <Filter Include="Shaders"> + <UniqueIdentifier>{12de0363-d75b-4f29-bd10-e8b9832dd449}</UniqueIdentifier> + </Filter> + </ItemGroup> + <ItemGroup> + <ClCompile Include="demoAppCodeGen.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + </ItemGroup> + <ItemGroup> + <ClInclude Include="loaderCodeGen.h"> + <Filter>Header Files</Filter> + </ClInclude> + <ClInclude Include="functionDefinitionExtract.h"> + <Filter>Header Files</Filter> + </ClInclude> + </ItemGroup> +</Project>
\ No newline at end of file diff --git a/demo/DemoAppCodeGen/demoAppCodeGen.cpp b/demo/DemoAppCodeGen/demoAppCodeGen.cpp new file mode 100644 index 0000000..103e19f --- /dev/null +++ b/demo/DemoAppCodeGen/demoAppCodeGen.cpp @@ -0,0 +1,292 @@ +/* +* Copyright (c) 2014-2017, NVIDIA CORPORATION. All rights reserved. +* +* NVIDIA CORPORATION and its licensors retain all intellectual property +* and proprietary rights in and to this software, related documentation +* and any modifications thereto. Any use, reproduction, disclosure or +* distribution of this software and related documentation without an express +* license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +#include <stdio.h> +#include <string.h> +#include <cstdlib> + +#include "loaderCodeGen.h" +#include "functionDefinitionExtract.h" + +LoaderType gLoaderType = eLoaderTypeDynamicLink; + +void genLoaderAppGraphCtx() +{ + const unsigned int numFunctions = 12u; + + const char* functionDefinitions[numFunctions] = { + "AppGraphCtx* AppGraphCtxCreate(int deviceID);", + "bool AppGraphCtxUpdateSize(AppGraphCtx* context, SDL_Window* window, bool fullscreen);", + "void AppGraphCtxReleaseRenderTarget(AppGraphCtx* context);", + "void AppGraphCtxRelease(AppGraphCtx* context);", + "void AppGraphCtxFrameStart(AppGraphCtx* context, AppGraphColor clearColor);", + "void AppGraphCtxFramePresent(AppGraphCtx* context, bool fullsync);", + "void AppGraphCtxWaitForFrames(AppGraphCtx* context, unsigned int maxFramesInFlight);", + "void AppGraphCtxProfileEnable(AppGraphCtx* context, bool enabled);", + "void AppGraphCtxProfileBegin(AppGraphCtx* context, const char* label);", + "void AppGraphCtxProfileEnd(AppGraphCtx* context, const char* label);", + "bool AppGraphCtxProfileGet(AppGraphCtx* context, const char** plabel, float* cpuTime, float* gpuTime, int index);", + "size_t AppGraphCtxDedicatedVideoMemory(AppGraphCtx* context);" + }; + + StrHeap strHeap = allocateStrHeap(functionDefinitions, numFunctions); + + Function functions[numFunctions]; + for (unsigned int functionIdx = 0u; functionIdx < numFunctions; functionIdx++) + { + functions[functionIdx] = genFunction(&strHeap, functionDefinitions[functionIdx]); + } + + GenerateCodeParams genCodeParams = {}; + genCodeParams.loaderType = gLoaderType; + genCodeParams.file = nullptr; + genCodeParams.functions = functions; + genCodeParams.numFunctions = numFunctions; + genCodeParams.filenameTmp = "appGraphCtxLoaderGenerated.tmp.h"; + genCodeParams.filenameDst = "appGraphCtxLoaderGenerated.h"; + genCodeParams.moduleNameUpperCase = "AppGraphCtx"; + genCodeParams.moduleNameLowerCase = "appGraphCtx"; + genCodeParams.instName = "gAppGraphCtxLoader"; + genCodeParams.apiMarker = "APP_GRAPH_CTX_API"; + + fopen_s(&genCodeParams.file, genCodeParams.filenameTmp, "w"); + + generateCode(&genCodeParams); + + fclose(genCodeParams.file); + + freeStrHeap(&strHeap); + + fileDiffAndWriteIfModified(&genCodeParams); +} + +void genLoaderComputeContext() +{ + const unsigned int numFunctions = 23u; + + const char* functionDefinitions[numFunctions] = { + "ComputeContext* ComputeContextCreate(ComputeContextDesc* desc);", + "void ComputeContextUpdate(ComputeContext* context, ComputeContextDesc* desc);", + "void ComputeContextRelease(ComputeContext* context);", + "ComputeShader* ComputeShaderCreate(ComputeContext* context, const ComputeShaderDesc* desc);", + "void ComputeShaderRelease(ComputeShader* shader);", + "ComputeConstantBuffer* ComputeConstantBufferCreate(ComputeContext* context, const ComputeConstantBufferDesc* desc);", + "void ComputeConstantBufferRelease(ComputeConstantBuffer* constantBuffer);", + "void* ComputeConstantBufferMap(ComputeContext* context, ComputeConstantBuffer* constantBuffer);", + "void ComputeConstantBufferUnmap(ComputeContext* context, ComputeConstantBuffer* constantBuffer);", + "ComputeResource* ComputeResourceCreate(ComputeContext* context, const ComputeResourceDesc* desc);", + "void ComputeResourceUpdate(ComputeContext* context, ComputeResource* resource, const ComputeResourceDesc* desc);", + "void ComputeResourceRelease(ComputeResource* resource);", + "ComputeResourceRW* ComputeResourceRWCreate(ComputeContext* context, const ComputeResourceRWDesc* desc);", + "void ComputeResourceRWUpdate(ComputeContext* context, ComputeResourceRW* resourceRW, const ComputeResourceRWDesc* desc);", + "void ComputeResourceRWRelease(ComputeResourceRW* resourceRW);", + "ComputeResource* ComputeResourceRWGetResource(ComputeResourceRW* resourceRW);", + "void ComputeContextDispatch(ComputeContext* context, const ComputeDispatchParams* params);", + "ComputeContext* ComputeContextNvFlowContextCreate(NvFlowContext* flowContext);", + "void ComputeContextNvFlowContextUpdate(ComputeContext* computeContext, NvFlowContext* flowContext);", + "ComputeResource* ComputeResourceNvFlowCreate(ComputeContext* context, NvFlowContext* flowContext, NvFlowResource* flowResource);", + "void ComputeResourceNvFlowUpdate(ComputeContext* context, ComputeResource* resource, NvFlowContext* flowContext, NvFlowResource* flowResource);", + "ComputeResourceRW* ComputeResourceRWNvFlowCreate(ComputeContext* context, NvFlowContext* flowContext, NvFlowResourceRW* flowResourceRW);", + "void ComputeResourceRWNvFlowUpdate(ComputeContext* context, ComputeResourceRW* resourceRW, NvFlowContext* flowContext, NvFlowResourceRW* flowResourceRW);" + }; + + StrHeap strHeap = allocateStrHeap(functionDefinitions, numFunctions); + + Function functions[numFunctions]; + for (unsigned int functionIdx = 0u; functionIdx < numFunctions; functionIdx++) + { + functions[functionIdx] = genFunction(&strHeap, functionDefinitions[functionIdx]); + } + + GenerateCodeParams genCodeParams = {}; + genCodeParams.loaderType = gLoaderType; + genCodeParams.file = nullptr; + genCodeParams.functions = functions; + genCodeParams.numFunctions = numFunctions; + genCodeParams.filenameTmp = "computeContextLoaderGenerated.tmp.h"; + genCodeParams.filenameDst = "computeContextLoaderGenerated.h"; + genCodeParams.moduleNameUpperCase = "ComputeContext"; + genCodeParams.moduleNameLowerCase = "computeContext"; + genCodeParams.instName = "gComputeContextLoader"; + genCodeParams.apiMarker = "COMPUTE_API"; + + fopen_s(&genCodeParams.file, genCodeParams.filenameTmp, "w"); + + generateCode(&genCodeParams); + + fclose(genCodeParams.file); + + freeStrHeap(&strHeap); + + fileDiffAndWriteIfModified(&genCodeParams); +} + +void genLoaderImgui() +{ + const unsigned int numFunctions = 18u; + + const char* functionDefinitions[numFunctions] = { + "void imguiGraphContextInit(const ImguiGraphDesc* desc);", + "void imguiGraphContextUpdate(const ImguiGraphDesc* desc);", + "void imguiGraphContextDestroy();", + "void imguiGraphRecordBegin();", + "void imguiGraphRecordEnd();", + "void imguiGraphVertex2f(float x, float y);", + "void imguiGraphVertex2fv(const float* v);", + "void imguiGraphTexCoord2f(float u, float v);", + "void imguiGraphColor4ub(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha);", + "void imguiGraphColor4ubv(const uint8_t* v);", + "void imguiGraphFontTextureEnable();", + "void imguiGraphFontTextureDisable();", + "void imguiGraphEnableScissor(int x, int y, int width, int height);", + "void imguiGraphDisableScissor();", + "void imguiGraphFontTextureInit(unsigned char* data);", + "void imguiGraphFontTextureRelease();", + "bool imguiInteropGraphInit(imguiGraphInit_t func, const char* fontpath, AppGraphCtx* appctx);", + "void imguiInteropGraphUpdate(imguiGraphUpdate_t func, AppGraphCtx* appctx);" + }; + + StrHeap strHeap = allocateStrHeap(functionDefinitions, numFunctions); + + Function functions[numFunctions]; + for (unsigned int functionIdx = 0u; functionIdx < numFunctions; functionIdx++) + { + functions[functionIdx] = genFunction(&strHeap, functionDefinitions[functionIdx]); + } + + GenerateCodeParams genCodeParams = {}; + genCodeParams.loaderType = gLoaderType; + genCodeParams.file = nullptr; + genCodeParams.functions = functions; + genCodeParams.numFunctions = numFunctions; + genCodeParams.filenameTmp = "imguiGraphLoaderGenerated.tmp.h"; + genCodeParams.filenameDst = "imguiGraphLoaderGenerated.h"; + genCodeParams.moduleNameUpperCase = "Imgui"; + genCodeParams.moduleNameLowerCase = "imgui"; + genCodeParams.instName = "gImguiLoader"; + genCodeParams.apiMarker = "IMGUI_GRAPH_API"; + + fopen_s(&genCodeParams.file, genCodeParams.filenameTmp, "w"); + + generateCode(&genCodeParams); + + fclose(genCodeParams.file); + + freeStrHeap(&strHeap); + + fileDiffAndWriteIfModified(&genCodeParams); +} + +void genLoaderMesh() +{ + const unsigned int numFunctions = 10u; + + const char* functionDefinitions[numFunctions] = { + "MeshContext* MeshContextCreate(const MeshContextDesc* desc);", + "void MeshContextUpdate(MeshContext* context, const MeshContextDesc* desc);", + "void MeshContextRelease(MeshContext* context);", + "MeshIndexBuffer* MeshIndexBufferCreate(MeshContext* context, MeshUint* indices, MeshUint numIndices);", + "void MeshIndexBufferRelease(MeshIndexBuffer* buffer);", + "MeshVertexBuffer* MeshVertexBufferCreate(MeshContext* context, MeshVertex* vertices, MeshUint numVertices);", + "void MeshVertexBufferRelease(MeshVertexBuffer* buffer);", + "void MeshContextDraw(MeshContext* context, const MeshContextDrawParams* params);", + "MeshContext* MeshInteropContextCreate(AppGraphCtx* appctx);", + "void MeshInteropContextUpdate(MeshContext* context, AppGraphCtx* appctx);" + }; + + StrHeap strHeap = allocateStrHeap(functionDefinitions, numFunctions); + + Function functions[numFunctions]; + for (unsigned int functionIdx = 0u; functionIdx < numFunctions; functionIdx++) + { + functions[functionIdx] = genFunction(&strHeap, functionDefinitions[functionIdx]); + } + + GenerateCodeParams genCodeParams = {}; + genCodeParams.loaderType = gLoaderType; + genCodeParams.file = nullptr; + genCodeParams.functions = functions; + genCodeParams.numFunctions = numFunctions; + genCodeParams.filenameTmp = "meshLoaderGenerated.tmp.h"; + genCodeParams.filenameDst = "meshLoaderGenerated.h"; + genCodeParams.moduleNameUpperCase = "Mesh"; + genCodeParams.moduleNameLowerCase = "mesh"; + genCodeParams.instName = "gMeshLoader"; + genCodeParams.apiMarker = "MESH_API"; + + fopen_s(&genCodeParams.file, genCodeParams.filenameTmp, "w"); + + generateCode(&genCodeParams); + + fclose(genCodeParams.file); + + freeStrHeap(&strHeap); + + fileDiffAndWriteIfModified(&genCodeParams); +} + +void genNvFlowInteropLoader() +{ + const unsigned int numFunctions = 6u; + + const char* functionDefinitions[numFunctions] = { + "NvFlowContext* NvFlowInteropCreateContext(AppGraphCtx* appctx);", + "NvFlowDepthStencilView* NvFlowInteropCreateDepthStencilView(AppGraphCtx* appctx, NvFlowContext* flowctx);", + "NvFlowRenderTargetView* NvFlowInteropCreateRenderTargetView(AppGraphCtx* appctx, NvFlowContext* flowctx);", + "void NvFlowInteropUpdateContext(NvFlowContext* context, AppGraphCtx* appctx);", + "void NvFlowInteropUpdateDepthStencilView(NvFlowDepthStencilView* view, AppGraphCtx* appctx, NvFlowContext* flowctx);", + "void NvFlowInteropUpdateRenderTargetView(NvFlowRenderTargetView* view, AppGraphCtx* appctx, NvFlowContext* flowctx);" + }; + + StrHeap strHeap = allocateStrHeap(functionDefinitions, numFunctions); + + Function functions[numFunctions]; + for (unsigned int functionIdx = 0u; functionIdx < numFunctions; functionIdx++) + { + functions[functionIdx] = genFunction(&strHeap, functionDefinitions[functionIdx]); + } + + GenerateCodeParams genCodeParams = {}; + genCodeParams.loaderType = gLoaderType; + genCodeParams.file = nullptr; + genCodeParams.functions = functions; + genCodeParams.numFunctions = numFunctions; + genCodeParams.filenameTmp = "NvFlowInteropLoaderGenerated.tmp.h"; + genCodeParams.filenameDst = "NvFlowInteropLoaderGenerated.h"; + genCodeParams.moduleNameUpperCase = "NvFlowInterop"; + genCodeParams.moduleNameLowerCase = "nvFlowInterop"; + genCodeParams.instName = "gNvFlowInteropLoader"; + genCodeParams.apiMarker = "NV_FLOW_API"; + + fopen_s(&genCodeParams.file, genCodeParams.filenameTmp, "w"); + + generateCode(&genCodeParams); + + fclose(genCodeParams.file); + + freeStrHeap(&strHeap); + + fileDiffAndWriteIfModified(&genCodeParams); +} + +int main(int argc, char** argv) +{ + genLoaderAppGraphCtx(); + + genLoaderComputeContext(); + + genLoaderImgui(); + + genLoaderMesh(); + + genNvFlowInteropLoader(); + + return 0; +}
\ No newline at end of file diff --git a/demo/DemoAppCodeGen/functionDefinitionExtract.h b/demo/DemoAppCodeGen/functionDefinitionExtract.h new file mode 100644 index 0000000..ca08253 --- /dev/null +++ b/demo/DemoAppCodeGen/functionDefinitionExtract.h @@ -0,0 +1,230 @@ +/* +* Copyright (c) 2014-2017, NVIDIA CORPORATION. All rights reserved. +* +* NVIDIA CORPORATION and its licensors retain all intellectual property +* and proprietary rights in and to this software, related documentation +* and any modifications thereto. Any use, reproduction, disclosure or +* distribution of this software and related documentation without an express +* license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +#pragma once + +struct StrHeap +{ + char* data; + unsigned int size; + unsigned int allocIdx; +}; + +StrHeap allocateStrHeap(const char** definitions, unsigned int numFunctions) +{ + unsigned int count = 0u; + for (unsigned int functionIdx = 0u; functionIdx < numFunctions; functionIdx++) + { + count += (unsigned int)strlen(definitions[functionIdx]); + } + + // offset count to cover null terminators + count += numFunctions * (2 * maxFunctionParams + 1 + 1); + + StrHeap heap = {}; + heap.data = (char*)malloc(count); + heap.size = count; + heap.allocIdx = 0u; + return heap; +} + +void freeStrHeap(StrHeap* heap) +{ + free(heap->data); + heap->data = nullptr; + heap->size = 0u; + heap->allocIdx = 0u; +} + +inline bool isSpace(char c) +{ + return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == '\f' || c == '\v'; +} + +inline bool isAlphaNum(char c) +{ + return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || (c == '_'); +} + +void skipSpace(unsigned int* readIdx, const char* definition) +{ + while (definition[*readIdx] != '\0') + { + if (isSpace(definition[*readIdx])) + { + *readIdx = *readIdx + 1; + } + else + { + break; + } + } +} + +void findChar(unsigned int* readIdx, const char* definition, char c) +{ + while (definition[*readIdx] != '\0') + { + if (definition[*readIdx] == c) + { + break; + } + else + { + *readIdx = *readIdx + 1; + } + } +} + +unsigned int findParamDelimiter(unsigned int readIdx, const char* definition) +{ + while (definition[readIdx] != '\0') + { + if (definition[readIdx] == ',' || definition[readIdx] == ')') + { + return readIdx; + } + else + { + readIdx = readIdx + 1; + } + } + return readIdx; +} + +unsigned int reverseFindAlphaNum(unsigned int maxReadIdx, const char* definition) +{ + int readIdx = (int)maxReadIdx; + readIdx--; + bool hitAlphaNum = false; + while (readIdx >= 0) + { + if (isAlphaNum(definition[readIdx])) + { + hitAlphaNum = true; + readIdx--; + } + else if (definition[readIdx] == '(' || definition[readIdx] == ',') + { + if (hitAlphaNum) + { + return (unsigned int)(readIdx + 1); + } + else + { + return maxReadIdx; + }; + } + else if (isSpace(definition[readIdx])) + { + if (hitAlphaNum) + { + return (unsigned int)(readIdx + 1); + } + else + { + readIdx--; + } + } + else + { + break; + } + } + return maxReadIdx; +} + +void extractAlphaNum(StrHeap* heap, const char** dstPtr, unsigned int* readIdx, const char* definition) +{ + skipSpace(readIdx, definition); + + *dstPtr = heap->data + heap->allocIdx; + + while (heap->allocIdx < heap->size) + { + if (isAlphaNum(definition[(*readIdx)])) + { + heap->data[heap->allocIdx++] = definition[(*readIdx)++]; + } + else + { + break; + } + } + heap->data[heap->allocIdx++] = '\0'; +} + +void extractRegion(StrHeap* heap, const char** dstPtr, unsigned char readIdx, unsigned char maxReadIdx, const char* definition) +{ + *dstPtr = heap->data + heap->allocIdx; + + while (heap->allocIdx < heap->size) + { + if (readIdx < maxReadIdx) + { + heap->data[heap->allocIdx++] = definition[readIdx++]; + } + else + { + break; + } + } + heap->data[heap->allocIdx++] = '\0'; +} + +Function genFunction(StrHeap* heap, const char* definition) +{ + Function function = {}; + + unsigned int readIdx = 0u; + unsigned int tempReadIdx = 0u; + + unsigned int paramStartReadIdx = readIdx; + findChar(¶mStartReadIdx, definition, '('); + + unsigned int methodReadIdx = reverseFindAlphaNum(paramStartReadIdx, definition); + + extractRegion(heap, &function.retType, readIdx, methodReadIdx, definition); + + tempReadIdx = methodReadIdx; + extractAlphaNum(heap, &function.method, &tempReadIdx, definition); + + readIdx = paramStartReadIdx; + + function.numParams = 0; + while (function.numParams < maxFunctionParams) + { + unsigned int maxReadIdx = findParamDelimiter(readIdx, definition); + + unsigned int instNameReadIdx = reverseFindAlphaNum(maxReadIdx, definition); + + // break if no name found + if (instNameReadIdx == maxReadIdx) + { + break; + } + + FunctionParams funcParams = {}; + + // extract type name, found on interval readIdx to instNameReadIdx + extractRegion(heap, &funcParams.typeName, readIdx + 1, instNameReadIdx, definition); + + // extract inst name, found on interval instNameReadIdx to maxReadIdx + tempReadIdx = instNameReadIdx; + extractAlphaNum(heap, &funcParams.instName, &tempReadIdx, definition); + + // advance read index + readIdx = maxReadIdx + 1; + + function.params[function.numParams++] = funcParams; + } + + return function; +}
\ No newline at end of file diff --git a/demo/DemoAppCodeGen/loaderCodeGen.h b/demo/DemoAppCodeGen/loaderCodeGen.h new file mode 100644 index 0000000..b92beb1 --- /dev/null +++ b/demo/DemoAppCodeGen/loaderCodeGen.h @@ -0,0 +1,335 @@ +/* +* Copyright (c) 2014-2017, NVIDIA CORPORATION. All rights reserved. +* +* NVIDIA CORPORATION and its licensors retain all intellectual property +* and proprietary rights in and to this software, related documentation +* and any modifications thereto. Any use, reproduction, disclosure or +* distribution of this software and related documentation without an express +* license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +#pragma once + +enum LoaderType +{ + eLoaderTypeDynamicLink = 0, + eLoaderTypeStaticLink = 1 +}; + +const unsigned int maxFunctionParams = 8u; + +struct FunctionParams +{ + const char* typeName; + const char* instName; +}; + +struct Function +{ + const char* retType; + const char* method; + unsigned int numParams; + FunctionParams params[maxFunctionParams]; +}; + +struct GenerateCodeParams +{ + LoaderType loaderType; + FILE* file; + Function* functions; + unsigned int numFunctions; + + const char* filenameTmp; + const char* filenameDst; + const char* moduleNameUpperCase; + const char* moduleNameLowerCase; + const char* instName; + const char* apiMarker; +}; + +void typedef_function_ptrs(const GenerateCodeParams* params) +{ + for (unsigned int functionIdx = 0u; functionIdx < params->numFunctions; functionIdx++) + { + auto& function = params->functions[functionIdx]; + + fprintf(params->file, "typedef %s (*%s_ptr_t)(", function.retType, function.method); + + for (unsigned int paramIdx = 0u; paramIdx < function.numParams; paramIdx++) + { + fprintf(params->file, "%s %s", function.params[paramIdx].typeName, function.params[paramIdx].instName); + + if (paramIdx < function.numParams - 1) fprintf(params->file, ", "); + } + + fprintf(params->file, ");\n"); + } + + fprintf(params->file, "\n"); +} + +void declare_function_ptrs(const GenerateCodeParams* params) +{ + for (unsigned int functionIdx = 0u; functionIdx < params->numFunctions; functionIdx++) + { + auto& function = params->functions[functionIdx]; + + fprintf(params->file, "\t%s_ptr_t %s_ptr;\n", function.method, function.method); + } +} + +void implement_pointer_wrappers(const GenerateCodeParams* params) +{ + for (unsigned int functionIdx = 0u; functionIdx < params->numFunctions; functionIdx++) + { + auto& function = params->functions[functionIdx]; + + fprintf(params->file, "%s %s(", function.retType, function.method); + + for (unsigned int paramIdx = 0u; paramIdx < function.numParams; paramIdx++) + { + fprintf(params->file, "%s %s", function.params[paramIdx].typeName, function.params[paramIdx].instName); + + if (paramIdx < function.numParams - 1) fprintf(params->file, ", "); + } + + fprintf(params->file, ")\n{\n"); + + fprintf(params->file, "\treturn %s.%s_ptr(", params->instName, function.method); + + for (unsigned int paramIdx = 0u; paramIdx < function.numParams; paramIdx++) + { + fprintf(params->file, "%s", function.params[paramIdx].instName); + + if (paramIdx < function.numParams - 1) fprintf(params->file, ", "); + } + + fprintf(params->file, ");\n"); + + fprintf(params->file, "}\n\n"); + } +} + +void load_function_ptrs(const GenerateCodeParams* params) +{ + for (unsigned int functionIdx = 0u; functionIdx < params->numFunctions; functionIdx++) + { + auto& function = params->functions[functionIdx]; + + fprintf(params->file, "\t%s.%s_ptr = ", params->instName, function.method); + + fprintf(params->file, "(%s_ptr_t", function.method); + + fprintf(params->file, ")(%sLoaderLoadFunction(&%s, \"%s\")", params->moduleNameLowerCase, params->instName, function.method); + + fprintf(params->file, ");\n"); + } +} + +void load_function_ptrs_static(const GenerateCodeParams* params, const char* suffix) +{ + fprintf(params->file, "\tif (type == APP_CONTEXT_%s)\n\t{\n", suffix); + + for (unsigned int functionIdx = 0u; functionIdx < params->numFunctions; functionIdx++) + { + auto& function = params->functions[functionIdx]; + + fprintf(params->file, "\t\t%s.%s_ptr = ", params->instName, function.method); + + fprintf(params->file, "%s%s;\n", function.method, suffix); + } + + fprintf(params->file, "\t}\n\n"); +} + +void unload_function_ptrs(const GenerateCodeParams* params) +{ + for (unsigned int functionIdx = 0u; functionIdx < params->numFunctions; functionIdx++) + { + auto& function = params->functions[functionIdx]; + + fprintf(params->file, "\t%s.%s_ptr = nullptr;\n", params->instName, function.method); + } +} + +void declare_backend_functions(const GenerateCodeParams* params, const char* suffix) +{ + for (unsigned int functionIdx = 0u; functionIdx < params->numFunctions; functionIdx++) + { + auto& function = params->functions[functionIdx]; + + fprintf(params->file, "%s %s %s%s(", params->apiMarker, function.retType, function.method, suffix); + + for (unsigned int paramIdx = 0u; paramIdx < function.numParams; paramIdx++) + { + fprintf(params->file, "%s %s", function.params[paramIdx].typeName, function.params[paramIdx].instName); + + if (paramIdx < function.numParams - 1) fprintf(params->file, ", "); + } + + fprintf(params->file, ");\n"); + } + + fprintf(params->file, "\n"); +} + +const char* fileHeader = +"/*\n" +"* Copyright (c) 2014-2017, NVIDIA CORPORATION. All rights reserved.\n" +"*\n" +"* NVIDIA CORPORATION and its licensors retain all intellectual property\n" +"* and proprietary rights in and to this software, related documentation\n" +"* and any modifications thereto. Any use, reproduction, disclosure or\n" +"* distribution of this software and related documentation without an express\n" +"* license agreement from NVIDIA CORPORATION is strictly prohibited.\n" +"*/\n\n"; + +void generateCode(const GenerateCodeParams* params) +{ + fprintf(params->file, fileHeader); + + typedef_function_ptrs(params); + + const char* loaderBegin = + "struct %sLoader \n" + "{ \n" + " void* module = nullptr; \n" + " const char* suffix = \"\"; \n" + " char buf[1024u]; \n\n"; + fprintf(params->file, loaderBegin, params->moduleNameUpperCase); + + declare_function_ptrs(params); + + const char* loaderEnd = + "\n" + "}%s; \n\n"; + fprintf(params->file, loaderEnd, params->instName); + + implement_pointer_wrappers(params); + + if (params->loaderType == eLoaderTypeDynamicLink) + { + const char* loaderFunction = + "void* %sLoaderLoadFunction(%sLoader* inst, const char* name)\n" + "{\n" + " snprintf(inst->buf, 1024u, \"%s%s\", name, inst->suffix);\n" + "\n" + " return SDL_LoadFunction(inst->module, inst->buf);\n" + "}\n\n"; + fprintf(params->file, loaderFunction, params->moduleNameLowerCase, params->moduleNameUpperCase, "%s", "%s"); + + const char* loadModule = + "void load%s(AppGraphCtxType type)\n" + "{\n" + " const char* moduleName = demoAppDLLName(type);\n" + "\n" + " %s.suffix = demoAppBackendSuffix(type);\n" + "\n" + " %s.module = SDL_LoadObject(moduleName);\n\n"; + fprintf(params->file, loadModule, params->moduleNameUpperCase, params->instName, params->instName); + + load_function_ptrs(params); + + const char* unloadModule = + "}\n" + "\n" + "void unload%s()\n" + "{\n"; + fprintf(params->file, unloadModule, params->moduleNameUpperCase); + + unload_function_ptrs(params); + + const char* unloadModuleEnd = + "\n" + " SDL_UnloadObject(%s.module);\n" + "}\n"; + fprintf(params->file, unloadModuleEnd, params->instName); + } + else if (params->loaderType == eLoaderTypeStaticLink) + { + const unsigned int suffixCount = 2u; + const char* suffix[suffixCount] = { "D3D11", "D3D12" }; + + for (unsigned int suffixIdx = 0u; suffixIdx < 2u; suffixIdx++) + { + declare_backend_functions(params, suffix[suffixIdx]); + } + + const char* loadModule = + "void load%s(AppGraphCtxType type)\n" + "{\n" + " %s.suffix = demoAppBackendSuffix(type);\n" + "\n"; + fprintf(params->file, loadModule, params->moduleNameUpperCase, params->instName); + + for (unsigned int suffixIdx = 0u; suffixIdx < 2u; suffixIdx++) + { + load_function_ptrs_static(params, suffix[suffixIdx]); + } + + const char* unloadModule = + "}\n" + "\n" + "void unload%s()\n" + "{\n"; + fprintf(params->file, unloadModule, params->moduleNameUpperCase); + + unload_function_ptrs(params); + + const char* unloadModuleEnd = + "\n" + "}\n"; + fprintf(params->file, unloadModuleEnd, params->instName); + } +} + +void fileDiffAndWriteIfModified(const GenerateCodeParams* params) +{ + FILE* fileTmp = nullptr; + FILE* fileDst = nullptr; + bool match = true; + + fopen_s(&fileDst, params->filenameDst, "r"); + if (fileDst) + { + fopen_s(&fileTmp, params->filenameTmp, "r"); + if (fileTmp) + { + while (1) + { + int a = fgetc(fileTmp); + int b = fgetc(fileDst); + + if (a == EOF && b == EOF) + { + break; + } + else if (a != b) + { + match = false; + break; + } + } + + fclose(fileTmp); + } + else + { + match = false; + } + fclose(fileDst); + } + else + { + match = false; + } + + if (!match) + { + remove(params->filenameDst); + rename(params->filenameTmp, params->filenameDst); + } + + // always cleanup temp file + remove(params->filenameTmp); +}
\ No newline at end of file diff --git a/demo/DemoAppD3D11/NvFlowInteropD3D11.cpp b/demo/DemoAppD3D11/NvFlowInteropD3D11.cpp index 23aaf9c..4f4b1cf 100644 --- a/demo/DemoAppD3D11/NvFlowInteropD3D11.cpp +++ b/demo/DemoAppD3D11/NvFlowInteropD3D11.cpp @@ -15,16 +15,32 @@ #include "NvFlowContextD3D11.h" #include "appD3D11Ctx.h" -NvFlowContext* NvFlowInteropCreateContext(AppGraphCtx* appctx) +NV_FLOW_API NvFlowContext* NvFlowInteropCreateContextD3D11(AppGraphCtx* appctx); + +NV_FLOW_API NvFlowDepthStencilView* NvFlowInteropCreateDepthStencilViewD3D11(AppGraphCtx* appctx, NvFlowContext* flowctx); + +NV_FLOW_API NvFlowRenderTargetView* NvFlowInteropCreateRenderTargetViewD3D11(AppGraphCtx* appctx, NvFlowContext* flowctx); + +NV_FLOW_API void NvFlowInteropUpdateContextD3D11(NvFlowContext* context, AppGraphCtx* appctx); + +NV_FLOW_API void NvFlowInteropUpdateDepthStencilViewD3D11(NvFlowDepthStencilView* view, AppGraphCtx* appctx, NvFlowContext* flowctx); + +NV_FLOW_API void NvFlowInteropUpdateRenderTargetViewD3D11(NvFlowRenderTargetView* view, AppGraphCtx* appctx, NvFlowContext* flowctx); + +NvFlowContext* NvFlowInteropCreateContextD3D11(AppGraphCtx* appctxIn) { + auto appctx = cast_to_AppGraphCtxD3D11(appctxIn); + NvFlowContextDescD3D11 desc = {}; desc.device = appctx->m_device; desc.deviceContext = appctx->m_deviceContext; return NvFlowCreateContextD3D11(NV_FLOW_VERSION, &desc); } -NvFlowDepthStencilView* NvFlowInteropCreateDepthStencilView(AppGraphCtx* appctx, NvFlowContext* flowctx) +NvFlowDepthStencilView* NvFlowInteropCreateDepthStencilViewD3D11(AppGraphCtx* appctxIn, NvFlowContext* flowctx) { + auto appctx = cast_to_AppGraphCtxD3D11(appctxIn); + NvFlowDepthStencilViewDescD3D11 desc = {}; desc.dsv = appctx->m_dsv; desc.srv = appctx->m_depthSRV; @@ -32,24 +48,30 @@ NvFlowDepthStencilView* NvFlowInteropCreateDepthStencilView(AppGraphCtx* appctx, return NvFlowCreateDepthStencilViewD3D11(flowctx, &desc); } -NvFlowRenderTargetView* NvFlowInteropCreateRenderTargetView(AppGraphCtx* appctx, NvFlowContext* flowctx) +NvFlowRenderTargetView* NvFlowInteropCreateRenderTargetViewD3D11(AppGraphCtx* appctxIn, NvFlowContext* flowctx) { + auto appctx = cast_to_AppGraphCtxD3D11(appctxIn); + NvFlowRenderTargetViewDescD3D11 desc = {}; desc.rtv = appctx->m_rtv; desc.viewport = appctx->m_viewport; return NvFlowCreateRenderTargetViewD3D11(flowctx, &desc); } -void NvFlowInteropUpdateContext(NvFlowContext* context, AppGraphCtx* appctx) +void NvFlowInteropUpdateContextD3D11(NvFlowContext* context, AppGraphCtx* appctxIn) { + auto appctx = cast_to_AppGraphCtxD3D11(appctxIn); + NvFlowContextDescD3D11 desc = {}; desc.device = appctx->m_device; desc.deviceContext = appctx->m_deviceContext; NvFlowUpdateContextD3D11(context, &desc); } -void NvFlowInteropUpdateDepthStencilView(NvFlowDepthStencilView* view, AppGraphCtx* appctx, NvFlowContext* flowctx) +void NvFlowInteropUpdateDepthStencilViewD3D11(NvFlowDepthStencilView* view, AppGraphCtx* appctxIn, NvFlowContext* flowctx) { + auto appctx = cast_to_AppGraphCtxD3D11(appctxIn); + NvFlowDepthStencilViewDescD3D11 desc = {}; desc.dsv = appctx->m_dsv; desc.srv = appctx->m_depthSRV; @@ -57,8 +79,10 @@ void NvFlowInteropUpdateDepthStencilView(NvFlowDepthStencilView* view, AppGraphC NvFlowUpdateDepthStencilViewD3D11(flowctx, view, &desc); } -void NvFlowInteropUpdateRenderTargetView(NvFlowRenderTargetView* view, AppGraphCtx* appctx, NvFlowContext* flowctx) +void NvFlowInteropUpdateRenderTargetViewD3D11(NvFlowRenderTargetView* view, AppGraphCtx* appctxIn, NvFlowContext* flowctx) { + auto appctx = cast_to_AppGraphCtxD3D11(appctxIn); + NvFlowRenderTargetViewDescD3D11 desc = {}; desc.rtv = appctx->m_rtv; desc.viewport = appctx->m_viewport; diff --git a/demo/DemoAppD3D11/appD3D11Ctx.cpp b/demo/DemoAppD3D11/appD3D11Ctx.cpp index 959614c..dd2bd2c 100644 --- a/demo/DemoAppD3D11/appD3D11Ctx.cpp +++ b/demo/DemoAppD3D11/appD3D11Ctx.cpp @@ -45,25 +45,23 @@ namespace } } -AppGraphProfiler* appGraphCreateProfiler(AppGraphCtx* ctx); -void appGraphProfilerFrameBegin(AppGraphProfiler* profiler); -void appGraphProfilerFrameEnd(AppGraphProfiler* profiler); -void appGraphProfilerEnable(AppGraphProfiler* profiler, bool enabled); -void appGraphProfilerBegin(AppGraphProfiler* profiler, const char* label); -void appGraphProfilerEnd(AppGraphProfiler* profiler, const char* label); -bool appGraphProfilerGet(AppGraphProfiler* profiler, const char** plabel, float* cpuTime, float* gpuTime, int index); -void appGraphReleaseProfiler(AppGraphProfiler* profiler); - -void AppGraphCtxInitRenderTarget(AppGraphCtx* context, SDL_Window* window, bool fullscreen); - -AppGraphCtx::AppGraphCtx() +AppGraphProfilerD3D11* appGraphCreateProfilerD3D11(AppGraphCtx* ctx); +void appGraphProfilerD3D11FrameBegin(AppGraphProfilerD3D11* profiler); +void appGraphProfilerD3D11FrameEnd(AppGraphProfilerD3D11* profiler); +void appGraphProfilerD3D11Enable(AppGraphProfilerD3D11* profiler, bool enabled); +void appGraphProfilerD3D11Begin(AppGraphProfilerD3D11* profiler, const char* label); +void appGraphProfilerD3D11End(AppGraphProfilerD3D11* profiler, const char* label); +bool appGraphProfilerD3D11Get(AppGraphProfilerD3D11* profiler, const char** plabel, float* cpuTime, float* gpuTime, int index); +void appGraphReleaseProfiler(AppGraphProfilerD3D11* profiler); + +AppGraphCtxD3D11::AppGraphCtxD3D11() { - m_profiler = appGraphCreateProfiler(this); + m_profiler = appGraphCreateProfilerD3D11(cast_from_AppGraphCtxD3D11(this)); } -AppGraphCtx::~AppGraphCtx() +AppGraphCtxD3D11::~AppGraphCtxD3D11() { - AppGraphCtxReleaseRenderTarget(this); + AppGraphCtxReleaseRenderTargetD3D11(cast_from_AppGraphCtxD3D11(this)); COMRelease(m_device); COMRelease(m_deviceContext); @@ -73,9 +71,9 @@ AppGraphCtx::~AppGraphCtx() m_profiler = nullptr; } -AppGraphCtx* AppGraphCtxCreate(int deviceID) +AppGraphCtx* AppGraphCtxCreateD3D11(int deviceID) { - AppGraphCtx* context = new AppGraphCtx; + AppGraphCtxD3D11* context = new AppGraphCtxD3D11; HRESULT hr = S_OK; @@ -160,11 +158,15 @@ AppGraphCtx* AppGraphCtxCreate(int deviceID) return nullptr; } - return context; + return cast_from_AppGraphCtxD3D11(context); } -bool AppGraphCtxUpdateSize(AppGraphCtx* context, SDL_Window* window, bool fullscreen) +void AppGraphCtxInitRenderTargetD3D11(AppGraphCtx* context, SDL_Window* window, bool fullscreen); + +bool AppGraphCtxUpdateSizeD3D11(AppGraphCtx* contextIn, SDL_Window* window, bool fullscreen) { + auto context = cast_to_AppGraphCtxD3D11(contextIn); + // TODO: fix iflip fullscreen support fullscreen = false; @@ -204,18 +206,20 @@ bool AppGraphCtxUpdateSize(AppGraphCtx* context, SDL_Window* window, bool fullsc if (sizeChanged) { - AppGraphCtxReleaseRenderTarget(context); + AppGraphCtxReleaseRenderTargetD3D11(cast_from_AppGraphCtxD3D11(context)); } if (sizeChanged && context->m_valid) { - AppGraphCtxInitRenderTarget(context, window, fullscreen); + AppGraphCtxInitRenderTargetD3D11(cast_from_AppGraphCtxD3D11(context), window, fullscreen); } return context->m_valid; } -void AppGraphCtxInitRenderTarget(AppGraphCtx* context, SDL_Window* window, bool fullscreen) +void AppGraphCtxInitRenderTargetD3D11(AppGraphCtx* contextIn, SDL_Window* window, bool fullscreen) { + auto context = cast_to_AppGraphCtxD3D11(contextIn); + HWND hWnd = nullptr; // get Windows handle to this SDL window SDL_SysWMinfo winInfo; @@ -354,8 +358,10 @@ void AppGraphCtxInitRenderTarget(AppGraphCtx* context, SDL_Window* window, bool } } -void AppGraphCtxReleaseRenderTarget(AppGraphCtx* context) +void AppGraphCtxReleaseRenderTargetD3D11(AppGraphCtx* contextIn) { + auto context = cast_to_AppGraphCtxD3D11(contextIn); + if (context->m_swapChain == nullptr) { return; @@ -376,58 +382,66 @@ void AppGraphCtxReleaseRenderTarget(AppGraphCtx* context) context->m_winH = 0u; } -void AppGraphCtxRelease(AppGraphCtx* context) +void AppGraphCtxReleaseD3D11(AppGraphCtx* context) { if (context == nullptr) return; - delete context; + delete cast_to_AppGraphCtxD3D11(context); } -void AppGraphCtxFrameStart(AppGraphCtx* context, float clearColor[4]) +void AppGraphCtxFrameStartD3D11(AppGraphCtx* contextIn, AppGraphColor clearColor) { - appGraphProfilerFrameBegin(context->m_profiler); + auto context = cast_to_AppGraphCtxD3D11(contextIn); + + appGraphProfilerD3D11FrameBegin(context->m_profiler); context->m_deviceContext->RSSetViewports(1, &context->m_viewport); context->m_deviceContext->RSSetScissorRects(0, nullptr); context->m_deviceContext->OMSetRenderTargets(1, &context->m_rtv, context->m_dsv); - context->m_deviceContext->ClearRenderTargetView(context->m_rtv, clearColor); + context->m_deviceContext->ClearRenderTargetView(context->m_rtv, &clearColor.r); context->m_deviceContext->ClearDepthStencilView(context->m_dsv, D3D11_CLEAR_DEPTH, 1.f, 0u); context->m_deviceContext->OMSetDepthStencilState(context->m_depthState, 0u); } -void AppGraphCtxFramePresent(AppGraphCtx* context, bool fullsync) +void AppGraphCtxFramePresentD3D11(AppGraphCtx* contextIn, bool fullsync) { + auto context = cast_to_AppGraphCtxD3D11(contextIn); + context->m_swapChain->Present(0, 0); - appGraphProfilerFrameEnd(context->m_profiler); + appGraphProfilerD3D11FrameEnd(context->m_profiler); } -void AppGraphCtxWaitForFrames(AppGraphCtx* context, unsigned int maxFramesInFlight) +void AppGraphCtxWaitForFramesD3D11(AppGraphCtx* context, unsigned int maxFramesInFlight) { // TODO: Implement } -void AppGraphCtxProfileEnable(AppGraphCtx* context, bool enabled) +void AppGraphCtxProfileEnableD3D11(AppGraphCtx* contextIn, bool enabled) { - appGraphProfilerEnable(context->m_profiler, enabled); + auto context = cast_to_AppGraphCtxD3D11(contextIn); + appGraphProfilerD3D11Enable(context->m_profiler, enabled); } -void AppGraphCtxProfileBegin(AppGraphCtx* context, const char* label) +void AppGraphCtxProfileBeginD3D11(AppGraphCtx* contextIn, const char* label) { - appGraphProfilerBegin(context->m_profiler, label); + auto context = cast_to_AppGraphCtxD3D11(contextIn); + appGraphProfilerD3D11Begin(context->m_profiler, label); } -void AppGraphCtxProfileEnd(AppGraphCtx* context, const char* label) +void AppGraphCtxProfileEndD3D11(AppGraphCtx* contextIn, const char* label) { - appGraphProfilerEnd(context->m_profiler, label); + auto context = cast_to_AppGraphCtxD3D11(contextIn); + appGraphProfilerD3D11End(context->m_profiler, label); } -bool AppGraphCtxProfileGet(AppGraphCtx* context, const char** plabel, float* cpuTime, float* gpuTime, int index) +bool AppGraphCtxProfileGetD3D11(AppGraphCtx* contextIn, const char** plabel, float* cpuTime, float* gpuTime, int index) { - return appGraphProfilerGet(context->m_profiler, plabel, cpuTime, gpuTime, index); + auto context = cast_to_AppGraphCtxD3D11(contextIn); + return appGraphProfilerD3D11Get(context->m_profiler, plabel, cpuTime, gpuTime, index); } // ******************************* Profiler ********************************* @@ -549,9 +563,9 @@ namespace }; } -struct AppGraphProfiler +struct AppGraphProfilerD3D11 { - AppGraphCtx* m_context; + AppGraphCtxD3D11* m_context; int m_state = 0; bool m_enabled = false; @@ -568,30 +582,30 @@ struct AppGraphProfiler TimerValue m_timerValues[m_timersCap]; int m_timerValuesSize = 0; - AppGraphProfiler(AppGraphCtx* context); - ~AppGraphProfiler(); + AppGraphProfilerD3D11(AppGraphCtx* context); + ~AppGraphProfilerD3D11(); }; -AppGraphProfiler::AppGraphProfiler(AppGraphCtx* context) : m_context(context) +AppGraphProfilerD3D11::AppGraphProfilerD3D11(AppGraphCtx* context) : m_context(cast_to_AppGraphCtxD3D11(context)) { } -AppGraphProfiler::~AppGraphProfiler() +AppGraphProfilerD3D11::~AppGraphProfilerD3D11() { COMRelease(m_disjoint); } -AppGraphProfiler* appGraphCreateProfiler(AppGraphCtx* ctx) +AppGraphProfilerD3D11* appGraphCreateProfilerD3D11(AppGraphCtx* ctx) { - return new AppGraphProfiler(ctx); + return new AppGraphProfilerD3D11(ctx); } -void appGraphReleaseProfiler(AppGraphProfiler* profiler) +void appGraphReleaseProfiler(AppGraphProfilerD3D11* profiler) { delete profiler; } -void appGraphProfilerFrameBegin(AppGraphProfiler* p) +void appGraphProfilerD3D11FrameBegin(AppGraphProfilerD3D11* p) { p->m_frameTime = (float)p->m_frameTimer.getDeltaTime(); @@ -616,7 +630,7 @@ void appGraphProfilerFrameBegin(AppGraphProfiler* p) } } -void appGraphProfilerFrameEnd(AppGraphProfiler* p) +void appGraphProfilerD3D11FrameEnd(AppGraphProfilerD3D11* p) { if (p->m_state == 1) { @@ -628,12 +642,12 @@ void appGraphProfilerFrameEnd(AppGraphProfiler* p) } } -void appGraphProfilerEnable(AppGraphProfiler* p, bool enabled) +void appGraphProfilerD3D11Enable(AppGraphProfilerD3D11* p, bool enabled) { p->m_enabled = enabled; } -void appGraphProfilerBegin(AppGraphProfiler* p, const char* label) +void appGraphProfilerD3D11Begin(AppGraphProfilerD3D11* p, const char* label) { if (p->m_state == 1 && p->m_timersSize < p->m_timersCap) { @@ -657,7 +671,7 @@ void appGraphProfilerBegin(AppGraphProfiler* p, const char* label) } } -void appGraphProfilerEnd(AppGraphProfiler* p, const char* label) +void appGraphProfilerD3D11End(AppGraphProfilerD3D11* p, const char* label) { if (p->m_state == 1) { @@ -681,7 +695,7 @@ void appGraphProfilerEnd(AppGraphProfiler* p, const char* label) } } -bool appGraphProfilerFlush(AppGraphProfiler* p) +bool appGraphProfilerD3D11Flush(AppGraphProfilerD3D11* p) { if (p->m_state == 2) { @@ -740,9 +754,9 @@ bool appGraphProfilerFlush(AppGraphProfiler* p) return false; } -bool appGraphProfilerGet(AppGraphProfiler* p, const char** plabel, float* cpuTime, float* gpuTime, int index) +bool appGraphProfilerD3D11Get(AppGraphProfilerD3D11* p, const char** plabel, float* cpuTime, float* gpuTime, int index) { - appGraphProfilerFlush(p); + appGraphProfilerD3D11Flush(p); { if (index < p->m_timerValuesSize) { @@ -760,7 +774,8 @@ bool appGraphProfilerGet(AppGraphProfiler* p, const char** plabel, float* cpuTim return false; } -size_t AppGraphCtxDedicatedVideoMemory(AppGraphCtx* context) +size_t AppGraphCtxDedicatedVideoMemoryD3D11(AppGraphCtx* contextIn) { + auto context = cast_to_AppGraphCtxD3D11(contextIn); return context->m_dedicatedVideoMemory; }
\ No newline at end of file diff --git a/demo/DemoAppD3D11/appD3D11Ctx.h b/demo/DemoAppD3D11/appD3D11Ctx.h index 578413c..c811f8b 100644 --- a/demo/DemoAppD3D11/appD3D11Ctx.h +++ b/demo/DemoAppD3D11/appD3D11Ctx.h @@ -12,9 +12,9 @@ #include "../DemoApp/appGraphCtx.h" -struct AppGraphProfiler; +struct AppGraphProfilerD3D11; -struct AppGraphCtx +struct AppGraphCtxD3D11 { HWND m_hWnd = nullptr; @@ -36,8 +36,42 @@ struct AppGraphCtx ID3D11ShaderResourceView* m_depthSRV = nullptr; ID3D11DepthStencilState* m_depthState = nullptr; - AppGraphProfiler* m_profiler = nullptr; + AppGraphProfilerD3D11* m_profiler = nullptr; - AppGraphCtx(); - ~AppGraphCtx(); -};
\ No newline at end of file + AppGraphCtxD3D11(); + ~AppGraphCtxD3D11(); +}; + +inline AppGraphCtxD3D11* cast_to_AppGraphCtxD3D11(AppGraphCtx* appctx) +{ + return (AppGraphCtxD3D11*)(appctx); +} + +inline AppGraphCtx* cast_from_AppGraphCtxD3D11(AppGraphCtxD3D11* appctx) +{ + return (AppGraphCtx*)(appctx); +} + +APP_GRAPH_CTX_API AppGraphCtx* AppGraphCtxCreateD3D11(int deviceID); + +APP_GRAPH_CTX_API bool AppGraphCtxUpdateSizeD3D11(AppGraphCtx* context, SDL_Window* window, bool fullscreen); + +APP_GRAPH_CTX_API void AppGraphCtxReleaseRenderTargetD3D11(AppGraphCtx* context); + +APP_GRAPH_CTX_API void AppGraphCtxReleaseD3D11(AppGraphCtx* context); + +APP_GRAPH_CTX_API void AppGraphCtxFrameStartD3D11(AppGraphCtx* context, AppGraphColor clearColor); + +APP_GRAPH_CTX_API void AppGraphCtxFramePresentD3D11(AppGraphCtx* context, bool fullsync); + +APP_GRAPH_CTX_API void AppGraphCtxWaitForFramesD3D11(AppGraphCtx* context, unsigned int maxFramesInFlight); + +APP_GRAPH_CTX_API void AppGraphCtxProfileEnableD3D11(AppGraphCtx* context, bool enabled); + +APP_GRAPH_CTX_API void AppGraphCtxProfileBeginD3D11(AppGraphCtx* context, const char* label); + +APP_GRAPH_CTX_API void AppGraphCtxProfileEndD3D11(AppGraphCtx* context, const char* label); + +APP_GRAPH_CTX_API bool AppGraphCtxProfileGetD3D11(AppGraphCtx* context, const char** plabel, float* cpuTime, float* gpuTime, int index); + +APP_GRAPH_CTX_API size_t AppGraphCtxDedicatedVideoMemoryD3D11(AppGraphCtx* context);
\ No newline at end of file diff --git a/demo/DemoAppD3D11/computeContextD3D11.cpp b/demo/DemoAppD3D11/computeContextD3D11.cpp index 2f25f95..f4b4c3e 100644 --- a/demo/DemoAppD3D11/computeContextD3D11.cpp +++ b/demo/DemoAppD3D11/computeContextD3D11.cpp @@ -21,9 +21,9 @@ void inline COMRelease(T& t) t = nullptr; } -struct ComputeContext +struct ComputeContextD3D11 { - ComputeContextDesc m_desc = {}; + ComputeContextDescD3D11 m_desc = {}; ID3D11SamplerState* m_sampler0 = nullptr; ID3D11SamplerState* m_sampler1 = nullptr; @@ -32,8 +32,10 @@ struct ComputeContext ID3D11SamplerState* m_sampler4 = nullptr; ID3D11SamplerState* m_sampler5 = nullptr; - ComputeContext(const ComputeContextDesc* desc) + ComputeContextD3D11(const ComputeContextDesc* descIn) { + const auto desc = cast_to_ComputeContextDescD3D11(descIn); + m_desc = *desc; auto createSampler = [&](D3D11_FILTER filter, D3D11_TEXTURE_ADDRESS_MODE mode) @@ -64,7 +66,7 @@ struct ComputeContext m_sampler4 = createSampler(D3D11_FILTER_MIN_MAG_LINEAR_MIP_POINT, D3D11_TEXTURE_ADDRESS_CLAMP); m_sampler5 = createSampler(D3D11_FILTER_MIN_MAG_MIP_POINT, D3D11_TEXTURE_ADDRESS_CLAMP); } - ~ComputeContext() + ~ComputeContextD3D11() { COMRelease(m_sampler0); COMRelease(m_sampler1); @@ -75,43 +77,74 @@ struct ComputeContext } }; -struct ComputeShader +inline ComputeContextD3D11* cast_to_ComputeContextD3D11(ComputeContext* ctx) +{ + return (ComputeContextD3D11*)(ctx); +} + +inline ComputeContext* cast_from_ComputeContextD3D11(ComputeContextD3D11* ctx) +{ + return (ComputeContext*)(ctx); +} + +struct ComputeShaderD3D11 { ID3D11ComputeShader* m_shader = nullptr; - ComputeShader(ID3D11ComputeShader* shader) + ComputeShaderD3D11(ID3D11ComputeShader* shader) { m_shader = shader; } - ~ComputeShader() + ~ComputeShaderD3D11() { COMRelease(m_shader); } }; -struct ComputeConstantBuffer +inline ComputeShaderD3D11* cast_to_ComputeShaderD3D11(ComputeShader* ctx) +{ + return (ComputeShaderD3D11*)(ctx); +} + +inline ComputeShader* cast_from_ComputeShaderD3D11(ComputeShaderD3D11* ctx) +{ + return (ComputeShader*)(ctx); +} + +struct ComputeConstantBufferD3D11 { ID3D11Buffer* m_buffer; - ComputeConstantBuffer(ID3D11Buffer* buffer) + ComputeConstantBufferD3D11(ID3D11Buffer* buffer) { m_buffer = buffer; } - ~ComputeConstantBuffer() + ~ComputeConstantBufferD3D11() { COMRelease(m_buffer); } }; -struct ComputeResource +inline ComputeConstantBufferD3D11* cast_to_ComputeConstantBufferD3D11(ComputeConstantBuffer* ctx) +{ + return (ComputeConstantBufferD3D11*)(ctx); +} + +inline ComputeConstantBuffer* cast_from_ComputeConstantBufferD3D11(ComputeConstantBufferD3D11* ctx) +{ + return (ComputeConstantBuffer*)(ctx); +} + +struct ComputeResourceD3D11 { protected: ID3D11ShaderResourceView* m_srv = nullptr; public: - void update(const ComputeResourceDesc* desc) + void update(const ComputeResourceDesc* descIn) { + const auto desc = cast_to_ComputeResourceDescD3D11(descIn); m_srv = desc->srv; } - ComputeResource(const ComputeResourceDesc* desc) + ComputeResourceD3D11(const ComputeResourceDesc* desc) { update(desc); } @@ -122,20 +155,37 @@ public: } }; -struct ComputeResourceRW : public ComputeResource +inline ComputeResourceD3D11* cast_to_ComputeResourceD3D11(ComputeResource* ctx) +{ + return (ComputeResourceD3D11*)(ctx); +} + +inline ComputeResource* cast_from_ComputeResourceD3D11(ComputeResourceD3D11* ctx) +{ + return (ComputeResource*)(ctx); +} + +struct ComputeResourceRWD3D11 : public ComputeResourceD3D11 { protected: ID3D11UnorderedAccessView* m_uav; public: - void update(const ComputeResourceRWDesc* descRW) + static const ComputeResourceRWDescD3D11* cast(const ComputeResourceRWDesc* descRW) { + return cast_to_ComputeResourceRWDescD3D11(descRW); + } + + void update(const ComputeResourceRWDesc* descRWIn) + { + const auto descRW = cast(descRWIn); m_uav = descRW->uav; - ComputeResource::update(&descRW->resource); + ComputeResourceD3D11::update(cast_from_ComputeResourceDescD3D11(&descRW->resource)); } - ComputeResourceRW(const ComputeResourceRWDesc* descRW): - ComputeResource(&descRW->resource) + ComputeResourceRWD3D11(const ComputeResourceRWDesc* descRWIn): + ComputeResourceD3D11(cast_from_ComputeResourceDescD3D11(&cast(descRWIn)->resource)) { + const auto descRW = cast(descRWIn); m_uav = descRW->uav; } @@ -145,37 +195,54 @@ public: } }; +inline ComputeResourceRWD3D11* cast_to_ComputeResourceRWD3D11(ComputeResourceRW* ctx) +{ + return (ComputeResourceRWD3D11*)(ctx); +} + +inline ComputeResourceRW* cast_from_ComputeResourceRWD3D11(ComputeResourceRWD3D11* ctx) +{ + return (ComputeResourceRW*)(ctx); +} + // ************* API functions **************** -ComputeContext* ComputeContextCreate(ComputeContextDesc* desc) +ComputeContext* ComputeContextCreateD3D11(ComputeContextDesc* desc) { - return new ComputeContext(desc); + return cast_from_ComputeContextD3D11(new ComputeContextD3D11(desc)); } -void ComputeContextUpdate(ComputeContext* context, ComputeContextDesc* desc) +void ComputeContextUpdateD3D11(ComputeContext* contextIn, ComputeContextDesc* descIn) { + auto context = cast_to_ComputeContextD3D11(contextIn); + auto desc = cast_to_ComputeContextDescD3D11(descIn); + context->m_desc = *desc; } -void ComputeContextRelease(ComputeContext* context) +void ComputeContextReleaseD3D11(ComputeContext* context) { - delete context; + delete cast_to_ComputeContextD3D11(context); } -ComputeShader* ComputeShaderCreate(ComputeContext* context, const ComputeShaderDesc* desc) +ComputeShader* ComputeShaderCreateD3D11(ComputeContext* contextIn, const ComputeShaderDesc* desc) { + auto context = cast_to_ComputeContextD3D11(contextIn); + ID3D11ComputeShader* computeShader = nullptr; context->m_desc.device->CreateComputeShader(desc->cs, desc->cs_length, nullptr, &computeShader); - return new ComputeShader(computeShader); + return cast_from_ComputeShaderD3D11(new ComputeShaderD3D11(computeShader)); } -void ComputeShaderRelease(ComputeShader* shader) +void ComputeShaderReleaseD3D11(ComputeShader* shader) { - delete shader; + delete cast_to_ComputeShaderD3D11(shader); } -ComputeConstantBuffer* ComputeConstantBufferCreate(ComputeContext* context, const ComputeConstantBufferDesc* desc) +ComputeConstantBuffer* ComputeConstantBufferCreateD3D11(ComputeContext* contextIn, const ComputeConstantBufferDesc* desc) { + auto context = cast_to_ComputeContextD3D11(contextIn); + ID3D11Buffer* constantBuffer = nullptr; { D3D11_BUFFER_DESC bufDesc; @@ -187,81 +254,94 @@ ComputeConstantBuffer* ComputeConstantBufferCreate(ComputeContext* context, cons context->m_desc.device->CreateBuffer(&bufDesc, nullptr, &constantBuffer); } - return new ComputeConstantBuffer(constantBuffer); + return cast_from_ComputeConstantBufferD3D11(new ComputeConstantBufferD3D11(constantBuffer)); } -void ComputeConstantBufferRelease(ComputeConstantBuffer* constantBuffer) +void ComputeConstantBufferReleaseD3D11(ComputeConstantBuffer* constantBuffer) { - delete constantBuffer; + delete cast_to_ComputeConstantBufferD3D11(constantBuffer); } -void* ComputeConstantBufferMap(ComputeContext* context, ComputeConstantBuffer* constantBuffer) +void* ComputeConstantBufferMapD3D11(ComputeContext* contextIn, ComputeConstantBuffer* constantBufferIn) { + auto context = cast_to_ComputeContextD3D11(contextIn); + auto constantBuffer = cast_to_ComputeConstantBufferD3D11(constantBufferIn); + D3D11_MAPPED_SUBRESOURCE mapped = {}; context->m_desc.deviceContext->Map(constantBuffer->m_buffer, 0u, D3D11_MAP_WRITE_DISCARD, 0u, &mapped); return mapped.pData; } -void ComputeConstantBufferUnmap(ComputeContext* context, ComputeConstantBuffer* constantBuffer) +void ComputeConstantBufferUnmapD3D11(ComputeContext* contextIn, ComputeConstantBuffer* constantBufferIn) { + auto context = cast_to_ComputeContextD3D11(contextIn); + auto constantBuffer = cast_to_ComputeConstantBufferD3D11(constantBufferIn); + context->m_desc.deviceContext->Unmap(constantBuffer->m_buffer, 0u); } -ComputeResource* ComputeResourceCreate(ComputeContext* context, const ComputeResourceDesc* desc) +ComputeResource* ComputeResourceCreateD3D11(ComputeContext* context, const ComputeResourceDesc* desc) { - return new ComputeResource(desc); + return cast_from_ComputeResourceD3D11(new ComputeResourceD3D11(desc)); } -void ComputeResourceUpdate(ComputeContext* context, ComputeResource* resource, const ComputeResourceDesc* desc) +void ComputeResourceUpdateD3D11(ComputeContext* context, ComputeResource* resourceIn, const ComputeResourceDesc* desc) { + auto resource = cast_to_ComputeResourceD3D11(resourceIn); + resource->update(desc); } -void ComputeResourceRelease(ComputeResource* resource) +void ComputeResourceReleaseD3D11(ComputeResource* resource) { - delete resource; + delete cast_to_ComputeResourceD3D11(resource); } -ComputeResourceRW* ComputeResourceRWCreate(ComputeContext* context, const ComputeResourceRWDesc* desc) +ComputeResourceRW* ComputeResourceRWCreateD3D11(ComputeContext* context, const ComputeResourceRWDesc* desc) { - return new ComputeResourceRW(desc); + return cast_from_ComputeResourceRWD3D11(new ComputeResourceRWD3D11(desc)); } -void ComputeResourceRWUpdate(ComputeContext* context, ComputeResourceRW* resourceRW, const ComputeResourceRWDesc* desc) +void ComputeResourceRWUpdateD3D11(ComputeContext* context, ComputeResourceRW* resourceRWIn, const ComputeResourceRWDesc* desc) { + auto resourceRW = cast_to_ComputeResourceRWD3D11(resourceRWIn); + resourceRW->update(desc); } -void ComputeResourceRWRelease(ComputeResourceRW* resourceRW) +void ComputeResourceRWReleaseD3D11(ComputeResourceRW* resourceRW) { - delete resourceRW; + delete cast_to_ComputeResourceRWD3D11(resourceRW); } -ComputeResource* ComputeResourceRWGetResource(ComputeResourceRW* resourceRW) +ComputeResource* ComputeResourceRWGetResourceD3D11(ComputeResourceRW* resourceRWIn) { - return static_cast<ComputeResource*>(resourceRW); + auto resourceRW = cast_to_ComputeResourceRWD3D11(resourceRWIn); + return cast_from_ComputeResourceD3D11(static_cast<ComputeResourceD3D11*>(resourceRW)); } -void ComputeContextDispatch(ComputeContext* context, const ComputeDispatchParams* params) +void ComputeContextDispatchD3D11(ComputeContext* contextIn, const ComputeDispatchParams* params) { + auto context = cast_to_ComputeContextD3D11(contextIn); + auto& deviceContext = context->m_desc.deviceContext; - if (params->shader) deviceContext->CSSetShader(params->shader->m_shader, nullptr, 0u); + if (params->shader) deviceContext->CSSetShader(cast_to_ComputeShaderD3D11(params->shader)->m_shader, nullptr, 0u); ID3D11ShaderResourceView* srvs[ComputeDispatchMaxResources] = { nullptr }; ID3D11UnorderedAccessView* uavs[ComputeDispatchMaxResourcesRW] = { nullptr }; for (unsigned int i = 0u; i < ComputeDispatchMaxResources; i++) { - if (params->resources[i]) srvs[i] = params->resources[i]->SRV(); + if (params->resources[i]) srvs[i] = cast_to_ComputeResourceD3D11(params->resources[i])->SRV(); } for (unsigned int i = 0u; i < ComputeDispatchMaxResourcesRW; i++) { - if (params->resourcesRW[i]) uavs[i] = params->resourcesRW[i]->UAV(); + if (params->resourcesRW[i]) uavs[i] = cast_to_ComputeResourceRWD3D11(params->resourcesRW[i])->UAV(); } deviceContext->CSSetShaderResources(0u, ComputeDispatchMaxResources, srvs); deviceContext->CSSetUnorderedAccessViews(0u, ComputeDispatchMaxResourcesRW, uavs, nullptr); - if (params->constantBuffer) deviceContext->CSSetConstantBuffers(0u, 1u, ¶ms->constantBuffer->m_buffer); + if (params->constantBuffer) deviceContext->CSSetConstantBuffers(0u, 1u, &cast_to_ComputeConstantBufferD3D11(params->constantBuffer)->m_buffer); ID3D11SamplerState* samplers[] = { context->m_sampler0, context->m_sampler1, context->m_sampler2, @@ -282,7 +362,7 @@ void ComputeContextDispatch(ComputeContext* context, const ComputeDispatchParams #include "NvFlow.h" #include "NvFlowContextD3D11.h" -inline void updateComputeContextDesc(NvFlowContext* flowContext, ComputeContextDesc* desc) +inline void updateComputeContextDesc(NvFlowContext* flowContext, ComputeContextDescD3D11* desc) { NvFlowContextDescD3D11 srcDesc = {}; NvFlowUpdateContextDescD3D11(flowContext, &srcDesc); @@ -290,54 +370,54 @@ inline void updateComputeContextDesc(NvFlowContext* flowContext, ComputeContextD desc->deviceContext = srcDesc.deviceContext; } -ComputeContext* ComputeContextNvFlowContextCreate(NvFlowContext* flowContext) +ComputeContext* ComputeContextNvFlowContextCreateD3D11(NvFlowContext* flowContext) { - ComputeContextDesc desc = {}; + ComputeContextDescD3D11 desc = {}; updateComputeContextDesc(flowContext, &desc); - return ComputeContextCreate(&desc); + return ComputeContextCreateD3D11(cast_from_ComputeContextDescD3D11(&desc)); } -void ComputeContextNvFlowContextUpdate(ComputeContext* computeContext, NvFlowContext* flowContext) +void ComputeContextNvFlowContextUpdateD3D11(ComputeContext* computeContext, NvFlowContext* flowContext) { - ComputeContextDesc desc = {}; + ComputeContextDescD3D11 desc = {}; updateComputeContextDesc(flowContext, &desc); - ComputeContextUpdate(computeContext, &desc); + ComputeContextUpdateD3D11(computeContext, cast_from_ComputeContextDescD3D11(&desc)); } -ComputeResource* ComputeResourceNvFlowCreate(ComputeContext* context, NvFlowContext* flowContext, NvFlowResource* flowResource) +ComputeResource* ComputeResourceNvFlowCreateD3D11(ComputeContext* context, NvFlowContext* flowContext, NvFlowResource* flowResource) { NvFlowResourceViewDescD3D11 flowViewDesc = {}; NvFlowUpdateResourceViewDescD3D11(flowContext, flowResource, &flowViewDesc); - ComputeResourceDesc desc = {}; + ComputeResourceDescD3D11 desc = {}; desc.srv = flowViewDesc.srv; - return ComputeResourceCreate(context, &desc); + return ComputeResourceCreateD3D11(context, cast_from_ComputeResourceDescD3D11(&desc)); } -void ComputeResourceNvFlowUpdate(ComputeContext* context, ComputeResource* resource, NvFlowContext* flowContext, NvFlowResource* flowResource) +void ComputeResourceNvFlowUpdateD3D11(ComputeContext* context, ComputeResource* resource, NvFlowContext* flowContext, NvFlowResource* flowResource) { NvFlowResourceViewDescD3D11 flowViewDesc = {}; NvFlowUpdateResourceViewDescD3D11(flowContext, flowResource, &flowViewDesc); - ComputeResourceDesc desc = {}; + ComputeResourceDescD3D11 desc = {}; desc.srv = flowViewDesc.srv; - ComputeResourceUpdate(context, resource, &desc); + ComputeResourceUpdateD3D11(context, resource, cast_from_ComputeResourceDescD3D11(&desc)); } -ComputeResourceRW* ComputeResourceRWNvFlowCreate(ComputeContext* context, NvFlowContext* flowContext, NvFlowResourceRW* flowResourceRW) +ComputeResourceRW* ComputeResourceRWNvFlowCreateD3D11(ComputeContext* context, NvFlowContext* flowContext, NvFlowResourceRW* flowResourceRW) { NvFlowResourceRWViewDescD3D11 flowViewDesc = {}; NvFlowUpdateResourceRWViewDescD3D11(flowContext, flowResourceRW, &flowViewDesc); - ComputeResourceRWDesc desc = {}; + ComputeResourceRWDescD3D11 desc = {}; desc.resource.srv = flowViewDesc.resourceView.srv; desc.uav = flowViewDesc.uav; - return ComputeResourceRWCreate(context, &desc); + return ComputeResourceRWCreateD3D11(context, cast_from_ComputeResourceRWDescD3D11(&desc)); } -void ComputeResourceRWNvFlowUpdate(ComputeContext* context, ComputeResourceRW* resourceRW, NvFlowContext* flowContext, NvFlowResourceRW* flowResourceRW) +void ComputeResourceRWNvFlowUpdateD3D11(ComputeContext* context, ComputeResourceRW* resourceRW, NvFlowContext* flowContext, NvFlowResourceRW* flowResourceRW) { NvFlowResourceRWViewDescD3D11 flowViewDesc = {}; NvFlowUpdateResourceRWViewDescD3D11(flowContext, flowResourceRW, &flowViewDesc); - ComputeResourceRWDesc desc = {}; + ComputeResourceRWDescD3D11 desc = {}; desc.resource.srv = flowViewDesc.resourceView.srv; desc.uav = flowViewDesc.uav; - ComputeResourceRWUpdate(context, resourceRW, &desc); + ComputeResourceRWUpdateD3D11(context, resourceRW, cast_from_ComputeResourceRWDescD3D11(&desc)); }
\ No newline at end of file diff --git a/demo/DemoAppD3D11/computeContextD3D11.h b/demo/DemoAppD3D11/computeContextD3D11.h index 43ad5b1..a8a2189 100644 --- a/demo/DemoAppD3D11/computeContextD3D11.h +++ b/demo/DemoAppD3D11/computeContextD3D11.h @@ -12,19 +12,95 @@ #include "../DemoApp/computeContext.h" -struct ComputeContextDesc +struct ComputeContextDescD3D11 { ID3D11Device* device; ID3D11DeviceContext* deviceContext; }; -struct ComputeResourceDesc +struct ComputeResourceDescD3D11 { ID3D11ShaderResourceView* srv; }; -struct ComputeResourceRWDesc +struct ComputeResourceRWDescD3D11 { - ComputeResourceDesc resource; + ComputeResourceDescD3D11 resource; ID3D11UnorderedAccessView* uav; -};
\ No newline at end of file +}; + +inline const ComputeContextDescD3D11* cast_to_ComputeContextDescD3D11(const ComputeContextDesc* desc) +{ + return (const ComputeContextDescD3D11*)(desc); +} + +inline ComputeContextDesc* cast_from_ComputeContextDescD3D11(ComputeContextDescD3D11* desc) +{ + return (ComputeContextDesc*)(desc); +} + +inline const ComputeResourceDescD3D11* cast_to_ComputeResourceDescD3D11(const ComputeResourceDesc* desc) +{ + return (const ComputeResourceDescD3D11*)(desc); +} + +inline const ComputeResourceDesc* cast_from_ComputeResourceDescD3D11(const ComputeResourceDescD3D11* desc) +{ + return (const ComputeResourceDesc*)(desc); +} + +inline const ComputeResourceRWDescD3D11* cast_to_ComputeResourceRWDescD3D11(const ComputeResourceRWDesc* desc) +{ + return (const ComputeResourceRWDescD3D11*)(desc); +} + +inline ComputeResourceRWDesc* cast_from_ComputeResourceRWDescD3D11(ComputeResourceRWDescD3D11* desc) +{ + return (ComputeResourceRWDesc*)(desc); +} + +COMPUTE_API ComputeContext* ComputeContextCreateD3D11(ComputeContextDesc* desc); + +COMPUTE_API void ComputeContextUpdateD3D11(ComputeContext* context, ComputeContextDesc* desc); + +COMPUTE_API void ComputeContextReleaseD3D11(ComputeContext* context); + +COMPUTE_API ComputeShader* ComputeShaderCreateD3D11(ComputeContext* context, const ComputeShaderDesc* desc); + +COMPUTE_API void ComputeShaderReleaseD3D11(ComputeShader* shader); + +COMPUTE_API ComputeConstantBuffer* ComputeConstantBufferCreateD3D11(ComputeContext* context, const ComputeConstantBufferDesc* desc); + +COMPUTE_API void ComputeConstantBufferReleaseD3D11(ComputeConstantBuffer* constantBuffer); + +COMPUTE_API void* ComputeConstantBufferMapD3D11(ComputeContext* context, ComputeConstantBuffer* constantBuffer); + +COMPUTE_API void ComputeConstantBufferUnmapD3D11(ComputeContext* context, ComputeConstantBuffer* constantBuffer); + +COMPUTE_API ComputeResource* ComputeResourceCreateD3D11(ComputeContext* context, const ComputeResourceDesc* desc); + +COMPUTE_API void ComputeResourceUpdateD3D11(ComputeContext* context, ComputeResource* resource, const ComputeResourceDesc* desc); + +COMPUTE_API void ComputeResourceReleaseD3D11(ComputeResource* resource); + +COMPUTE_API ComputeResourceRW* ComputeResourceRWCreateD3D11(ComputeContext* context, const ComputeResourceRWDesc* desc); + +COMPUTE_API void ComputeResourceRWUpdateD3D11(ComputeContext* context, ComputeResourceRW* resourceRW, const ComputeResourceRWDesc* desc); + +COMPUTE_API void ComputeResourceRWReleaseD3D11(ComputeResourceRW* resourceRW); + +COMPUTE_API ComputeResource* ComputeResourceRWGetResourceD3D11(ComputeResourceRW* resourceRW); + +COMPUTE_API void ComputeContextDispatchD3D11(ComputeContext* context, const ComputeDispatchParams* params); + +COMPUTE_API ComputeContext* ComputeContextNvFlowContextCreateD3D11(NvFlowContext* flowContext); + +COMPUTE_API void ComputeContextNvFlowContextUpdateD3D11(ComputeContext* computeContext, NvFlowContext* flowContext); + +COMPUTE_API ComputeResource* ComputeResourceNvFlowCreateD3D11(ComputeContext* context, NvFlowContext* flowContext, NvFlowResource* flowResource); + +COMPUTE_API void ComputeResourceNvFlowUpdateD3D11(ComputeContext* context, ComputeResource* resource, NvFlowContext* flowContext, NvFlowResource* flowResource); + +COMPUTE_API ComputeResourceRW* ComputeResourceRWNvFlowCreateD3D11(ComputeContext* context, NvFlowContext* flowContext, NvFlowResourceRW* flowResourceRW); + +COMPUTE_API void ComputeResourceRWNvFlowUpdateD3D11(ComputeContext* context, ComputeResourceRW* resourceRW, NvFlowContext* flowContext, NvFlowResourceRW* flowResourceRW);
\ No newline at end of file diff --git a/demo/DemoAppD3D11/imguiGraphD3D11.cpp b/demo/DemoAppD3D11/imguiGraphD3D11.cpp index a654cf2..0cf619c 100644 --- a/demo/DemoAppD3D11/imguiGraphD3D11.cpp +++ b/demo/DemoAppD3D11/imguiGraphD3D11.cpp @@ -77,7 +77,7 @@ namespace }; } -void imguiGraphContextDestroy() +void imguiGraphContextDestroyD3D11() { COMRelease(m_rasterizerState); COMRelease(m_samplerState); @@ -89,8 +89,10 @@ void imguiGraphContextDestroy() COMRelease(m_vertexBuffer); } -void imguiGraphContextInit(const ImguiGraphDesc* desc) +void imguiGraphContextInitD3D11(const ImguiGraphDesc* descIn) { + const auto desc = cast_to_imguiGraphDescD3D11(descIn); + m_device = desc->device; m_deviceContext = desc->deviceContext; m_winW = desc->winW; @@ -202,15 +204,17 @@ void imguiGraphContextInit(const ImguiGraphDesc* desc) } } -void imguiGraphContextUpdate(const ImguiGraphDesc* desc) +void imguiGraphContextUpdateD3D11(const ImguiGraphDesc* descIn) { + const auto desc = cast_to_imguiGraphDescD3D11(descIn); + m_device = desc->device; m_deviceContext = desc->deviceContext; m_winW = desc->winW; m_winH = desc->winH; } -void imguiGraphRecordBegin() +void imguiGraphRecordBeginD3D11() { Params params = { 2.f / float(m_winW), 0.f, 0.f, -1.f, @@ -318,7 +322,7 @@ static void imguiGraphFlush() } } -void imguiGraphRecordEnd() +void imguiGraphRecordEndD3D11() { ID3D11DeviceContext* context = m_deviceContext; @@ -340,7 +344,7 @@ void imguiGraphRecordEnd() context->RSSetState(nullptr); } -void imguiGraphEnableScissor(int x, int y, int width, int height) +void imguiGraphEnableScissorD3D11(int x, int y, int width, int height) { // mark end of last region m_stateScissor.stopIdx = m_stateVertIdx; @@ -355,7 +359,7 @@ void imguiGraphEnableScissor(int x, int y, int width, int height) m_stateScissor.height = height; } -void imguiGraphDisableScissor() +void imguiGraphDisableScissorD3D11() { if (m_stateVertIdx == 0) return; @@ -372,13 +376,13 @@ void imguiGraphDisableScissor() m_stateScissor.height = m_winH; } -void imguiGraphVertex2f(float x, float y) +void imguiGraphVertex2fD3D11(float x, float y) { float v[2] = { x,y }; - imguiGraphVertex2fv(v); + imguiGraphVertex2fvD3D11(v); } -void imguiGraphVertex2fv(const float* v) +void imguiGraphVertex2fvD3D11(const float* v) { // update state m_stateVert.x = v[0]; @@ -393,13 +397,13 @@ void imguiGraphVertex2fv(const float* v) } } -void imguiGraphTexCoord2f(float u, float v) +void imguiGraphTexCoord2fD3D11(float u, float v) { m_stateVert.u = u; m_stateVert.v = v; } -void imguiGraphColor4ub(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha) +void imguiGraphColor4ubD3D11(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha) { m_stateVert.rgba[0] = red; m_stateVert.rgba[1] = green; @@ -407,7 +411,7 @@ void imguiGraphColor4ub(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha) m_stateVert.rgba[3] = alpha; } -void imguiGraphColor4ubv(const uint8_t* v) +void imguiGraphColor4ubvD3D11(const uint8_t* v) { m_stateVert.rgba[0] = v[0]; m_stateVert.rgba[1] = v[1]; @@ -415,18 +419,18 @@ void imguiGraphColor4ubv(const uint8_t* v) m_stateVert.rgba[3] = v[3]; } -void imguiGraphFontTextureEnable() +void imguiGraphFontTextureEnableD3D11() { } -void imguiGraphFontTextureDisable() +void imguiGraphFontTextureDisableD3D11() { m_stateVert.u = -1.f; m_stateVert.v = -1.f; } -void imguiGraphFontTextureInit(unsigned char* data) +void imguiGraphFontTextureInitD3D11(unsigned char* data) { ID3D11DeviceContext* context = m_deviceContext; @@ -465,7 +469,7 @@ void imguiGraphFontTextureInit(unsigned char* data) } -void imguiGraphFontTextureRelease() +void imguiGraphFontTextureReleaseD3D11() { COMRelease(m_texture); COMRelease(m_textureSRV); diff --git a/demo/DemoAppD3D11/imguiGraphD3D11.h b/demo/DemoAppD3D11/imguiGraphD3D11.h index 54e022f..cb3f864 100644 --- a/demo/DemoAppD3D11/imguiGraphD3D11.h +++ b/demo/DemoAppD3D11/imguiGraphD3D11.h @@ -18,7 +18,7 @@ struct ID3D11Device; struct ID3D11DeviceContext; -struct ImguiGraphDesc +struct ImguiGraphDescD3D11 { ID3D11Device* device = nullptr; ID3D11DeviceContext* deviceContext = nullptr; @@ -27,7 +27,49 @@ struct ImguiGraphDesc uint32_t maxVertices = 64 * 4096u; - ImguiGraphDesc() {} + ImguiGraphDescD3D11() {} }; +inline const ImguiGraphDescD3D11* cast_to_imguiGraphDescD3D11(const ImguiGraphDesc* desc) +{ + return (const ImguiGraphDescD3D11*)(desc); +} + +inline ImguiGraphDesc* cast_from_imguiGraphDescD3D11(ImguiGraphDescD3D11* desc) +{ + return (ImguiGraphDesc*)(desc); +} + +IMGUI_GRAPH_API void imguiGraphContextInitD3D11(const ImguiGraphDesc* desc); + +IMGUI_GRAPH_API void imguiGraphContextUpdateD3D11(const ImguiGraphDesc* desc); + +IMGUI_GRAPH_API void imguiGraphContextDestroyD3D11(); + +IMGUI_GRAPH_API void imguiGraphRecordBeginD3D11(); + +IMGUI_GRAPH_API void imguiGraphRecordEndD3D11(); + +IMGUI_GRAPH_API void imguiGraphVertex2fD3D11(float x, float y); + +IMGUI_GRAPH_API void imguiGraphVertex2fvD3D11(const float* v); + +IMGUI_GRAPH_API void imguiGraphTexCoord2fD3D11(float u, float v); + +IMGUI_GRAPH_API void imguiGraphColor4ubD3D11(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha); + +IMGUI_GRAPH_API void imguiGraphColor4ubvD3D11(const uint8_t* v); + +IMGUI_GRAPH_API void imguiGraphFontTextureEnableD3D11(); + +IMGUI_GRAPH_API void imguiGraphFontTextureDisableD3D11(); + +IMGUI_GRAPH_API void imguiGraphEnableScissorD3D11(int x, int y, int width, int height); + +IMGUI_GRAPH_API void imguiGraphDisableScissorD3D11(); + +IMGUI_GRAPH_API void imguiGraphFontTextureInitD3D11(unsigned char* data); + +IMGUI_GRAPH_API void imguiGraphFontTextureReleaseD3D11(); + #endif
\ No newline at end of file diff --git a/demo/DemoAppD3D11/imguiInteropD3D11.cpp b/demo/DemoAppD3D11/imguiInteropD3D11.cpp index 9989aeb..ba8d740 100644 --- a/demo/DemoAppD3D11/imguiInteropD3D11.cpp +++ b/demo/DemoAppD3D11/imguiInteropD3D11.cpp @@ -19,24 +19,32 @@ #include "appD3D11Ctx.h" #include "imguiGraphD3D11.h" -bool imguiInteropGraphInit(imguiGraphInit_t func, const char* fontpath, AppGraphCtx* appctx) +IMGUI_GRAPH_API bool imguiInteropGraphInitD3D11(imguiGraphInit_t func, const char* fontpath, AppGraphCtx* appctx); + +IMGUI_GRAPH_API void imguiInteropGraphUpdateD3D11(imguiGraphUpdate_t func, AppGraphCtx* appctx); + +bool imguiInteropGraphInitD3D11(imguiGraphInit_t func, const char* fontpath, AppGraphCtx* appctxIn) { - ImguiGraphDesc desc; + auto appctx = cast_to_AppGraphCtxD3D11(appctxIn); + + ImguiGraphDescD3D11 desc; desc.device = appctx->m_device; desc.deviceContext = appctx->m_deviceContext; desc.winW = appctx->m_winW; desc.winH = appctx->m_winH; - return func(fontpath, &desc); + return func(fontpath, cast_from_imguiGraphDescD3D11(&desc)); } -void imguiInteropGraphUpdate(imguiGraphUpdate_t func, AppGraphCtx* appctx) +void imguiInteropGraphUpdateD3D11(imguiGraphUpdate_t func, AppGraphCtx* appctxIn) { - ImguiGraphDesc desc; + auto appctx = cast_to_AppGraphCtxD3D11(appctxIn); + + ImguiGraphDescD3D11 desc; desc.device = appctx->m_device; desc.deviceContext = appctx->m_deviceContext; desc.winW = appctx->m_winW; desc.winH = appctx->m_winH; - return func(&desc); + return func(cast_from_imguiGraphDescD3D11(&desc)); }
\ No newline at end of file diff --git a/demo/DemoAppD3D11/meshD3D11.cpp b/demo/DemoAppD3D11/meshD3D11.cpp index 2b119bb..5c84cfa 100644 --- a/demo/DemoAppD3D11/meshD3D11.cpp +++ b/demo/DemoAppD3D11/meshD3D11.cpp @@ -31,7 +31,7 @@ namespace } } -struct MeshContext +struct MeshContextD3D11 { ID3D11Device* m_device = nullptr; ID3D11DeviceContext* m_deviceContext = nullptr; @@ -42,8 +42,8 @@ struct MeshContext ID3D11Buffer* m_constantBuffer = nullptr; ID3D11RasterizerState* m_rasterizerStateRH = nullptr; - MeshContext() {} - ~MeshContext() + MeshContextD3D11() {} + ~MeshContextD3D11() { COMRelease(m_inputLayout); COMRelease(m_meshVS); @@ -53,33 +53,65 @@ struct MeshContext } }; -struct MeshIndexBuffer +inline MeshContextD3D11* cast_to_MeshContextD3D11(MeshContext* ctx) +{ + return (MeshContextD3D11*)(ctx); +} + +inline MeshContext* cast_from_MeshContextD3D11(MeshContextD3D11* ctx) +{ + return (MeshContext*)(ctx); +} + +struct MeshIndexBufferD3D11 { ID3D11Buffer* m_buffer = nullptr; MeshUint m_numElements = 0u; - MeshIndexBuffer() {} - ~MeshIndexBuffer() + MeshIndexBufferD3D11() {} + ~MeshIndexBufferD3D11() { COMRelease(m_buffer); } }; -struct MeshVertexBuffer +inline MeshIndexBufferD3D11* cast_to_MeshIndexBufferD3D11(MeshIndexBuffer* buf) +{ + return (MeshIndexBufferD3D11*)(buf); +} + +inline MeshIndexBuffer* cast_from_MeshIndexBufferD3D11(MeshIndexBufferD3D11* buf) +{ + return (MeshIndexBuffer*)(buf); +} + +struct MeshVertexBufferD3D11 { ID3D11Buffer* m_buffer = nullptr; MeshUint m_numElements = 0u; - MeshVertexBuffer() {} - ~MeshVertexBuffer() + MeshVertexBufferD3D11() {} + ~MeshVertexBufferD3D11() { COMRelease(m_buffer); } }; -MeshContext* MeshContextCreate(const MeshContextDesc* desc) +inline MeshVertexBufferD3D11* cast_to_MeshVertexBufferD3D11(MeshVertexBuffer* buf) { - MeshContext* context = new MeshContext; + return (MeshVertexBufferD3D11*)(buf); +} + +inline MeshVertexBuffer* cast_from_MeshVertexBufferD3D11(MeshVertexBufferD3D11* buf) +{ + return (MeshVertexBuffer*)(buf); +} + +MeshContext* MeshContextCreateD3D11(const MeshContextDesc* descIn) +{ + auto desc = cast_to_MeshContextDescD3D11(descIn); + + MeshContextD3D11* context = new MeshContextD3D11; context->m_device = desc->device; context->m_deviceContext = desc->context; @@ -128,25 +160,30 @@ MeshContext* MeshContextCreate(const MeshContextDesc* desc) context->m_device->CreateRasterizerState(&desc, &context->m_rasterizerStateRH); } - return context; + return cast_from_MeshContextD3D11(context); } -void MeshContextUpdate(MeshContext* context, const MeshContextDesc* desc) +void MeshContextUpdateD3D11(MeshContext* contextIn, const MeshContextDesc* descIn) { + auto context = cast_to_MeshContextD3D11(contextIn); + auto desc = cast_to_MeshContextDescD3D11(descIn); + context->m_device = desc->device; context->m_deviceContext = desc->context; } -void MeshContextRelease(MeshContext* context) +void MeshContextReleaseD3D11(MeshContext* context) { if (context == nullptr) return; - delete context; + delete cast_to_MeshContextD3D11(context); } -MeshIndexBuffer* MeshIndexBufferCreate(MeshContext* context, MeshUint* indices, MeshUint numIndices) +MeshIndexBuffer* MeshIndexBufferCreateD3D11(MeshContext* contextIn, MeshUint* indices, MeshUint numIndices) { - MeshIndexBuffer* buffer = new MeshIndexBuffer; + auto context = cast_to_MeshContextD3D11(contextIn); + + MeshIndexBufferD3D11* buffer = new MeshIndexBufferD3D11; buffer->m_numElements = numIndices; // create an index buffer @@ -166,19 +203,21 @@ MeshIndexBuffer* MeshIndexBufferCreate(MeshContext* context, MeshUint* indices, context->m_device->CreateBuffer(&bufDesc, &data, &buffer->m_buffer); } - return buffer; + return cast_from_MeshIndexBufferD3D11(buffer); } -void MeshIndexBufferRelease(MeshIndexBuffer* buffer) +void MeshIndexBufferReleaseD3D11(MeshIndexBuffer* buffer) { if (buffer == nullptr) return; - delete buffer; + delete cast_to_MeshIndexBufferD3D11(buffer); } -MeshVertexBuffer* MeshVertexBufferCreate(MeshContext* context, MeshVertex* vertices, MeshUint numVertices) +MeshVertexBuffer* MeshVertexBufferCreateD3D11(MeshContext* contextIn, MeshVertex* vertices, MeshUint numVertices) { - MeshVertexBuffer* buffer = new MeshVertexBuffer; + auto context = cast_to_MeshContextD3D11(contextIn); + + MeshVertexBufferD3D11* buffer = new MeshVertexBufferD3D11; buffer->m_numElements = numVertices; // create a vertex buffer @@ -198,18 +237,20 @@ MeshVertexBuffer* MeshVertexBufferCreate(MeshContext* context, MeshVertex* verti context->m_device->CreateBuffer(&bufDesc, &data, &buffer->m_buffer); } - return buffer; + return cast_from_MeshVertexBufferD3D11(buffer); } -void MeshVertexBufferRelease(MeshVertexBuffer* buffer) +void MeshVertexBufferReleaseD3D11(MeshVertexBuffer* buffer) { if (buffer == nullptr) return; - delete buffer; + delete cast_to_MeshVertexBufferD3D11(buffer); } -void MeshContextDraw(MeshContext* context, const MeshContextDrawParams* params) +void MeshContextDrawD3D11(MeshContext* contextIn, const MeshContextDrawParams* params) { + auto context = cast_to_MeshContextD3D11(contextIn); + using namespace DirectX; XMMATRIX matrix = XMMatrixTranspose(XMMatrixMultiply(XMMatrixMultiply( @@ -242,8 +283,8 @@ void MeshContextDraw(MeshContext* context, const MeshContextDrawParams* params) UINT vertexStride = sizeof(MeshVertex); UINT offset = 0u; - deviceContext->IASetVertexBuffers(0, 1, ¶ms->vertexBuffer->m_buffer, &vertexStride, &offset); - deviceContext->IASetIndexBuffer(params->indexBuffer->m_buffer, DXGI_FORMAT_R32_UINT, 0u); + deviceContext->IASetVertexBuffers(0, 1, &cast_to_MeshVertexBufferD3D11(params->vertexBuffer)->m_buffer, &vertexStride, &offset); + deviceContext->IASetIndexBuffer(cast_to_MeshIndexBufferD3D11(params->indexBuffer)->m_buffer, DXGI_FORMAT_R32_UINT, 0u); float depthSign = DirectX::XMVectorGetW(params->params->projection.r[2]); if (depthSign < 0.f) @@ -251,7 +292,7 @@ void MeshContextDraw(MeshContext* context, const MeshContextDrawParams* params) deviceContext->RSSetState(context->m_rasterizerStateRH); } - deviceContext->DrawIndexed((UINT)params->indexBuffer->m_numElements, 0, 0); + deviceContext->DrawIndexed((UINT)cast_to_MeshIndexBufferD3D11(params->indexBuffer)->m_numElements, 0, 0); if (depthSign < 0.f) { diff --git a/demo/DemoAppD3D11/meshD3D11.h b/demo/DemoAppD3D11/meshD3D11.h index 86efe6b..c756d76 100644 --- a/demo/DemoAppD3D11/meshD3D11.h +++ b/demo/DemoAppD3D11/meshD3D11.h @@ -12,8 +12,35 @@ #include "../DemoApp/mesh.h" -struct MeshContextDesc +struct MeshContextDescD3D11 { ID3D11Device* device; ID3D11DeviceContext* context; -};
\ No newline at end of file +}; + +inline const MeshContextDescD3D11* cast_to_MeshContextDescD3D11(const MeshContextDesc* desc) +{ + return (const MeshContextDescD3D11*)(desc); +} + +inline MeshContextDesc* cast_from_MeshContextDescD3D11(MeshContextDescD3D11* desc) +{ + return (MeshContextDesc*)(desc); +} + +MESH_API MeshContext* MeshContextCreateD3D11(const MeshContextDesc* desc); + +MESH_API void MeshContextUpdateD3D11(MeshContext* context, const MeshContextDesc* desc); + +MESH_API void MeshContextReleaseD3D11(MeshContext* context); + + +MESH_API MeshIndexBuffer* MeshIndexBufferCreateD3D11(MeshContext* context, MeshUint* indices, MeshUint numIndices); + +MESH_API void MeshIndexBufferReleaseD3D11(MeshIndexBuffer* buffer); + +MESH_API MeshVertexBuffer* MeshVertexBufferCreateD3D11(MeshContext* context, MeshVertex* vertices, MeshUint numVertices); + +MESH_API void MeshVertexBufferReleaseD3D11(MeshVertexBuffer* buffer); + +MESH_API void MeshContextDrawD3D11(MeshContext* context, const MeshContextDrawParams* params);
\ No newline at end of file diff --git a/demo/DemoAppD3D11/meshInteropD3D11.cpp b/demo/DemoAppD3D11/meshInteropD3D11.cpp index 5ab9a90..40d2473 100644 --- a/demo/DemoAppD3D11/meshInteropD3D11.cpp +++ b/demo/DemoAppD3D11/meshInteropD3D11.cpp @@ -19,20 +19,28 @@ #include "appD3D11Ctx.h" #include "meshD3D11.h" -MeshContext* MeshInteropContextCreate(AppGraphCtx* appctx) +MESH_API MeshContext* MeshInteropContextCreateD3D11(AppGraphCtx* appctx); + +MESH_API void MeshInteropContextUpdateD3D11(MeshContext* context, AppGraphCtx* appctx); + +MeshContext* MeshInteropContextCreateD3D11(AppGraphCtx* appctxIn) { - MeshContextDesc desc = {}; + auto appctx = cast_to_AppGraphCtxD3D11(appctxIn); + + MeshContextDescD3D11 desc = {}; desc.device = appctx->m_device; desc.context = appctx->m_deviceContext; - return MeshContextCreate(&desc); + return MeshContextCreateD3D11(cast_from_MeshContextDescD3D11(&desc)); } -void MeshInteropContextUpdate(MeshContext* context, AppGraphCtx* appctx) +void MeshInteropContextUpdateD3D11(MeshContext* context, AppGraphCtx* appctxIn) { - MeshContextDesc desc = {}; + auto appctx = cast_to_AppGraphCtxD3D11(appctxIn); + + MeshContextDescD3D11 desc = {}; desc.device = appctx->m_device; desc.context = appctx->m_deviceContext; - return MeshContextUpdate(context, &desc); + return MeshContextUpdateD3D11(context, cast_from_MeshContextDescD3D11(&desc)); }
\ No newline at end of file diff --git a/demo/DemoAppD3D12/NvFlowInteropD3D12.cpp b/demo/DemoAppD3D12/NvFlowInteropD3D12.cpp index ce79bcc..ecb13d8 100644 --- a/demo/DemoAppD3D12/NvFlowInteropD3D12.cpp +++ b/demo/DemoAppD3D12/NvFlowInteropD3D12.cpp @@ -15,9 +15,21 @@ #include "NvFlowContextD3D12.h" #include "appD3D12Ctx.h" +NV_FLOW_API NvFlowContext* NvFlowInteropCreateContextD3D12(AppGraphCtx* appctx); + +NV_FLOW_API NvFlowDepthStencilView* NvFlowInteropCreateDepthStencilViewD3D12(AppGraphCtx* appctx, NvFlowContext* flowctx); + +NV_FLOW_API NvFlowRenderTargetView* NvFlowInteropCreateRenderTargetViewD3D12(AppGraphCtx* appctx, NvFlowContext* flowctx); + +NV_FLOW_API void NvFlowInteropUpdateContextD3D12(NvFlowContext* context, AppGraphCtx* appctx); + +NV_FLOW_API void NvFlowInteropUpdateDepthStencilViewD3D12(NvFlowDepthStencilView* view, AppGraphCtx* appctx, NvFlowContext* flowctx); + +NV_FLOW_API void NvFlowInteropUpdateRenderTargetViewD3D12(NvFlowRenderTargetView* view, AppGraphCtx* appctx, NvFlowContext* flowctx); + NvFlowDescriptorReserveHandleD3D12 NvFlowInteropReserveDescriptors(void* userdata, NvFlowUint numDescriptors, NvFlowUint64 lastFenceCompleted, NvFlowUint64 nextFenceValue) { - auto appctx = static_cast<AppGraphCtx*>(userdata); + auto appctx = cast_to_AppGraphCtxD3D12((AppGraphCtx*)userdata); auto srcHandle = appctx->m_dynamicHeapCbvSrvUav.reserveDescriptors(numDescriptors, lastFenceCompleted, nextFenceValue); NvFlowDescriptorReserveHandleD3D12 handle = {}; handle.heap = srcHandle.heap; @@ -27,8 +39,10 @@ NvFlowDescriptorReserveHandleD3D12 NvFlowInteropReserveDescriptors(void* userdat return handle; } -void NvFlowInteropUpdateContextDesc(NvFlowContextDescD3D12* desc, AppGraphCtx* appctx) +void NvFlowInteropUpdateContextDesc(NvFlowContextDescD3D12* desc, AppGraphCtx* appctxIn) { + auto appctx = cast_to_AppGraphCtxD3D12(appctxIn); + desc->device = appctx->m_device; desc->commandQueue = appctx->m_commandQueue; desc->commandQueueFence = appctx->m_fence; @@ -40,28 +54,36 @@ void NvFlowInteropUpdateContextDesc(NvFlowContextDescD3D12* desc, AppGraphCtx* a desc->dynamicHeapCbvSrvUav.reserveDescriptors = NvFlowInteropReserveDescriptors; } -NvFlowContext* NvFlowInteropCreateContext(AppGraphCtx* appctx) +NvFlowContext* NvFlowInteropCreateContextD3D12(AppGraphCtx* appctx) { NvFlowContextDescD3D12 desc = {}; NvFlowInteropUpdateContextDesc(&desc, appctx); return NvFlowCreateContextD3D12(NV_FLOW_VERSION, &desc); } -NvFlowDepthStencilView* NvFlowInteropCreateDepthStencilView(AppGraphCtx* appctx, NvFlowContext* flowctx) +NvFlowDepthStencilView* NvFlowInteropCreateDepthStencilViewD3D12(AppGraphCtx* appctxIn, NvFlowContext* flowctx) { + auto appctx = cast_to_AppGraphCtxD3D12(appctxIn); + NvFlowDepthStencilViewDescD3D12 desc = {}; desc.dsvHandle = appctx->m_current_dsvHandle; desc.dsvDesc = appctx->m_current_dsvDesc; + desc.dsvResource = appctx->m_depthStencil; + desc.dsvCurrentState = D3D12_RESOURCE_STATE_DEPTH_WRITE; + desc.srvHandle = appctx->m_current_depth_srvHandle; desc.srvDesc = appctx->m_current_depth_srvDesc; - desc.resource = appctx->m_depthStencil; - desc.currentState = D3D12_RESOURCE_STATE_DEPTH_WRITE; + desc.srvResource = appctx->m_depthStencil; + desc.srvCurrentState = D3D12_RESOURCE_STATE_DEPTH_WRITE; + desc.viewport = appctx->m_viewport; return NvFlowCreateDepthStencilViewD3D12(flowctx, &desc); } -NvFlowRenderTargetView* NvFlowInteropCreateRenderTargetView(AppGraphCtx* appctx, NvFlowContext* flowctx) +NvFlowRenderTargetView* NvFlowInteropCreateRenderTargetViewD3D12(AppGraphCtx* appctxIn, NvFlowContext* flowctx) { + auto appctx = cast_to_AppGraphCtxD3D12(appctxIn); + NvFlowRenderTargetViewDescD3D12 desc = {}; desc.rtvHandle = appctx->m_current_rtvHandle; desc.rtvDesc = appctx->m_current_rtvDesc; @@ -72,28 +94,36 @@ NvFlowRenderTargetView* NvFlowInteropCreateRenderTargetView(AppGraphCtx* appctx, return NvFlowCreateRenderTargetViewD3D12(flowctx, &desc); } -void NvFlowInteropUpdateContext(NvFlowContext* context, AppGraphCtx* appctx) +void NvFlowInteropUpdateContextD3D12(NvFlowContext* context, AppGraphCtx* appctx) { NvFlowContextDescD3D12 desc = {}; NvFlowInteropUpdateContextDesc(&desc, appctx); NvFlowUpdateContextD3D12(context, &desc); } -void NvFlowInteropUpdateDepthStencilView(NvFlowDepthStencilView* view, AppGraphCtx* appctx, NvFlowContext* flowctx) +void NvFlowInteropUpdateDepthStencilViewD3D12(NvFlowDepthStencilView* view, AppGraphCtx* appctxIn, NvFlowContext* flowctx) { + auto appctx = cast_to_AppGraphCtxD3D12(appctxIn); + NvFlowDepthStencilViewDescD3D12 desc = {}; desc.dsvHandle = appctx->m_current_dsvHandle; desc.dsvDesc = appctx->m_current_dsvDesc; + desc.dsvResource = appctx->m_depthStencil; + desc.dsvCurrentState = D3D12_RESOURCE_STATE_DEPTH_WRITE; + desc.srvHandle = appctx->m_current_depth_srvHandle; desc.srvDesc = appctx->m_current_depth_srvDesc; - desc.resource = appctx->m_depthStencil; - desc.currentState = D3D12_RESOURCE_STATE_DEPTH_WRITE; + desc.srvResource = appctx->m_depthStencil; + desc.srvCurrentState = D3D12_RESOURCE_STATE_DEPTH_WRITE; + desc.viewport = appctx->m_viewport; NvFlowUpdateDepthStencilViewD3D12(flowctx, view, &desc); } -void NvFlowInteropUpdateRenderTargetView(NvFlowRenderTargetView* view, AppGraphCtx* appctx, NvFlowContext* flowctx) +void NvFlowInteropUpdateRenderTargetViewD3D12(NvFlowRenderTargetView* view, AppGraphCtx* appctxIn, NvFlowContext* flowctx) { + auto appctx = cast_to_AppGraphCtxD3D12(appctxIn); + NvFlowRenderTargetViewDescD3D12 desc = {}; desc.rtvHandle = appctx->m_current_rtvHandle; desc.rtvDesc = appctx->m_current_rtvDesc; diff --git a/demo/DemoAppD3D12/appD3D12Ctx.cpp b/demo/DemoAppD3D12/appD3D12Ctx.cpp index 8d1d7ff..1779ba1 100644 --- a/demo/DemoAppD3D12/appD3D12Ctx.cpp +++ b/demo/DemoAppD3D12/appD3D12Ctx.cpp @@ -45,25 +45,23 @@ namespace } } -AppGraphProfiler* appGraphCreateProfiler(AppGraphCtx* ctx); -void appGraphProfilerFrameBegin(AppGraphProfiler* profiler); -void appGraphProfilerFrameEnd(AppGraphProfiler* profiler); -void appGraphProfilerEnable(AppGraphProfiler* profiler, bool enabled); -void appGraphProfilerBegin(AppGraphProfiler* profiler, const char* label); -void appGraphProfilerEnd(AppGraphProfiler* profiler, const char* label); -bool appGraphProfilerGet(AppGraphProfiler* profiler, const char** plabel, float* cpuTime, float* gpuTime, int index); -void appGraphReleaseProfiler(AppGraphProfiler* profiler); - -void AppGraphCtxInitRenderTarget(AppGraphCtx* context, SDL_Window* window, bool fullscreen); - -AppGraphCtx::AppGraphCtx() +AppGraphProfilerD3D12* appGraphCreateProfilerD3D12(AppGraphCtx* ctx); +void appGraphProfilerD3D12FrameBegin(AppGraphProfilerD3D12* profiler); +void appGraphProfilerD3D12FrameEnd(AppGraphProfilerD3D12* profiler); +void appGraphProfilerD3D12Enable(AppGraphProfilerD3D12* profiler, bool enabled); +void appGraphProfilerD3D12Begin(AppGraphProfilerD3D12* profiler, const char* label); +void appGraphProfilerD3D12End(AppGraphProfilerD3D12* profiler, const char* label); +bool appGraphProfilerD3D12Get(AppGraphProfilerD3D12* profiler, const char** plabel, float* cpuTime, float* gpuTime, int index); +void appGraphReleaseProfiler(AppGraphProfilerD3D12* profiler); + +AppGraphCtxD3D12::AppGraphCtxD3D12() { - m_profiler = appGraphCreateProfiler(this); + m_profiler = appGraphCreateProfilerD3D12(cast_from_AppGraphCtxD3D12(this)); } -AppGraphCtx::~AppGraphCtx() +AppGraphCtxD3D12::~AppGraphCtxD3D12() { - AppGraphCtxReleaseRenderTarget(this); + AppGraphCtxReleaseRenderTargetD3D12(cast_from_AppGraphCtxD3D12(this)); COMRelease(m_device); COMRelease(m_commandQueue); @@ -83,9 +81,9 @@ AppGraphCtx::~AppGraphCtx() m_profiler = nullptr; } -AppGraphCtx* AppGraphCtxCreate(int deviceID) +AppGraphCtx* AppGraphCtxCreateD3D12(int deviceID) { - AppGraphCtx* context = new AppGraphCtx; + AppGraphCtxD3D12* context = new AppGraphCtxD3D12; HRESULT hr = S_OK; @@ -247,11 +245,15 @@ AppGraphCtx* AppGraphCtxCreate(int deviceID) } } - return context; + return cast_from_AppGraphCtxD3D12(context); } -bool AppGraphCtxUpdateSize(AppGraphCtx* context, SDL_Window* window, bool fullscreen) +void AppGraphCtxInitRenderTargetD3D12(AppGraphCtx* context, SDL_Window* window, bool fullscreen); + +bool AppGraphCtxUpdateSizeD3D12(AppGraphCtx* contextIn, SDL_Window* window, bool fullscreen) { + auto context = cast_to_AppGraphCtxD3D12(contextIn); + // TODO: fix iflip fullscreen support fullscreen = false; @@ -291,18 +293,20 @@ bool AppGraphCtxUpdateSize(AppGraphCtx* context, SDL_Window* window, bool fullsc if (sizeChanged) { - AppGraphCtxReleaseRenderTarget(context); + AppGraphCtxReleaseRenderTargetD3D12(cast_from_AppGraphCtxD3D12(context)); } if (sizeChanged && context->m_valid) { - AppGraphCtxInitRenderTarget(context, window, fullscreen); + AppGraphCtxInitRenderTargetD3D12(cast_from_AppGraphCtxD3D12(context), window, fullscreen); } return context->m_valid; } -void AppGraphCtxInitRenderTarget(AppGraphCtx* context, SDL_Window* window, bool fullscreen) +void AppGraphCtxInitRenderTargetD3D12(AppGraphCtx* contextIn, SDL_Window* window, bool fullscreen) { + auto context = cast_to_AppGraphCtxD3D12(contextIn); + HWND hWnd = nullptr; // get Windows handle to this SDL window SDL_SysWMinfo winInfo; @@ -473,8 +477,10 @@ void AppGraphCtxInitRenderTarget(AppGraphCtx* context, SDL_Window* window, bool } } -void AppGraphCtxReleaseRenderTarget(AppGraphCtx* context) +void AppGraphCtxReleaseRenderTargetD3D12(AppGraphCtx* contextIn) { + auto context = cast_to_AppGraphCtxD3D12(contextIn); + if (context->m_swapChain == nullptr) { return; @@ -505,15 +511,17 @@ void AppGraphCtxReleaseRenderTarget(AppGraphCtx* context) context->m_winH = 0u; } -void AppGraphCtxRelease(AppGraphCtx* context) +void AppGraphCtxReleaseD3D12(AppGraphCtx* context) { if (context == nullptr) return; - delete context; + delete cast_to_AppGraphCtxD3D12(context); } -void AppGraphCtxFrameStart(AppGraphCtx* context, float clearColor[4]) +void AppGraphCtxFrameStartD3D12(AppGraphCtx* contextIn, AppGraphColor clearColor) { + auto context = cast_to_AppGraphCtxD3D12(contextIn); + // Get back render target index context->m_renderTargetIndex = context->m_swapChain->GetCurrentBackBufferIndex(); @@ -535,7 +543,7 @@ void AppGraphCtxFrameStart(AppGraphCtx* context, float clearColor[4]) // reset command list with this frame's allocator context->m_commandList->Reset(context->m_commandAllocators[context->m_frameIndex], nullptr); - appGraphProfilerFrameBegin(context->m_profiler); + appGraphProfilerD3D12FrameBegin(context->m_profiler); context->m_commandList->RSSetViewports(1, &context->m_viewport); context->m_commandList->RSSetScissorRects(1, &context->m_scissorRect); @@ -555,7 +563,7 @@ void AppGraphCtxFrameStart(AppGraphCtx* context, float clearColor[4]) D3D12_CPU_DESCRIPTOR_HANDLE dsvHandle = context->m_dsvHeap->GetCPUDescriptorHandleForHeapStart(); context->m_commandList->OMSetRenderTargets(1, &rtvHandle, FALSE, &dsvHandle); - context->m_commandList->ClearRenderTargetView(rtvHandle, clearColor, 0, nullptr); + context->m_commandList->ClearRenderTargetView(rtvHandle, &clearColor.r, 0, nullptr); context->m_commandList->ClearDepthStencilView(dsvHandle, D3D12_CLEAR_FLAG_DEPTH, 1.f, 0, 0, nullptr); /// to simplify interop implementation @@ -565,8 +573,10 @@ void AppGraphCtxFrameStart(AppGraphCtx* context, float clearColor[4]) context->m_current_depth_srvHandle = context->m_depthSrvHeap->GetCPUDescriptorHandleForHeapStart(); } -void AppGraphCtxFramePresent(AppGraphCtx* context, bool fullsync) +void AppGraphCtxFramePresentD3D12(AppGraphCtx* contextIn, bool fullsync) { + auto context = cast_to_AppGraphCtxD3D12(contextIn); + D3D12_RESOURCE_BARRIER barrier = {}; barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION; barrier.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE; @@ -590,7 +600,7 @@ void AppGraphCtxFramePresent(AppGraphCtx* context, bool fullsync) context->m_renderTargetID++; } - appGraphProfilerFrameEnd(context->m_profiler); + appGraphProfilerD3D12FrameEnd(context->m_profiler); // signal for this frame id context->m_frameID++; @@ -615,8 +625,10 @@ void AppGraphCtxFramePresent(AppGraphCtx* context, bool fullsync) } } -void AppGraphCtxWaitForFrames(AppGraphCtx* context, unsigned int maxFramesInFlight) +void AppGraphCtxWaitForFramesD3D12(AppGraphCtx* contextIn, unsigned int maxFramesInFlight) { + auto context = cast_to_AppGraphCtxD3D12(contextIn); + unsigned int framesActive = maxFramesInFlight; while (framesActive >= maxFramesInFlight) { @@ -668,24 +680,28 @@ void AppGraphCtxWaitForFrames(AppGraphCtx* context, unsigned int maxFramesInFlig } } -void AppGraphCtxProfileEnable(AppGraphCtx* context, bool enabled) +void AppGraphCtxProfileEnableD3D12(AppGraphCtx* contextIn, bool enabled) { - appGraphProfilerEnable(context->m_profiler, enabled); + auto context = cast_to_AppGraphCtxD3D12(contextIn); + appGraphProfilerD3D12Enable(context->m_profiler, enabled); } -void AppGraphCtxProfileBegin(AppGraphCtx* context, const char* label) +void AppGraphCtxProfileBeginD3D12(AppGraphCtx* contextIn, const char* label) { - appGraphProfilerBegin(context->m_profiler, label); + auto context = cast_to_AppGraphCtxD3D12(contextIn); + appGraphProfilerD3D12Begin(context->m_profiler, label); } -void AppGraphCtxProfileEnd(AppGraphCtx* context, const char* label) +void AppGraphCtxProfileEndD3D12(AppGraphCtx* contextIn, const char* label) { - appGraphProfilerEnd(context->m_profiler, label); + auto context = cast_to_AppGraphCtxD3D12(contextIn); + appGraphProfilerD3D12End(context->m_profiler, label); } -bool AppGraphCtxProfileGet(AppGraphCtx* context, const char** plabel, float* cpuTime, float* gpuTime, int index) +bool AppGraphCtxProfileGetD3D12(AppGraphCtx* contextIn, const char** plabel, float* cpuTime, float* gpuTime, int index) { - return appGraphProfilerGet(context->m_profiler, plabel, cpuTime, gpuTime, index); + auto context = cast_to_AppGraphCtxD3D12(contextIn); + return appGraphProfilerD3D12Get(context->m_profiler, plabel, cpuTime, gpuTime, index); } // ******************************* Dynamic descriptor heap ****************************** @@ -889,9 +905,9 @@ namespace }; } -struct AppGraphProfiler +struct AppGraphProfilerD3D12 { - AppGraphCtx* m_context; + AppGraphCtxD3D12* m_context; int m_state = 0; bool m_enabled = false; @@ -906,29 +922,29 @@ struct AppGraphProfiler TimerValue m_timerValues[m_timersCap]; int m_timerValuesSize = 0; - AppGraphProfiler(AppGraphCtx* context); - ~AppGraphProfiler(); + AppGraphProfilerD3D12(AppGraphCtx* context); + ~AppGraphProfilerD3D12(); }; -AppGraphProfiler::AppGraphProfiler(AppGraphCtx* context) : m_context(context) +AppGraphProfilerD3D12::AppGraphProfilerD3D12(AppGraphCtx* context) : m_context(cast_to_AppGraphCtxD3D12(context)) { } -AppGraphProfiler::~AppGraphProfiler() +AppGraphProfilerD3D12::~AppGraphProfilerD3D12() { } -AppGraphProfiler* appGraphCreateProfiler(AppGraphCtx* ctx) +AppGraphProfilerD3D12* appGraphCreateProfilerD3D12(AppGraphCtx* ctx) { - return new AppGraphProfiler(ctx); + return new AppGraphProfilerD3D12(ctx); } -void appGraphReleaseProfiler(AppGraphProfiler* profiler) +void appGraphReleaseProfiler(AppGraphProfilerD3D12* profiler) { delete profiler; } -void appGraphProfilerFrameBegin(AppGraphProfiler* p) +void appGraphProfilerD3D12FrameBegin(AppGraphProfilerD3D12* p) { p->m_frameTime = (float)p->m_frameTimer.getDeltaTime(); @@ -940,7 +956,7 @@ void appGraphProfilerFrameBegin(AppGraphProfiler* p) } } -void appGraphProfilerFrameEnd(AppGraphProfiler* p) +void appGraphProfilerD3D12FrameEnd(AppGraphProfilerD3D12* p) { if (p->m_state == 1) { @@ -948,12 +964,12 @@ void appGraphProfilerFrameEnd(AppGraphProfiler* p) } } -void appGraphProfilerEnable(AppGraphProfiler* p, bool enabled) +void appGraphProfilerD3D12Enable(AppGraphProfilerD3D12* p, bool enabled) { p->m_enabled = enabled; } -void appGraphProfilerBegin(AppGraphProfiler* p, const char* label) +void appGraphProfilerD3D12Begin(AppGraphProfilerD3D12* p, const char* label) { if (p->m_state == 1 && p->m_timersSize < p->m_timersCap) { @@ -987,7 +1003,7 @@ void appGraphProfilerBegin(AppGraphProfiler* p, const char* label) } } -void appGraphProfilerEnd(AppGraphProfiler* p, const char* label) +void appGraphProfilerD3D12End(AppGraphProfilerD3D12* p, const char* label) { if (p->m_state == 1) { @@ -1013,7 +1029,7 @@ void appGraphProfilerEnd(AppGraphProfiler* p, const char* label) } } -bool appGraphProfilerFlush(AppGraphProfiler* p) +bool appGraphProfilerD3D12Flush(AppGraphProfilerD3D12* p) { if (p->m_state == 2) { @@ -1071,9 +1087,9 @@ bool appGraphProfilerFlush(AppGraphProfiler* p) return false; } -bool appGraphProfilerGet(AppGraphProfiler* p, const char** plabel, float* cpuTime, float* gpuTime, int index) +bool appGraphProfilerD3D12Get(AppGraphProfilerD3D12* p, const char** plabel, float* cpuTime, float* gpuTime, int index) { - appGraphProfilerFlush(p); + appGraphProfilerD3D12Flush(p); { if (index < p->m_timerValuesSize) { @@ -1091,7 +1107,8 @@ bool appGraphProfilerGet(AppGraphProfiler* p, const char** plabel, float* cpuTim return false; } -size_t AppGraphCtxDedicatedVideoMemory(AppGraphCtx* context) +size_t AppGraphCtxDedicatedVideoMemoryD3D12(AppGraphCtx* contextIn) { + auto context = cast_to_AppGraphCtxD3D12(contextIn); return context->m_dedicatedVideoMemory; }
\ No newline at end of file diff --git a/demo/DemoAppD3D12/appD3D12Ctx.h b/demo/DemoAppD3D12/appD3D12Ctx.h index f6d2ba3..a20e44a 100644 --- a/demo/DemoAppD3D12/appD3D12Ctx.h +++ b/demo/DemoAppD3D12/appD3D12Ctx.h @@ -15,7 +15,7 @@ struct IDXGISwapChain3; -struct AppGraphProfiler; +struct AppGraphProfilerD3D12; struct AppDescriptorReserveHandleD3D12 { @@ -41,7 +41,7 @@ struct AppDynamicDescriptorHeapD3D12 ~AppDynamicDescriptorHeapD3D12() { release(); } }; -struct AppGraphCtx +struct AppGraphCtxD3D12 { HWND m_hWnd = nullptr; @@ -104,10 +104,44 @@ struct AppGraphCtx AppDynamicDescriptorHeapD3D12 m_dynamicHeapCbvSrvUav; - AppGraphProfiler* m_profiler = nullptr; + AppGraphProfilerD3D12* m_profiler = nullptr; - AppGraphCtx(); - ~AppGraphCtx(); + AppGraphCtxD3D12(); + ~AppGraphCtxD3D12(); }; +inline AppGraphCtxD3D12* cast_to_AppGraphCtxD3D12(AppGraphCtx* appctx) +{ + return (AppGraphCtxD3D12*)(appctx); +} + +inline AppGraphCtx* cast_from_AppGraphCtxD3D12(AppGraphCtxD3D12* appctx) +{ + return (AppGraphCtx*)(appctx); +} + +APP_GRAPH_CTX_API AppGraphCtx* AppGraphCtxCreateD3D12(int deviceID); + +APP_GRAPH_CTX_API bool AppGraphCtxUpdateSizeD3D12(AppGraphCtx* context, SDL_Window* window, bool fullscreen); + +APP_GRAPH_CTX_API void AppGraphCtxReleaseRenderTargetD3D12(AppGraphCtx* context); + +APP_GRAPH_CTX_API void AppGraphCtxReleaseD3D12(AppGraphCtx* context); + +APP_GRAPH_CTX_API void AppGraphCtxFrameStartD3D12(AppGraphCtx* context, AppGraphColor clearColor); + +APP_GRAPH_CTX_API void AppGraphCtxFramePresentD3D12(AppGraphCtx* context, bool fullsync); + +APP_GRAPH_CTX_API void AppGraphCtxWaitForFramesD3D12(AppGraphCtx* context, unsigned int maxFramesInFlight); + +APP_GRAPH_CTX_API void AppGraphCtxProfileEnableD3D12(AppGraphCtx* context, bool enabled); + +APP_GRAPH_CTX_API void AppGraphCtxProfileBeginD3D12(AppGraphCtx* context, const char* label); + +APP_GRAPH_CTX_API void AppGraphCtxProfileEndD3D12(AppGraphCtx* context, const char* label); + +APP_GRAPH_CTX_API bool AppGraphCtxProfileGetD3D12(AppGraphCtx* context, const char** plabel, float* cpuTime, float* gpuTime, int index); + +APP_GRAPH_CTX_API size_t AppGraphCtxDedicatedVideoMemoryD3D12(AppGraphCtx* context); + #endif
\ No newline at end of file diff --git a/demo/DemoAppD3D12/computeContextD3D12.cpp b/demo/DemoAppD3D12/computeContextD3D12.cpp index f6cf26e..9e54325 100644 --- a/demo/DemoAppD3D12/computeContextD3D12.cpp +++ b/demo/DemoAppD3D12/computeContextD3D12.cpp @@ -250,9 +250,9 @@ struct ComputeContextUserData virtual void Release() = 0; }; -struct ComputeContext +struct ComputeContextD3D12 { - ComputeContextDesc m_desc = {}; + ComputeContextDescD3D12 m_desc = {}; ID3D12RootSignature* m_rootSignatureCompute = nullptr; ID3D12DescriptorHeap* m_nullHeap = nullptr; @@ -261,8 +261,10 @@ struct ComputeContext ComputeContextUserData* m_computeUserdata = nullptr; - ComputeContext(const ComputeContextDesc* desc) + ComputeContextD3D12(const ComputeContextDesc* descIn) { + auto desc = cast_to_ComputeContextDescD3D12(descIn); + m_desc = *desc; auto createRootSignature = [&](D3D12_ROOT_SIGNATURE_DESC* desc, ID3D12RootSignature** root) @@ -323,7 +325,7 @@ struct ComputeContext m_desc.device->CreateShaderResourceView(nullptr, &srvDesc, m_nullSRV); } } - ~ComputeContext() + ~ComputeContextD3D12() { COMRelease(m_rootSignatureCompute); COMRelease(m_nullHeap); @@ -331,20 +333,40 @@ struct ComputeContext } }; -struct ComputeShader +inline ComputeContextD3D12* cast_to_ComputeContextD3D12(ComputeContext* ctx) +{ + return (ComputeContextD3D12*)(ctx); +} + +inline ComputeContext* cast_from_ComputeContextD3D12(ComputeContextD3D12* ctx) +{ + return (ComputeContext*)(ctx); +} + +struct ComputeShaderD3D12 { ID3D12PipelineState* m_shader = nullptr; - ComputeShader(ID3D12PipelineState* shader) + ComputeShaderD3D12(ID3D12PipelineState* shader) { m_shader = shader; } - ~ComputeShader() + ~ComputeShaderD3D12() { COMRelease(m_shader); } }; -struct ComputeConstantBuffer +inline ComputeShaderD3D12* cast_to_ComputeShaderD3D12(ComputeShader* ctx) +{ + return (ComputeShaderD3D12*)(ctx); +} + +inline ComputeShader* cast_from_ComputeShaderD3D12(ComputeShaderD3D12* ctx) +{ + return (ComputeShader*)(ctx); +} + +struct ComputeConstantBufferD3D12 { ComputeConstantBufferDesc m_desc = {}; @@ -357,38 +379,54 @@ struct ComputeConstantBuffer }; VersionedBuffer<BufferData> m_buffers; - ComputeConstantBuffer(ComputeContext* context, const ComputeConstantBufferDesc* desc) - { - m_desc = *desc; + ComputeConstantBufferD3D12(ComputeContext* context, const ComputeConstantBufferDesc* desc); + ~ComputeConstantBufferD3D12(); +}; - // map and unmap to trigger initial allocation - ComputeConstantBufferMap(context, this); - ComputeConstantBufferUnmap(context, this); - } - ~ComputeConstantBuffer() +inline ComputeConstantBufferD3D12* cast_to_ComputeConstantBufferD3D12(ComputeConstantBuffer* ctx) +{ + return (ComputeConstantBufferD3D12*)(ctx); +} + +inline ComputeConstantBuffer* cast_from_ComputeConstantBufferD3D12(ComputeConstantBufferD3D12* ctx) +{ + return (ComputeConstantBuffer*)(ctx); +} + +ComputeConstantBufferD3D12::ComputeConstantBufferD3D12(ComputeContext* context, const ComputeConstantBufferDesc* desc) +{ + m_desc = *desc; + + // map and unmap to trigger initial allocation + ComputeConstantBufferMapD3D12(context, cast_from_ComputeConstantBufferD3D12(this)); + ComputeConstantBufferUnmapD3D12(context, cast_from_ComputeConstantBufferD3D12(this)); +} + +ComputeConstantBufferD3D12::~ComputeConstantBufferD3D12() +{ + for (ComputeUint i = 0; i < m_buffers.m_buffers.m_size; i++) { - for (ComputeUint i = 0; i < m_buffers.m_buffers.m_size; i++) - { - COMRelease(m_buffers.m_buffers[i].bufferData.m_buffer); - } + COMRelease(m_buffers.m_buffers[i].bufferData.m_buffer); } -}; +} -struct ComputeResource +struct ComputeResourceD3D12 { protected: D3D12_CPU_DESCRIPTOR_HANDLE m_srv; ID3D12Resource* m_resource; D3D12_RESOURCE_STATES* m_currentState; public: - void update(const ComputeResourceDesc* desc) + void update(const ComputeResourceDesc* descIn) { + auto desc = cast_to_ComputeResourceDescD3D12(descIn); + m_srv = desc->srv; m_resource = desc->resource; m_currentState = desc->currentState; } - ComputeResource(const ComputeResourceDesc* desc) + ComputeResourceD3D12(const ComputeResourceDesc* desc) { update(desc); } @@ -409,21 +447,36 @@ public: } }; -struct ComputeResourceRW : public ComputeResource +inline ComputeResourceD3D12* cast_to_ComputeResourceD3D12(ComputeResource* ctx) +{ + return (ComputeResourceD3D12*)(ctx); +} + +inline ComputeResource* cast_from_ComputeResourceD3D12(ComputeResourceD3D12* ctx) +{ + return (ComputeResource*)(ctx); +} + +struct ComputeResourceRWD3D12 : public ComputeResourceD3D12 { protected: D3D12_CPU_DESCRIPTOR_HANDLE m_uav; public: + static const ComputeResourceRWDescD3D12* cast(const ComputeResourceRWDesc* descRW) + { + return cast_to_ComputeResourceRWDescD3D12(descRW); + } + void update(const ComputeResourceRWDesc* descRW) { - m_uav = descRW->uav; - ComputeResource::update(&descRW->resource); + m_uav = cast(descRW)->uav; + ComputeResourceD3D12::update(cast_from_ComputeResourceDescD3D12(&cast(descRW)->resource)); } - ComputeResourceRW(const ComputeResourceRWDesc* descRW) : - ComputeResource(&descRW->resource) + ComputeResourceRWD3D12(const ComputeResourceRWDesc* descRW) : + ComputeResourceD3D12(cast_from_ComputeResourceDescD3D12(&cast(descRW)->resource)) { - m_uav = descRW->uav; + m_uav = cast(descRW)->uav; } D3D12_CPU_DESCRIPTOR_HANDLE UAV() @@ -432,25 +485,41 @@ public: } }; +inline ComputeResourceRWD3D12* cast_to_ComputeResourceRWD3D12(ComputeResourceRW* ctx) +{ + return (ComputeResourceRWD3D12*)(ctx); +} + +inline ComputeResourceRW* cast_from_ComputeResourceRWD3D12(ComputeResourceRWD3D12* ctx) +{ + return (ComputeResourceRW*)(ctx); +} + + // ************* API functions **************** -ComputeContext* ComputeContextCreate(ComputeContextDesc* desc) +ComputeContext* ComputeContextCreateD3D12(ComputeContextDesc* desc) { - return new ComputeContext(desc); + return cast_from_ComputeContextD3D12(new ComputeContextD3D12(desc)); } -void ComputeContextUpdate(ComputeContext* context, ComputeContextDesc* desc) +void ComputeContextUpdateD3D12(ComputeContext* contextIn, ComputeContextDesc* descIn) { + auto context = cast_to_ComputeContextD3D12(contextIn); + auto desc = cast_to_ComputeContextDescD3D12(descIn); + context->m_desc = *desc; } -void ComputeContextRelease(ComputeContext* context) +void ComputeContextReleaseD3D12(ComputeContext* context) { - delete context; + delete cast_to_ComputeContextD3D12(context); } -ComputeShader* ComputeShaderCreate(ComputeContext* context, const ComputeShaderDesc* desc) +ComputeShader* ComputeShaderCreateD3D12(ComputeContext* contextIn, const ComputeShaderDesc* desc) { + auto context = cast_to_ComputeContextD3D12(contextIn); + ID3D12PipelineState* computeShader = nullptr; D3D12_COMPUTE_PIPELINE_STATE_DESC psoDesc = {}; @@ -460,26 +529,29 @@ ComputeShader* ComputeShaderCreate(ComputeContext* context, const ComputeShaderD context->m_desc.device->CreateComputePipelineState(&psoDesc, IID_PPV_ARGS(&computeShader)); - return new ComputeShader(computeShader); + return cast_from_ComputeShaderD3D12(new ComputeShaderD3D12(computeShader)); } -void ComputeShaderRelease(ComputeShader* shader) +void ComputeShaderReleaseD3D12(ComputeShader* shader) { - delete shader; + delete cast_to_ComputeShaderD3D12(shader); } -ComputeConstantBuffer* ComputeConstantBufferCreate(ComputeContext* context, const ComputeConstantBufferDesc* desc) +ComputeConstantBuffer* ComputeConstantBufferCreateD3D12(ComputeContext* context, const ComputeConstantBufferDesc* desc) { - return new ComputeConstantBuffer(context, desc); + return cast_from_ComputeConstantBufferD3D12(new ComputeConstantBufferD3D12(context, desc)); } -void ComputeConstantBufferRelease(ComputeConstantBuffer* constantBuffer) +void ComputeConstantBufferReleaseD3D12(ComputeConstantBuffer* constantBuffer) { - delete constantBuffer; + delete cast_to_ComputeConstantBufferD3D12(constantBuffer); } -void* ComputeConstantBufferMap(ComputeContext* context, ComputeConstantBuffer* constantBuffer) +void* ComputeConstantBufferMapD3D12(ComputeContext* contextIn, ComputeConstantBuffer* constantBufferIn) { + auto context = cast_to_ComputeContextD3D12(contextIn); + auto constantBuffer = cast_to_ComputeConstantBufferD3D12(constantBufferIn); + auto bufferData = constantBuffer->m_buffers.map(context->m_desc.lastFenceCompleted, context->m_desc.nextFenceValue); if (bufferData->m_buffer == nullptr) @@ -500,52 +572,60 @@ void* ComputeConstantBufferMap(ComputeContext* context, ComputeConstantBuffer* c return bufferData->m_mappedData; } -void ComputeConstantBufferUnmap(ComputeContext* context, ComputeConstantBuffer* constantBuffer) +void ComputeConstantBufferUnmapD3D12(ComputeContext* contextIn, ComputeConstantBuffer* constantBufferIn) { + auto context = cast_to_ComputeContextD3D12(contextIn); + auto constantBuffer = cast_to_ComputeConstantBufferD3D12(constantBufferIn); + constantBuffer->m_buffers.unmap(context->m_desc.lastFenceCompleted, context->m_desc.nextFenceValue); } -ComputeResource* ComputeResourceCreate(ComputeContext* context, const ComputeResourceDesc* desc) +ComputeResource* ComputeResourceCreateD3D12(ComputeContext* context, const ComputeResourceDesc* desc) { - return new ComputeResource(desc); + return cast_from_ComputeResourceD3D12(new ComputeResourceD3D12(desc)); } -void ComputeResourceUpdate(ComputeContext* context, ComputeResource* resource, const ComputeResourceDesc* desc) +void ComputeResourceUpdateD3D12(ComputeContext* context, ComputeResource* resourceIn, const ComputeResourceDesc* desc) { + auto resource = cast_to_ComputeResourceD3D12(resourceIn); resource->update(desc); } -void ComputeResourceRelease(ComputeResource* resource) +void ComputeResourceReleaseD3D12(ComputeResource* resource) { - delete resource; + delete cast_to_ComputeResourceD3D12(resource); } -ComputeResourceRW* ComputeResourceRWCreate(ComputeContext* context, const ComputeResourceRWDesc* desc) +ComputeResourceRW* ComputeResourceRWCreateD3D12(ComputeContext* context, const ComputeResourceRWDesc* desc) { - return new ComputeResourceRW(desc); + return cast_from_ComputeResourceRWD3D12(new ComputeResourceRWD3D12(desc)); } -void ComputeResourceRWUpdate(ComputeContext* context, ComputeResourceRW* resourceRW, const ComputeResourceRWDesc* desc) +void ComputeResourceRWUpdateD3D12(ComputeContext* context, ComputeResourceRW* resourceRWIn, const ComputeResourceRWDesc* desc) { + auto resourceRW = cast_to_ComputeResourceRWD3D12(resourceRWIn); resourceRW->update(desc); } -void ComputeResourceRWRelease(ComputeResourceRW* resourceRW) +void ComputeResourceRWReleaseD3D12(ComputeResourceRW* resourceRW) { - delete resourceRW; + delete cast_to_ComputeResourceRWD3D12(resourceRW); } -ComputeResource* ComputeResourceRWGetResource(ComputeResourceRW* resourceRW) +ComputeResource* ComputeResourceRWGetResourceD3D12(ComputeResourceRW* resourceRWIn) { - return static_cast<ComputeResource*>(resourceRW); + auto resourceRW = cast_to_ComputeResourceRWD3D12(resourceRWIn); + return cast_from_ComputeResourceD3D12(static_cast<ComputeResourceD3D12*>(resourceRW)); } -void ComputeContextDispatch(ComputeContext* context, const ComputeDispatchParams* params) +void ComputeContextDispatchD3D12(ComputeContext* contextIn, const ComputeDispatchParams* params) { + auto context = cast_to_ComputeContextD3D12(contextIn); + auto& commandList = context->m_desc.commandList; commandList->SetComputeRootSignature(context->m_rootSignatureCompute); - if (params->shader) commandList->SetPipelineState(params->shader->m_shader); + if (params->shader) commandList->SetPipelineState(cast_to_ComputeShaderD3D12(params->shader)->m_shader); auto handles = context->m_desc.dynamicHeapCbvSrvUav.reserveDescriptors(context->m_desc.dynamicHeapCbvSrvUav.userdata, ComputeDispatchMaxResources + ComputeDispatchMaxResourcesRW, @@ -557,14 +637,14 @@ void ComputeContextDispatch(ComputeContext* context, const ComputeDispatchParams for (ComputeUint i = 0u; i < ComputeDispatchMaxResources; i++) { auto r = params->resources[i]; - D3D12_CPU_DESCRIPTOR_HANDLE srcHandle = r ? r->SRV() : context->m_nullSRV; + D3D12_CPU_DESCRIPTOR_HANDLE srcHandle = r ? cast_to_ComputeResourceD3D12(r)->SRV() : context->m_nullSRV; context->m_desc.device->CopyDescriptorsSimple(1u, handles.cpuHandle, srcHandle, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); handles.cpuHandle.ptr += handles.descriptorSize; } for (ComputeUint i = 0u; i < ComputeDispatchMaxResourcesRW; i++) { auto rw = params->resourcesRW[i]; - D3D12_CPU_DESCRIPTOR_HANDLE srcHandle = rw ? rw->UAV() : context->m_nullUAV; + D3D12_CPU_DESCRIPTOR_HANDLE srcHandle = rw ? cast_to_ComputeResourceRWD3D12(rw)->UAV() : context->m_nullUAV; context->m_desc.device->CopyDescriptorsSimple(1u, handles.cpuHandle, srcHandle, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); handles.cpuHandle.ptr += handles.descriptorSize; } @@ -575,7 +655,7 @@ void ComputeContextDispatch(ComputeContext* context, const ComputeDispatchParams if (params->constantBuffer) { - auto cbv = params->constantBuffer->m_buffers.front()->m_buffer; + auto cbv = cast_to_ComputeConstantBufferD3D12(params->constantBuffer)->m_buffers.front()->m_buffer; commandList->SetComputeRootConstantBufferView(0u, cbv->GetGPUVirtualAddress()); } @@ -586,17 +666,17 @@ void ComputeContextDispatch(ComputeContext* context, const ComputeDispatchParams auto r = params->resources[i]; if (r) { - if (!((*r->currentState()) & D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE)) + if (!((*cast_to_ComputeResourceD3D12(r)->currentState()) & D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE)) { D3D12_RESOURCE_BARRIER& bar = barrier[barrierIdx++]; bar.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION; bar.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE; - bar.Transition.pResource = r->resource(); + bar.Transition.pResource = cast_to_ComputeResourceD3D12(r)->resource(); bar.Transition.Subresource = 0u; - bar.Transition.StateBefore = *r->currentState(); + bar.Transition.StateBefore = *cast_to_ComputeResourceD3D12(r)->currentState(); bar.Transition.StateAfter = D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE; - *r->currentState() = D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE; + *cast_to_ComputeResourceD3D12(r)->currentState() = D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE; } } } @@ -605,24 +685,24 @@ void ComputeContextDispatch(ComputeContext* context, const ComputeDispatchParams auto rw = params->resourcesRW[i]; if (rw) { - if ((*rw->currentState()) == D3D12_RESOURCE_STATE_UNORDERED_ACCESS) + if ((*cast_to_ComputeResourceRWD3D12(rw)->currentState()) == D3D12_RESOURCE_STATE_UNORDERED_ACCESS) { D3D12_RESOURCE_BARRIER& bar = barrier[barrierIdx++]; bar.Type = D3D12_RESOURCE_BARRIER_TYPE_UAV; bar.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE; - bar.UAV.pResource = rw->resource(); + bar.UAV.pResource = cast_to_ComputeResourceRWD3D12(rw)->resource(); } else { D3D12_RESOURCE_BARRIER& bar = barrier[barrierIdx++]; bar.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION; bar.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE; - bar.Transition.pResource = rw->resource(); + bar.Transition.pResource = cast_to_ComputeResourceRWD3D12(rw)->resource(); bar.Transition.Subresource = 0u; - bar.Transition.StateBefore = *rw->currentState(); + bar.Transition.StateBefore = *cast_to_ComputeResourceRWD3D12(rw)->currentState(); bar.Transition.StateAfter = D3D12_RESOURCE_STATE_UNORDERED_ACCESS; - *rw->currentState() = D3D12_RESOURCE_STATE_UNORDERED_ACCESS; + *cast_to_ComputeResourceRWD3D12(rw)->currentState() = D3D12_RESOURCE_STATE_UNORDERED_ACCESS; } } } @@ -647,7 +727,7 @@ struct ComputeContextUserDataNvFlow : public ComputeContextUserData } }; -ComputeDescriptorReserveHandleD3D12 ComputeReserveDescriptors(void* userdata, UINT numDescriptors, UINT64 lastFenceCompleted, UINT64 nextFenceValue) +ComputeDescriptorReserveHandleD3D12 ComputeReserveDescriptorsD3D12(void* userdata, UINT numDescriptors, UINT64 lastFenceCompleted, UINT64 nextFenceValue) { auto data = static_cast<ComputeContextUserDataNvFlow*>(userdata); auto srcHandle = data->flowHeap.reserveDescriptors(data->flowHeap.userdata, numDescriptors, lastFenceCompleted, nextFenceValue); @@ -659,9 +739,9 @@ ComputeDescriptorReserveHandleD3D12 ComputeReserveDescriptors(void* userdata, UI return handle; } -ComputeContext* ComputeContextNvFlowContextCreate(NvFlowContext* flowContext) +ComputeContext* ComputeContextNvFlowContextCreateD3D12(NvFlowContext* flowContext) { - ComputeContextDesc desc = {}; + ComputeContextDescD3D12 desc = {}; NvFlowContextDescD3D12 srcDesc = {}; NvFlowUpdateContextDescD3D12(flowContext, &srcDesc); @@ -677,18 +757,20 @@ ComputeContext* ComputeContextNvFlowContextCreate(NvFlowContext* flowContext) computeUserdata->flowHeap.reserveDescriptors = srcDesc.dynamicHeapCbvSrvUav.reserveDescriptors; desc.dynamicHeapCbvSrvUav.userdata = computeUserdata; - desc.dynamicHeapCbvSrvUav.reserveDescriptors = ComputeReserveDescriptors; + desc.dynamicHeapCbvSrvUav.reserveDescriptors = ComputeReserveDescriptorsD3D12; - auto computeContext = ComputeContextCreate(&desc); + auto computeContext = cast_to_ComputeContextD3D12(ComputeContextCreateD3D12(cast_from_ComputeContextDescD3D12(&desc))); computeContext->m_computeUserdata = computeUserdata; - return computeContext; + return cast_from_ComputeContextD3D12(computeContext); } -void ComputeContextNvFlowContextUpdate(ComputeContext* computeContext, NvFlowContext* flowContext) +void ComputeContextNvFlowContextUpdateD3D12(ComputeContext* computeContextIn, NvFlowContext* flowContext) { - ComputeContextDesc desc = {}; + auto computeContext = cast_to_ComputeContextD3D12(computeContextIn); + + ComputeContextDescD3D12 desc = {}; NvFlowContextDescD3D12 srcDesc = {}; NvFlowUpdateContextDescD3D12(flowContext, &srcDesc); @@ -704,56 +786,56 @@ void ComputeContextNvFlowContextUpdate(ComputeContext* computeContext, NvFlowCon computeUserdata->flowHeap.reserveDescriptors = srcDesc.dynamicHeapCbvSrvUav.reserveDescriptors; desc.dynamicHeapCbvSrvUav.userdata = computeUserdata; - desc.dynamicHeapCbvSrvUav.reserveDescriptors = ComputeReserveDescriptors; + desc.dynamicHeapCbvSrvUav.reserveDescriptors = ComputeReserveDescriptorsD3D12; - ComputeContextUpdate(computeContext, &desc); + ComputeContextUpdateD3D12(cast_from_ComputeContextD3D12(computeContext), cast_from_ComputeContextDescD3D12(&desc)); } -inline void updateComputeResourceDesc(NvFlowResourceViewDescD3D12* flowViewDesc, ComputeResourceDesc* desc) +inline void updateComputeResourceDesc(NvFlowResourceViewDescD3D12* flowViewDesc, ComputeResourceDescD3D12* desc) { desc->srv = flowViewDesc->srvHandle; desc->resource = flowViewDesc->resource; desc->currentState = flowViewDesc->currentState; } -ComputeResource* ComputeResourceNvFlowCreate(ComputeContext* context, NvFlowContext* flowContext, NvFlowResource* flowResource) +ComputeResource* ComputeResourceNvFlowCreateD3D12(ComputeContext* context, NvFlowContext* flowContext, NvFlowResource* flowResource) { NvFlowResourceViewDescD3D12 flowViewDesc = {}; NvFlowUpdateResourceViewDescD3D12(flowContext, flowResource, &flowViewDesc); - ComputeResourceDesc desc = {}; + ComputeResourceDescD3D12 desc = {}; updateComputeResourceDesc(&flowViewDesc, &desc); - return ComputeResourceCreate(context, &desc); + return ComputeResourceCreateD3D12(context, cast_from_ComputeResourceDescD3D12(&desc)); } -void ComputeResourceNvFlowUpdate(ComputeContext* context, ComputeResource* resource, NvFlowContext* flowContext, NvFlowResource* flowResource) +void ComputeResourceNvFlowUpdateD3D12(ComputeContext* context, ComputeResource* resource, NvFlowContext* flowContext, NvFlowResource* flowResource) { NvFlowResourceViewDescD3D12 flowViewDesc = {}; NvFlowUpdateResourceViewDescD3D12(flowContext, flowResource, &flowViewDesc); - ComputeResourceDesc desc = {}; + ComputeResourceDescD3D12 desc = {}; updateComputeResourceDesc(&flowViewDesc, &desc); - ComputeResourceUpdate(context, resource, &desc); + ComputeResourceUpdateD3D12(context, resource, cast_from_ComputeResourceDescD3D12(&desc)); } -inline void updateComputeResourceRWDesc(NvFlowResourceRWViewDescD3D12* flowViewDesc, ComputeResourceRWDesc* desc) +inline void updateComputeResourceRWDesc(NvFlowResourceRWViewDescD3D12* flowViewDesc, ComputeResourceRWDescD3D12* desc) { updateComputeResourceDesc(&flowViewDesc->resourceView, &desc->resource); desc->uav = flowViewDesc->uavHandle; } -ComputeResourceRW* ComputeResourceRWNvFlowCreate(ComputeContext* context, NvFlowContext* flowContext, NvFlowResourceRW* flowResourceRW) +ComputeResourceRW* ComputeResourceRWNvFlowCreateD3D12(ComputeContext* context, NvFlowContext* flowContext, NvFlowResourceRW* flowResourceRW) { NvFlowResourceRWViewDescD3D12 flowViewDesc = {}; NvFlowUpdateResourceRWViewDescD3D12(flowContext, flowResourceRW, &flowViewDesc); - ComputeResourceRWDesc desc = {}; + ComputeResourceRWDescD3D12 desc = {}; updateComputeResourceRWDesc(&flowViewDesc, &desc); - return ComputeResourceRWCreate(context, &desc); + return ComputeResourceRWCreateD3D12(context, cast_from_ComputeResourceRWDescD3D12(&desc)); } -void ComputeResourceRWNvFlowUpdate(ComputeContext* context, ComputeResourceRW* resourceRW, NvFlowContext* flowContext, NvFlowResourceRW* flowResourceRW) +void ComputeResourceRWNvFlowUpdateD3D12(ComputeContext* context, ComputeResourceRW* resourceRW, NvFlowContext* flowContext, NvFlowResourceRW* flowResourceRW) { NvFlowResourceRWViewDescD3D12 flowViewDesc = {}; NvFlowUpdateResourceRWViewDescD3D12(flowContext, flowResourceRW, &flowViewDesc); - ComputeResourceRWDesc desc = {}; + ComputeResourceRWDescD3D12 desc = {}; updateComputeResourceRWDesc(&flowViewDesc, &desc); - ComputeResourceRWUpdate(context, resourceRW, &desc); + ComputeResourceRWUpdateD3D12(context, resourceRW, cast_from_ComputeResourceRWDescD3D12(&desc)); }
\ No newline at end of file diff --git a/demo/DemoAppD3D12/computeContextD3D12.h b/demo/DemoAppD3D12/computeContextD3D12.h index 0acb489..835e7d7 100644 --- a/demo/DemoAppD3D12/computeContextD3D12.h +++ b/demo/DemoAppD3D12/computeContextD3D12.h @@ -26,7 +26,7 @@ struct ComputeDynamicDescriptorHeapD3D12 ComputeDescriptorReserveHandleD3D12(*reserveDescriptors)(void* userdata, UINT numDescriptors, UINT64 lastFenceCompleted, UINT64 nextFenceValue); }; -struct ComputeContextDesc +struct ComputeContextDescD3D12 { ID3D12Device* device; ID3D12CommandQueue* commandQueue; @@ -38,15 +38,91 @@ struct ComputeContextDesc ComputeDynamicDescriptorHeapD3D12 dynamicHeapCbvSrvUav; }; -struct ComputeResourceDesc +struct ComputeResourceDescD3D12 { D3D12_CPU_DESCRIPTOR_HANDLE srv; ID3D12Resource* resource; D3D12_RESOURCE_STATES* currentState; }; -struct ComputeResourceRWDesc +struct ComputeResourceRWDescD3D12 { - ComputeResourceDesc resource; + ComputeResourceDescD3D12 resource; D3D12_CPU_DESCRIPTOR_HANDLE uav; -};
\ No newline at end of file +}; + +inline const ComputeContextDescD3D12* cast_to_ComputeContextDescD3D12(const ComputeContextDesc* desc) +{ + return (const ComputeContextDescD3D12*)(desc); +} + +inline ComputeContextDesc* cast_from_ComputeContextDescD3D12(ComputeContextDescD3D12* desc) +{ + return (ComputeContextDesc*)(desc); +} + +inline const ComputeResourceDescD3D12* cast_to_ComputeResourceDescD3D12(const ComputeResourceDesc* desc) +{ + return (const ComputeResourceDescD3D12*)(desc); +} + +inline const ComputeResourceDesc* cast_from_ComputeResourceDescD3D12(const ComputeResourceDescD3D12* desc) +{ + return (const ComputeResourceDesc*)(desc); +} + +inline const ComputeResourceRWDescD3D12* cast_to_ComputeResourceRWDescD3D12(const ComputeResourceRWDesc* desc) +{ + return (const ComputeResourceRWDescD3D12*)(desc); +} + +inline const ComputeResourceRWDesc* cast_from_ComputeResourceRWDescD3D12(const ComputeResourceRWDescD3D12* desc) +{ + return (const ComputeResourceRWDesc*)(desc); +} + +COMPUTE_API ComputeContext* ComputeContextCreateD3D12(ComputeContextDesc* desc); + +COMPUTE_API void ComputeContextUpdateD3D12(ComputeContext* context, ComputeContextDesc* desc); + +COMPUTE_API void ComputeContextReleaseD3D12(ComputeContext* context); + +COMPUTE_API ComputeShader* ComputeShaderCreateD3D12(ComputeContext* context, const ComputeShaderDesc* desc); + +COMPUTE_API void ComputeShaderReleaseD3D12(ComputeShader* shader); + +COMPUTE_API ComputeConstantBuffer* ComputeConstantBufferCreateD3D12(ComputeContext* context, const ComputeConstantBufferDesc* desc); + +COMPUTE_API void ComputeConstantBufferReleaseD3D12(ComputeConstantBuffer* constantBuffer); + +COMPUTE_API void* ComputeConstantBufferMapD3D12(ComputeContext* context, ComputeConstantBuffer* constantBuffer); + +COMPUTE_API void ComputeConstantBufferUnmapD3D12(ComputeContext* context, ComputeConstantBuffer* constantBuffer); + +COMPUTE_API ComputeResource* ComputeResourceCreateD3D12(ComputeContext* context, const ComputeResourceDesc* desc); + +COMPUTE_API void ComputeResourceUpdateD3D12(ComputeContext* context, ComputeResource* resource, const ComputeResourceDesc* desc); + +COMPUTE_API void ComputeResourceReleaseD3D12(ComputeResource* resource); + +COMPUTE_API ComputeResourceRW* ComputeResourceRWCreateD3D12(ComputeContext* context, const ComputeResourceRWDesc* desc); + +COMPUTE_API void ComputeResourceRWUpdateD3D12(ComputeContext* context, ComputeResourceRW* resourceRW, const ComputeResourceRWDesc* desc); + +COMPUTE_API void ComputeResourceRWReleaseD3D12(ComputeResourceRW* resourceRW); + +COMPUTE_API ComputeResource* ComputeResourceRWGetResourceD3D12(ComputeResourceRW* resourceRW); + +COMPUTE_API void ComputeContextDispatchD3D12(ComputeContext* context, const ComputeDispatchParams* params); + +COMPUTE_API ComputeContext* ComputeContextNvFlowContextCreateD3D12(NvFlowContext* flowContext); + +COMPUTE_API void ComputeContextNvFlowContextUpdateD3D12(ComputeContext* computeContext, NvFlowContext* flowContext); + +COMPUTE_API ComputeResource* ComputeResourceNvFlowCreateD3D12(ComputeContext* context, NvFlowContext* flowContext, NvFlowResource* flowResource); + +COMPUTE_API void ComputeResourceNvFlowUpdateD3D12(ComputeContext* context, ComputeResource* resource, NvFlowContext* flowContext, NvFlowResource* flowResource); + +COMPUTE_API ComputeResourceRW* ComputeResourceRWNvFlowCreateD3D12(ComputeContext* context, NvFlowContext* flowContext, NvFlowResourceRW* flowResourceRW); + +COMPUTE_API void ComputeResourceRWNvFlowUpdateD3D12(ComputeContext* context, ComputeResourceRW* resourceRW, NvFlowContext* flowContext, NvFlowResourceRW* flowResourceRW);
\ No newline at end of file diff --git a/demo/DemoAppD3D12/imguiGraphD3D12.cpp b/demo/DemoAppD3D12/imguiGraphD3D12.cpp index 9b5f74a..92cbab1 100644 --- a/demo/DemoAppD3D12/imguiGraphD3D12.cpp +++ b/demo/DemoAppD3D12/imguiGraphD3D12.cpp @@ -28,7 +28,7 @@ namespace namespace { - ImguiGraphDesc m_desc = {}; + ImguiGraphDescD3D12 m_desc = {}; struct Vertex { @@ -75,8 +75,10 @@ namespace int frameIndex = 0; } -void imguiGraphContextInit(const ImguiGraphDesc* desc) +void imguiGraphContextInitD3D12(const ImguiGraphDesc* descIn) { + const auto desc = cast_to_imguiGraphDescD3D12(descIn); + m_desc = *desc; // create the root signature @@ -308,12 +310,14 @@ void imguiGraphContextInit(const ImguiGraphDesc* desc) } } -void imguiGraphContextUpdate(const ImguiGraphDesc* desc) +void imguiGraphContextUpdateD3D12(const ImguiGraphDesc* descIn) { + const auto desc = cast_to_imguiGraphDescD3D12(descIn); + m_desc = *desc; } -void imguiGraphContextDestroy() +void imguiGraphContextDestroyD3D12() { COMRelease(m_rootSignature); COMRelease(m_pipelineState); @@ -321,7 +325,7 @@ void imguiGraphContextDestroy() COMRelease(m_vertexBuffer); } -void imguiGraphRecordBegin() +void imguiGraphRecordBeginD3D12() { frameIndex = (frameIndex + 1) % frameCount; @@ -406,7 +410,7 @@ static void imguiGraphFlush() } } -void imguiGraphRecordEnd() +void imguiGraphRecordEndD3D12() { ID3D12GraphicsCommandList* commandList = m_desc.commandList; @@ -424,7 +428,7 @@ void imguiGraphRecordEnd() commandList->RSSetScissorRects(1, &rect); } -void imguiGraphEnableScissor(int x, int y, int width, int height) +void imguiGraphEnableScissorD3D12(int x, int y, int width, int height) { // mark end of last region m_stateScissor.stopIdx = m_stateVertIdx; @@ -439,7 +443,7 @@ void imguiGraphEnableScissor(int x, int y, int width, int height) m_stateScissor.height = height; } -void imguiGraphDisableScissor() +void imguiGraphDisableScissorD3D12() { if (m_stateVertIdx == 0) return; @@ -456,13 +460,13 @@ void imguiGraphDisableScissor() m_stateScissor.height = m_desc.winH; } -void imguiGraphVertex2f(float x, float y) +void imguiGraphVertex2fD3D12(float x, float y) { float v[2] = { x,y }; - imguiGraphVertex2fv(v); + imguiGraphVertex2fvD3D12(v); } -void imguiGraphVertex2fv(const float* v) +void imguiGraphVertex2fvD3D12(const float* v) { // update state m_stateVert.x = v[0]; @@ -477,13 +481,13 @@ void imguiGraphVertex2fv(const float* v) } } -void imguiGraphTexCoord2f(float u, float v) +void imguiGraphTexCoord2fD3D12(float u, float v) { m_stateVert.u = u; m_stateVert.v = v; } -void imguiGraphColor4ub(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha) +void imguiGraphColor4ubD3D12(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha) { m_stateVert.rgba[0] = red; m_stateVert.rgba[1] = green; @@ -491,7 +495,7 @@ void imguiGraphColor4ub(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha) m_stateVert.rgba[3] = alpha; } -void imguiGraphColor4ubv(const uint8_t* v) +void imguiGraphColor4ubvD3D12(const uint8_t* v) { m_stateVert.rgba[0] = v[0]; m_stateVert.rgba[1] = v[1]; @@ -499,18 +503,18 @@ void imguiGraphColor4ubv(const uint8_t* v) m_stateVert.rgba[3] = v[3]; } -void imguiGraphFontTextureEnable() +void imguiGraphFontTextureEnableD3D12() { } -void imguiGraphFontTextureDisable() +void imguiGraphFontTextureDisableD3D12() { m_stateVert.u = -1.f; m_stateVert.v = -1.f; } -void imguiGraphFontTextureInit(unsigned char* data) +void imguiGraphFontTextureInitD3D12(unsigned char* data) { ID3D12GraphicsCommandList* commandList = m_desc.commandList; @@ -653,7 +657,7 @@ void imguiGraphFontTextureInit(unsigned char* data) } -void imguiGraphFontTextureRelease() +void imguiGraphFontTextureReleaseD3D12() { COMRelease(m_texture); COMRelease(m_textureUploadHeap); diff --git a/demo/DemoAppD3D12/imguiGraphD3D12.h b/demo/DemoAppD3D12/imguiGraphD3D12.h index 7eeb538..d011188 100644 --- a/demo/DemoAppD3D12/imguiGraphD3D12.h +++ b/demo/DemoAppD3D12/imguiGraphD3D12.h @@ -29,7 +29,7 @@ struct ImguiDynamicDescriptorHeapD3D12 ImguiDescriptorReserveHandleD3D12(*reserveDescriptors)(void* userdata, UINT numDescriptors, UINT64 lastFenceCompleted, UINT64 nextFenceValue); }; -struct ImguiGraphDesc +struct ImguiGraphDescD3D12 { ID3D12Device* device = nullptr; ID3D12GraphicsCommandList* commandList = nullptr; @@ -42,7 +42,49 @@ struct ImguiGraphDesc ImguiDynamicDescriptorHeapD3D12 dynamicHeapCbvSrvUav = {}; - ImguiGraphDesc() {} + ImguiGraphDescD3D12() {} }; +inline const ImguiGraphDescD3D12* cast_to_imguiGraphDescD3D12(const ImguiGraphDesc* desc) +{ + return (const ImguiGraphDescD3D12*)(desc); +} + +inline ImguiGraphDesc* cast_from_imguiGraphDescD3D12(ImguiGraphDescD3D12* desc) +{ + return (ImguiGraphDesc*)(desc); +} + +IMGUI_GRAPH_API void imguiGraphContextInitD3D12(const ImguiGraphDesc* desc); + +IMGUI_GRAPH_API void imguiGraphContextUpdateD3D12(const ImguiGraphDesc* desc); + +IMGUI_GRAPH_API void imguiGraphContextDestroyD3D12(); + +IMGUI_GRAPH_API void imguiGraphRecordBeginD3D12(); + +IMGUI_GRAPH_API void imguiGraphRecordEndD3D12(); + +IMGUI_GRAPH_API void imguiGraphVertex2fD3D12(float x, float y); + +IMGUI_GRAPH_API void imguiGraphVertex2fvD3D12(const float* v); + +IMGUI_GRAPH_API void imguiGraphTexCoord2fD3D12(float u, float v); + +IMGUI_GRAPH_API void imguiGraphColor4ubD3D12(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha); + +IMGUI_GRAPH_API void imguiGraphColor4ubvD3D12(const uint8_t* v); + +IMGUI_GRAPH_API void imguiGraphFontTextureEnableD3D12(); + +IMGUI_GRAPH_API void imguiGraphFontTextureDisableD3D12(); + +IMGUI_GRAPH_API void imguiGraphEnableScissorD3D12(int x, int y, int width, int height); + +IMGUI_GRAPH_API void imguiGraphDisableScissorD3D12(); + +IMGUI_GRAPH_API void imguiGraphFontTextureInitD3D12(unsigned char* data); + +IMGUI_GRAPH_API void imguiGraphFontTextureReleaseD3D12(); + #endif
\ No newline at end of file diff --git a/demo/DemoAppD3D12/imguiInteropD3D12.cpp b/demo/DemoAppD3D12/imguiInteropD3D12.cpp index 322e1b5..30a8760 100644 --- a/demo/DemoAppD3D12/imguiInteropD3D12.cpp +++ b/demo/DemoAppD3D12/imguiInteropD3D12.cpp @@ -21,7 +21,7 @@ ImguiDescriptorReserveHandleD3D12 imguiInteropReserveDescriptors(void* userdata, UINT numDescriptors, UINT64 lastFenceCompleted, UINT64 nextFenceValue) { - auto appctx = static_cast<AppGraphCtx*>(userdata); + auto appctx = cast_to_AppGraphCtxD3D12((AppGraphCtx*)userdata); auto srcHandle = appctx->m_dynamicHeapCbvSrvUav.reserveDescriptors(numDescriptors, lastFenceCompleted, nextFenceValue); ImguiDescriptorReserveHandleD3D12 handle = {}; handle.heap = srcHandle.heap; @@ -31,8 +31,10 @@ ImguiDescriptorReserveHandleD3D12 imguiInteropReserveDescriptors(void* userdata, return handle; } -void imguiInteropUpdateDesc(ImguiGraphDesc& desc, AppGraphCtx* appctx) +inline void imguiInteropUpdateDesc(ImguiGraphDescD3D12& desc, AppGraphCtx* appctxIn) { + auto appctx = cast_to_AppGraphCtxD3D12(appctxIn); + desc.device = appctx->m_device; desc.commandList = appctx->m_commandList; desc.lastFenceCompleted = appctx->m_lastFenceComplete; @@ -43,18 +45,22 @@ void imguiInteropUpdateDesc(ImguiGraphDesc& desc, AppGraphCtx* appctx) desc.dynamicHeapCbvSrvUav.reserveDescriptors = imguiInteropReserveDescriptors; } -bool imguiInteropGraphInit(imguiGraphInit_t func, const char* fontpath, AppGraphCtx* appctx) +IMGUI_GRAPH_API bool imguiInteropGraphInitD3D12(imguiGraphInit_t func, const char* fontpath, AppGraphCtx* appctx); + +IMGUI_GRAPH_API void imguiInteropGraphUpdateD3D12(imguiGraphUpdate_t func, AppGraphCtx* appctx); + +bool imguiInteropGraphInitD3D12(imguiGraphInit_t func, const char* fontpath, AppGraphCtx* appctx) { - ImguiGraphDesc desc; + ImguiGraphDescD3D12 desc; imguiInteropUpdateDesc(desc, appctx); - return func(fontpath, &desc); + return func(fontpath, cast_from_imguiGraphDescD3D12(&desc)); } -void imguiInteropGraphUpdate(imguiGraphUpdate_t func, AppGraphCtx* appctx) +void imguiInteropGraphUpdateD3D12(imguiGraphUpdate_t func, AppGraphCtx* appctx) { - ImguiGraphDesc desc; + ImguiGraphDescD3D12 desc; imguiInteropUpdateDesc(desc, appctx); - return func(&desc); + return func(cast_from_imguiGraphDescD3D12(&desc)); }
\ No newline at end of file diff --git a/demo/DemoAppD3D12/meshD3D12.cpp b/demo/DemoAppD3D12/meshD3D12.cpp index 3b04436..5821c89 100644 --- a/demo/DemoAppD3D12/meshD3D12.cpp +++ b/demo/DemoAppD3D12/meshD3D12.cpp @@ -105,7 +105,7 @@ struct MeshConstantHeap } }; -struct MeshContext +struct MeshContextD3D12 { ID3D12Device* m_device = nullptr; ID3D12GraphicsCommandList* m_commandList = nullptr; @@ -116,8 +116,8 @@ struct MeshContext MeshConstantHeap* m_constantHeap = nullptr; - MeshContext() {} - ~MeshContext() + MeshContextD3D12() {} + ~MeshContextD3D12() { COMRelease(m_rootSignature); COMRelease(m_pipelineStateLH); @@ -130,7 +130,17 @@ struct MeshContext } }; -struct MeshIndexBuffer +inline MeshContextD3D12* cast_to_MeshContextD3D12(MeshContext* ctx) +{ + return (MeshContextD3D12*)(ctx); +} + +inline MeshContext* cast_from_MeshContextD3D12(MeshContextD3D12* ctx) +{ + return (MeshContext*)(ctx); +} + +struct MeshIndexBufferD3D12 { ID3D12Resource* m_buffer = nullptr; MeshUint m_numElements = 0u; @@ -138,15 +148,25 @@ struct MeshIndexBuffer ID3D12Resource* m_upload = nullptr; - MeshIndexBuffer() {} - ~MeshIndexBuffer() + MeshIndexBufferD3D12() {} + ~MeshIndexBufferD3D12() { COMRelease(m_buffer); COMRelease(m_upload); } }; -struct MeshVertexBuffer +inline MeshIndexBufferD3D12* cast_to_MeshIndexBufferD3D12(MeshIndexBuffer* buf) +{ + return (MeshIndexBufferD3D12*)(buf); +} + +inline MeshIndexBuffer* cast_from_MeshIndexBufferD3D12(MeshIndexBufferD3D12* buf) +{ + return (MeshIndexBuffer*)(buf); +} + +struct MeshVertexBufferD3D12 { ID3D12Resource* m_buffer = nullptr; MeshUint m_numElements = 0u; @@ -154,16 +174,28 @@ struct MeshVertexBuffer ID3D12Resource* m_upload = nullptr; - MeshVertexBuffer() {} - ~MeshVertexBuffer() + MeshVertexBufferD3D12() {} + ~MeshVertexBufferD3D12() { COMRelease(m_buffer); COMRelease(m_upload); } }; -MeshConstantHeap::MeshConstantHeap(MeshContext* meshContext, int size) : m_meshContext(meshContext) +inline MeshVertexBufferD3D12* cast_to_MeshVertexBufferD3D12(MeshVertexBuffer* buf) { + return (MeshVertexBufferD3D12*)(buf); +} + +inline MeshVertexBuffer* cast_from_MeshVertexBufferD3D12(MeshVertexBufferD3D12* buf) +{ + return (MeshVertexBuffer*)(buf); +} + +MeshConstantHeap::MeshConstantHeap(MeshContext* meshContextIn, int size) : m_meshContext(meshContextIn) +{ + auto meshContext = cast_to_MeshContextD3D12(meshContextIn); + // create a constant buffer { HRESULT hr = S_OK; @@ -208,9 +240,11 @@ MeshConstantHeap::MeshConstantHeap(MeshContext* meshContext, int size) : m_meshC } } -MeshContext* MeshContextCreate(const MeshContextDesc* desc) +MeshContext* MeshContextCreateD3D12(const MeshContextDesc* descIn) { - MeshContext* context = new MeshContext; + auto desc = cast_to_MeshContextDescD3D12(descIn); + + MeshContextD3D12* context = new MeshContextD3D12; context->m_device = desc->device; context->m_commandList = desc->commandList; @@ -333,30 +367,35 @@ MeshContext* MeshContextCreate(const MeshContextDesc* desc) // create constant heap { - context->m_constantHeap = new MeshConstantHeap(context, 4096u); + context->m_constantHeap = new MeshConstantHeap(cast_from_MeshContextD3D12(context), 4096u); } - return context; + return cast_from_MeshContextD3D12(context); } -void MeshContextUpdate(MeshContext* context, const MeshContextDesc* desc) +void MeshContextUpdateD3D12(MeshContext* contextIn, const MeshContextDesc* descIn) { + auto context = cast_to_MeshContextD3D12(contextIn); + auto desc = cast_to_MeshContextDescD3D12(descIn); + context->m_device = desc->device; context->m_commandList = desc->commandList; context->m_constantHeap->reset(); } -void MeshContextRelease(MeshContext* context) +void MeshContextReleaseD3D12(MeshContext* context) { if (context == nullptr) return; - delete context; + delete cast_to_MeshContextD3D12(context); } -MeshIndexBuffer* MeshIndexBufferCreate(MeshContext* context, MeshUint* indices, MeshUint numIndices) +MeshIndexBuffer* MeshIndexBufferCreateD3D12(MeshContext* contextIn, MeshUint* indices, MeshUint numIndices) { - MeshIndexBuffer* buffer = new MeshIndexBuffer; + auto context = cast_to_MeshContextD3D12(contextIn); + + MeshIndexBufferD3D12* buffer = new MeshIndexBufferD3D12; buffer->m_numElements = numIndices; // create an index buffer @@ -433,19 +472,21 @@ MeshIndexBuffer* MeshIndexBufferCreate(MeshContext* context, MeshUint* indices, buffer->m_view.Format = DXGI_FORMAT_R32_UINT; } - return buffer; + return cast_from_MeshIndexBufferD3D12(buffer); } -void MeshIndexBufferRelease(MeshIndexBuffer* buffer) +void MeshIndexBufferReleaseD3D12(MeshIndexBuffer* buffer) { if (buffer == nullptr) return; - delete buffer; + delete cast_to_MeshIndexBufferD3D12(buffer); } -MeshVertexBuffer* MeshVertexBufferCreate(MeshContext* context, MeshVertex* vertices, MeshUint numVertices) +MeshVertexBuffer* MeshVertexBufferCreateD3D12(MeshContext* contextIn, MeshVertex* vertices, MeshUint numVertices) { - MeshVertexBuffer* buffer = new MeshVertexBuffer; + auto context = cast_to_MeshContextD3D12(contextIn); + + MeshVertexBufferD3D12* buffer = new MeshVertexBufferD3D12; buffer->m_numElements = numVertices; // create a vertex buffer @@ -522,18 +563,20 @@ MeshVertexBuffer* MeshVertexBufferCreate(MeshContext* context, MeshVertex* verti buffer->m_view.SizeInBytes = bufferSize; } - return buffer; + return cast_from_MeshVertexBufferD3D12(buffer); } -void MeshVertexBufferRelease(MeshVertexBuffer* buffer) +void MeshVertexBufferReleaseD3D12(MeshVertexBuffer* buffer) { if (buffer == nullptr) return; - delete buffer; + delete cast_to_MeshVertexBufferD3D12(buffer); } -void MeshContextDraw(MeshContext* context, const MeshContextDrawParams* params) +void MeshContextDrawD3D12(MeshContext* contextIn, const MeshContextDrawParams* params) { + auto context = cast_to_MeshContextD3D12(contextIn); + using namespace DirectX; XMMATRIX matrix = XMMatrixTranspose(XMMatrixMultiply(XMMatrixMultiply( @@ -569,8 +612,8 @@ void MeshContextDraw(MeshContext* context, const MeshContextDrawParams* params) commandList->SetGraphicsRootConstantBufferView(0, cbvHandle); commandList->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST); - commandList->IASetVertexBuffers(0, 1, ¶ms->vertexBuffer->m_view); - commandList->IASetIndexBuffer(¶ms->indexBuffer->m_view); + commandList->IASetVertexBuffers(0, 1, &cast_to_MeshVertexBufferD3D12(params->vertexBuffer)->m_view); + commandList->IASetIndexBuffer(&cast_to_MeshIndexBufferD3D12(params->indexBuffer)->m_view); - commandList->DrawIndexedInstanced((UINT)params->indexBuffer->m_numElements, 1, 0, 0, 0); + commandList->DrawIndexedInstanced((UINT)cast_to_MeshIndexBufferD3D12(params->indexBuffer)->m_numElements, 1, 0, 0, 0); }
\ No newline at end of file diff --git a/demo/DemoAppD3D12/meshD3D12.h b/demo/DemoAppD3D12/meshD3D12.h index 4bd0fab..94c8994 100644 --- a/demo/DemoAppD3D12/meshD3D12.h +++ b/demo/DemoAppD3D12/meshD3D12.h @@ -12,8 +12,35 @@ #include "../DemoApp/mesh.h" -struct MeshContextDesc +struct MeshContextDescD3D12 { ID3D12Device* device; ID3D12GraphicsCommandList* commandList; -};
\ No newline at end of file +}; + +inline const MeshContextDescD3D12* cast_to_MeshContextDescD3D12(const MeshContextDesc* desc) +{ + return (const MeshContextDescD3D12*)(desc); +} + +inline MeshContextDesc* cast_from_MeshContextDescD3D12(MeshContextDescD3D12* desc) +{ + return (MeshContextDesc*)(desc); +} + +MESH_API MeshContext* MeshContextCreateD3D12(const MeshContextDesc* desc); + +MESH_API void MeshContextUpdateD3D12(MeshContext* context, const MeshContextDesc* desc); + +MESH_API void MeshContextReleaseD3D12(MeshContext* context); + + +MESH_API MeshIndexBuffer* MeshIndexBufferCreateD3D12(MeshContext* context, MeshUint* indices, MeshUint numIndices); + +MESH_API void MeshIndexBufferReleaseD3D12(MeshIndexBuffer* buffer); + +MESH_API MeshVertexBuffer* MeshVertexBufferCreateD3D12(MeshContext* context, MeshVertex* vertices, MeshUint numVertices); + +MESH_API void MeshVertexBufferReleaseD3D12(MeshVertexBuffer* buffer); + +MESH_API void MeshContextDrawD3D12(MeshContext* context, const MeshContextDrawParams* params);
\ No newline at end of file diff --git a/demo/DemoAppD3D12/meshInteropD3D12.cpp b/demo/DemoAppD3D12/meshInteropD3D12.cpp index 19c034d..28649a0 100644 --- a/demo/DemoAppD3D12/meshInteropD3D12.cpp +++ b/demo/DemoAppD3D12/meshInteropD3D12.cpp @@ -19,20 +19,28 @@ #include "appD3D12Ctx.h" #include "meshD3D12.h" -MeshContext* MeshInteropContextCreate(AppGraphCtx* appctx) +MESH_API MeshContext* MeshInteropContextCreateD3D12(AppGraphCtx* appctx); + +MESH_API void MeshInteropContextUpdateD3D12(MeshContext* context, AppGraphCtx* appctx); + +MeshContext* MeshInteropContextCreateD3D12(AppGraphCtx* appctxIn) { - MeshContextDesc desc = {}; + auto appctx = cast_to_AppGraphCtxD3D12(appctxIn); + + MeshContextDescD3D12 desc = {}; desc.device = appctx->m_device; desc.commandList = appctx->m_commandList; - return MeshContextCreate(&desc); + return MeshContextCreateD3D12(cast_from_MeshContextDescD3D12(&desc)); } -void MeshInteropContextUpdate(MeshContext* context, AppGraphCtx* appctx) +void MeshInteropContextUpdateD3D12(MeshContext* context, AppGraphCtx* appctxIn) { - MeshContextDesc desc = {}; + auto appctx = cast_to_AppGraphCtxD3D12(appctxIn); + + MeshContextDescD3D12 desc = {}; desc.device = appctx->m_device; desc.commandList = appctx->m_commandList; - return MeshContextUpdate(context, &desc); + return MeshContextUpdateD3D12(context, cast_from_MeshContextDescD3D12(&desc)); }
\ No newline at end of file |