diff options
Diffstat (limited to 'include')
| -rw-r--r-- | include/NvFlow.h | 1826 | ||||
| -rw-r--r-- | include/NvFlowContext.h | 138 | ||||
| -rw-r--r-- | include/NvFlowContextD3D11.h | 129 | ||||
| -rw-r--r-- | include/NvFlowContextD3D12.h | 161 | ||||
| -rw-r--r-- | include/NvFlowShader.h | 103 | ||||
| -rw-r--r-- | include/NvFlowTypes.h | 99 |
6 files changed, 2456 insertions, 0 deletions
diff --git a/include/NvFlow.h b/include/NvFlow.h new file mode 100644 index 0000000..b62b9e6 --- /dev/null +++ b/include/NvFlow.h @@ -0,0 +1,1826 @@ +/* + * 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 + +#include "NvFlowContext.h" +#include "NvFlowShader.h" + +// -------------------------- NvFlowGrid ------------------------------- +///@defgroup NvFlowGrid +///@{ + +//! An adaptive sparse grid +struct NvFlowGrid; + +//! Interface to expose read access to grid simulation data +struct NvFlowGridExport; + +//! Grid texture channel, four components per channel +enum NvFlowGridTextureChannel +{ + eNvFlowGridTextureChannelVelocity = 0, + eNvFlowGridTextureChannelDensity = 1, + eNvFlowGridTextureChannelDensityCoarse = 2, + + eNvFlowGridTextureChannelCount +}; + +//! Enumeration used to describe density texture channel resolution relative to velocity resolution +enum NvFlowMultiRes +{ + eNvFlowMultiRes1x1x1 = 0, + eNvFlowMultiRes2x2x2 = 1 +}; + +//! Description required to create a grid +struct NvFlowGridDesc +{ + NvFlowFloat3 initialLocation; //!< Initial location of axis aligned bounding box + NvFlowFloat3 halfSize; //!< Initial half size of axis aligned bounding box + + NvFlowDim virtualDim; //!< Resolution of virtual address space inside of bounding box + NvFlowMultiRes densityMultiRes; //!< Number of density cells per velocity cell + + float residentScale; //!< Fraction of virtual cells to allocate memory for + float coarseResidentScaleFactor; //!< Allows relative increase of resident scale for coarse sparse textures + + bool enableVTR; //!< Enable use of volume tiled resources, if supported + bool lowLatencyMapping; //!< Faster mapping updates, more mapping overhead but less prediction required +}; + +/** + * Allows the application to request a default grid description from Flow. + * + * @param[out] desc The description for Flow to fill out. + */ +NV_FLOW_API void NvFlowGridDescDefaults(NvFlowGridDesc* desc); + +/** + * Creates a grid. + * + * @param[in] context The context to use to create the new grid. + * @param[in] desc The grid description. + * + * @return The created grid. + */ +NV_FLOW_API NvFlowGrid* NvFlowCreateGrid(NvFlowContext* context, const NvFlowGridDesc* desc); + +/** + * Releases a grid. + * + * @param[in] grid The grid to be released. + */ +NV_FLOW_API void NvFlowReleaseGrid(NvFlowGrid* grid); + +//! Description required to reset a NvFlowGrid +struct NvFlowGridResetDesc +{ + NvFlowFloat3 initialLocation; //!< Initial location of axis aligned bounding box + NvFlowFloat3 halfSize; //!< Initial half size of axis aligned bounding box +}; + +/** + * Allows the application to request a default grid reset description from Flow. + * + * @param[out] desc The description for Flow to fill out. + */ +NV_FLOW_API void NvFlowGridResetDescDefaults(NvFlowGridResetDesc* desc); + +/** + * Submits a request to reset a grid, preserving memory allocations + * + * @param[in] grid The grid to reset. + * @param[in] desc The grid reset description. + */ +NV_FLOW_API void NvFlowGridReset(NvFlowGrid* grid, const NvFlowGridResetDesc* desc); + +/** + * Not fully supported yet. Allows the application to request the grid move to a new location. + * + * @param[in] grid The grid to move. + * @param[in] targetLocation The location the center of the grid should make a best effort attempt to reach. + */ +NV_FLOW_API void NvFlowGridSetTargetLocation(NvFlowGrid* grid, NvFlowFloat3 targetLocation); + +//! Flags to control grid debug visualization +enum NvFlowGridDebugVisFlags +{ + eNvFlowGridDebugVisDisabled = 0x00, //!< No debug visualization + eNvFlowGridDebugVisBlocks = 0x01, //!< Simulation block visualization, no overhead + eNvFlowGridDebugVisEmitBounds = 0x02, //!< Emitter bounds visualization, adds overhead + eNvFlowGridDebugVisShapesSimple = 0x04, //!< Visualize sphere/capsule/box shapes, adds overhead + + eNvFlowGridDebugVisCount +}; + +//! Parameters controlling grid behavior +struct NvFlowGridParams +{ + NvFlowFloat3 gravity; //!< Gravity vector for use by buoyancy + + bool pressureLegacyMode; //!< If true, run older less accurate pressure solver + + bool bigEffectMode; //!< Tweaks block allocation for better big effect behavior + float bigEffectPredictTime; //!< Time constant to tune big effect prediction + + NvFlowGridDebugVisFlags debugVisFlags; //!< Flags to control what debug visualization information is generated +}; + +/** + * Allows the application to request default grid parameters from Flow. + * + * @param[out] params The parameters for Flow to fill out. + */ +NV_FLOW_API void NvFlowGridParamsDefaults(NvFlowGridParams* params); + +/** + * Sets grid simulation parameters, persistent over multiple grid updates. + * + * @param[in] grid The grid to set parameters on. + * @param[in] params The new parameter values. + */ +NV_FLOW_API void NvFlowGridSetParams(NvFlowGrid* grid, const NvFlowGridParams* params); + +//! Description of feature support on the queried Flow context GPU. +struct NvFlowSupport +{ + bool supportsVTR; //!< True if volume tiled resources are supported +}; + +/** + * Queries support for features that depend on hardware/OS. + * + * @param[in] grid The grid to query for support. + * @param[in] context The context the grid was created against. + * @param[out] support Description of what is supported. + * + * @return Returns eNvFlowSuccess if information is available. + */ +NV_FLOW_API NvFlowResult NvFlowGridQuerySupport(NvFlowGrid* grid, NvFlowContext* context, NvFlowSupport* support); + +//! CPU/GPU timing info +struct NvFlowQueryTime +{ + float simulation; +}; + +/** + * Queries simulation timing data. + * + * @param[in] grid The grid to query for timing. + * @param[out] gpuTime Simulation overhead on GPU. + * @param[out] cpuTime Simulation overhead on CPU. + * + * @return Returns eNvFlowSuccess if information is available. + */ +NV_FLOW_API NvFlowResult NvFlowGridQueryTime(NvFlowGrid* grid, NvFlowQueryTime* gpuTime, NvFlowQueryTime* cpuTime); + +/** + * Queries simulation GPU memory usage. + * + * @param[in] grid The grid to query for memory usage. + * @param[out] numBytes GPU memory allocated in bytes. + */ +NV_FLOW_API void NvFlowGridGPUMemUsage(NvFlowGrid* grid, NvFlowUint64* numBytes); + +/** + * Steps the simulation dt forward in time. + * + * @param[in] grid The grid to update. + * @param[in] context The context to perform the update. + * @param[in] dt The time step, typically in seconds. + */ +NV_FLOW_API void NvFlowGridUpdate(NvFlowGrid* grid, NvFlowContext* context, float dt); + +/** + * Get read interface to the grid simulation results + * + * @param[in] context The context the grid was created with. + * @param[in] grid The grid to read. + * + * @return Returns gridExport interface. + */ +NV_FLOW_API NvFlowGridExport* NvFlowGridGetGridExport(NvFlowContext* context, NvFlowGrid* grid); + +///@} +// -------------------------- NvFlowGridMaterial ------------------------------- +///@defgroup NvFlowGridMaterial +///@{ + +//! Handle provided by grid to reference materials +struct NvFlowGridMaterialHandle +{ + NvFlowGrid* grid; //!< The grid that created this material handle + NvFlowUint64 uid; //!< Unique id for this material +}; + +//! Grid component IDs +enum NvFlowGridComponent +{ + eNvFlowGridComponentVelocity = 0, + eNvFlowGridComponentSmoke = 1, + eNvFlowGridComponentTemperature = 2, + eNvFlowGridComponentFuel = 3, + + eNvFlowGridNumComponents = 4 +}; + +//! Grid material per component parameters +struct NvFlowGridMaterialPerComponent +{ + float damping; //!< Higher values reduce component value faster (exponential decay curve) + float fade; //!< Fade component value rate in units / sec + float macCormackBlendFactor; //!< Higher values make a sharper appearance, but with more artifacts + float macCormackBlendThreshold; //!< Minimum absolute value to apply MacCormack correction. Increasing can improve performance + float allocWeight; //!< Relative importance of component value for allocation, 0.0 means not important + float allocThreshold; //!< Minimum component value magnitude that is considered relevant +}; + +//! Grid material parameters +struct NvFlowGridMaterialParams +{ + NvFlowGridMaterialPerComponent velocity; //!< Velocity component parameters + NvFlowGridMaterialPerComponent smoke; //!< Smoke component parameters + NvFlowGridMaterialPerComponent temperature; //!< Temperature component parameters + NvFlowGridMaterialPerComponent fuel; //!< Fuel component parameters + + float vorticityStrength; //!< Higher values increase rotation, reduce laminar flow + float vorticityVelocityMask; //!< 0.f means zero velocity magnitude influence on vorticity + + float ignitionTemp; //!< Minimum temperature for combustion + float burnPerTemp; //!< Burn amount per unit temperature above ignitionTemp + float fuelPerBurn; //!< Fuel consumed per unit burn + float tempPerBurn; //!< Temperature increase per unit burn + float smokePerBurn; //!< Smoke increase per unit burn + float divergencePerBurn; //!< Expansion per unit burn + float buoyancyPerTemp; //!< Buoyant force per unit temperature + float coolingRate; //!< Cooling rate, exponential +}; + +/** + * Allows the application to request default grid material parameters from Flow. + * + * @param[out] params The parameters for Flow to fill out. + */ +NV_FLOW_API void NvFlowGridMaterialParamsDefaults(NvFlowGridMaterialParams* params); + +/** + * Gets a handle to the default grid material. + * + * @param[in] grid The grid to return its default grid material. + * + * @return Returns default grid material for grid. + */ +NV_FLOW_API NvFlowGridMaterialHandle NvFlowGridGetDefaultMaterial(NvFlowGrid* grid); + +/** + * Creates new grid material, initializes to params. + * + * @param[in] grid The Flow grid to set parameters on. + * @param[in] params The new parameter values. + * + * @return Returns handle to newly create grid material. + */ +NV_FLOW_API NvFlowGridMaterialHandle NvFlowGridCreateMaterial(NvFlowGrid* grid, const NvFlowGridMaterialParams* params); + +/** + * Release grid material + * + * @param[in] grid The grid to set parameters on. + * @param[in] material Handle to material to release. + */ +NV_FLOW_API void NvFlowGridReleaseMaterial(NvFlowGrid* grid, NvFlowGridMaterialHandle material); + +/** + * Sets material parameters, persistent over multiple grid updates. + * + * @param[in] grid The grid to set parameters on. + * @param[in] material Handle to material to update. + * @param[in] params The new parameter values. + */ +NV_FLOW_API void NvFlowGridSetMaterialParams(NvFlowGrid* grid, NvFlowGridMaterialHandle material, const NvFlowGridMaterialParams* params); + +///@} +// -------------------------- NvFlowShape ------------------------------- +///@defgroup NvFlowShape +///@{ + +//! Types of shapes for emit/collide behavior +enum NvFlowShapeType +{ + eNvFlowShapeTypeSDF = 0, + eNvFlowShapeTypeSphere = 1, + eNvFlowShapeTypeBox = 2, + eNvFlowShapeTypeCapsule = 3, + eNvFlowShapeTypePlane = 4 +}; + +//! A signed distance field shape object for emitters and/or collision +struct NvFlowShapeSDF; + +//! Description of a signed distance field shape +struct NvFlowShapeDescSDF +{ + NvFlowUint sdfOffset; //!< Offset in number of SDFs +}; + +//! Desription of a sphere +struct NvFlowShapeDescSphere +{ + float radius; //!< Radius in local space +}; + +//! Description of a box +struct NvFlowShapeDescBox +{ + NvFlowFloat3 halfSize; //!< HalfSize in local space +}; + +//! Description of a capsule +struct NvFlowShapeDescCapsule +{ + float radius; //!< Radius in local space + float length; //!< Length in local space on x axis +}; + +//! Description of a plane +struct NvFlowShapeDescPlane +{ + NvFlowFloat3 normal; //!< Normal vector of the plane in local space + float distance; //!< Shortest signed distance from the origin to the plane in local space +}; + +//! Shared type for shape descriptions +union NvFlowShapeDesc +{ + NvFlowShapeDescSDF sdf; + NvFlowShapeDescSphere sphere; + NvFlowShapeDescBox box; + NvFlowShapeDescCapsule capsule; + NvFlowShapeDescPlane plane; +}; + +//! Description required to create a signed distance field object. +struct NvFlowShapeSDFDesc +{ + NvFlowDim resolution; //!< The resolution of the 3D texture used to store the signed distance field. +}; + +/** + * Allows the application to request a default signed distance field object description from Flow. + * + * @param[out] desc The description for Flow to fill out. + */ +NV_FLOW_API void NvFlowShapeSDFDescDefaults(NvFlowShapeSDFDesc* desc); + +//! Required information for writing to a CPU mapped signed distance field. +struct NvFlowShapeSDFData +{ + float* data; //!< Pointer to mapped data + NvFlowUint rowPitch; //!< Row pitch in floats + NvFlowUint depthPitch; //!< Depth pitch in floats + NvFlowDim dim; //!< Dimension of the sdf texture +}; + +/** + * Creates a signed distance field object with no initial data. + * + * @param[in] context The context to use for creation. + * @param[in] desc A description needed for memory allocation. + * + * @return The created signed distance field object. + */ +NV_FLOW_API NvFlowShapeSDF* NvFlowCreateShapeSDF(NvFlowContext* context, const NvFlowShapeSDFDesc* desc); + +/** + * Creates a signed distance field object with data from a 3D texture. + * + * @param[in] context The context to use for creation. + * @param[in] texture The 3D texture containing the signed distance field to use. + * + * @return The created signed distance field object. + */ +NV_FLOW_API NvFlowShapeSDF* NvFlowCreateShapeSDFFromTexture3D(NvFlowContext* context, NvFlowTexture3D* texture); + +/** + * Releases a signed distance field object. + * + * @param[in] shape The signed distance field to be released. + */ +NV_FLOW_API void NvFlowReleaseShapeSDF(NvFlowShapeSDF* shape); + +/** + * Maps a signed distance field object for CPU write access. + * + * @param[in] shape The signed distance field object to map. + * @param[in] context The context used to create the Flow signed distance field. + * + * @return Returns the information needed to properly write to the mapped signed distance field object. + */ +NV_FLOW_API NvFlowShapeSDFData NvFlowShapeSDFMap(NvFlowShapeSDF* shape, NvFlowContext* context); + +/** + * Unmaps a signed distance field object from CPU write access, uploads update field to GPU. + * + * @param[in] shape The signed distance field object to unmap. + * @param[in] context The context used to create the Flow signed distance field. + */ +NV_FLOW_API void NvFlowShapeSDFUnmap(NvFlowShapeSDF* shape, NvFlowContext* context); + +///@} +// -------------------------- NvFlowGridEmit ------------------------------- +///@defgroup NvFlowGridEmit +///@{ + +//! Emitter modes +enum NvFlowGridEmitMode +{ + eNvFlowGridEmitModeDefault = 0, //!< Emitter will influence velocity and density channels, optionally allocate based on bounds + eNvFlowGridEmitModeDisableVelocity = 0x01, //!< Flag to disable emitter interaction with velocity field + eNvFlowGridEmitModeDisableDensity = 0x02, //!< Flag to disable emitter interaction with density field + eNvFlowGridEmitModeDisableAlloc = 0x04, //!< Flag to disable emitter bound allocation + eNvFlowGridEmitModeAllocShape = 0x08, //!< Emitter will allocate using shape to drive allocation instead of only bounds + + eNvFlowGridEmitModeAllocShapeOnly = 0x0F, //!< Flags to configure for shape aware allocation only +}; + +//! Parameters for both emission and collision +struct NvFlowGridEmitParams +{ + NvFlowUint shapeRangeOffset; //!< Start of shape range, offset in number of Shapes + NvFlowUint shapeRangeSize; //!< Size of shape range, in number of Shapes + NvFlowShapeType shapeType; //!< Type of shape in the set + float shapeDistScale; //!< Scale to apply to SDF value + + NvFlowFloat4x4 bounds; //!< Transform from emitter ndc to world space + NvFlowFloat4x4 localToWorld; //!< Transform from shape local space to world space + NvFlowFloat3 centerOfMass; //!< Center of mass in emitter local coordinate space + + float deltaTime; //!< DeltaTime used to compute impulse + + NvFlowGridMaterialHandle material; //!< Material for this emitter + NvFlowUint emitMode; //!< Emitter behavior, based on NvFlowGridEmitMode, 0u is default + NvFlowUint numSubSteps; //!< Numbers of interations to perform on cell value + + NvFlowFloat3 allocationScale; //!< Higher values cause more blocks to allocate around emitter; 0.f means no allocation, 1.f is default + float allocationPredict; //!< Higher values cause extra allocation based on linear velocity and predict velocity + NvFlowFloat3 predictVelocity; //!< Velocity used only for predict + float predictVelocityWeight; //!< Blend weight between linearVelocity and predictVelocity + + float minActiveDist; //!< Minimum distance value for active emission + float maxActiveDist; //!< Maximum distance value for active emission + float minEdgeDist; //!< Distance from minActiveDist to 1.0 emitter opacity + float maxEdgeDist; //!< Distance before maxActiveDist to 0.0 emitter opacity + float slipThickness; //!< Thickness of slip boundary region + float slipFactor; //!< 0.0 => no slip, fully damped; 1.0 => full slip + + NvFlowFloat3 velocityLinear; //!< Linear velocity, in world units, emitter direction + NvFlowFloat3 velocityAngular; //!< Angular velocity, in world units, emitter direction + NvFlowFloat3 velocityCoupleRate; //!< Rate of correction to target, inf means instantaneous + + float smoke; //!< Target smoke + float smokeCoupleRate; //!< Rate of correction to target, inf means instantaneous + + float temperature; //!< Target temperature + float temperatureCoupleRate; //!< Rate of correction to target, inf means instantaneous + + float fuel; //!< Target fuel + float fuelCoupleRate; //!< Rate of correction to target, inf means instantaneous + float fuelReleaseTemp; //!< Minimum temperature to release fuelRelease additional fuel + float fuelRelease; //!< Fuel released when temperature exceeds release temperature +}; + +/** + * Allows the application to request default emit parameters from Flow. + * + * @param[out] params The parameters for Flow to fill out. + */ +NV_FLOW_API void NvFlowGridEmitParamsDefaults(NvFlowGridEmitParams* params); + +/** + * Adds one or more emit events to be applied with the next grid update. + * + * @param[in] grid The Flow grid to apply the emit events. + * @param[in] shapes Array of shape data referenced by emit params. + * @param[in] numShapes Number of shapes in the array. + * @param[in] params Array of emit event parameters. + * @param[in] numParams Number of emit events in the array. + */ +NV_FLOW_API void NvFlowGridEmit(NvFlowGrid* grid, const NvFlowShapeDesc* shapes, NvFlowUint numShapes, const NvFlowGridEmitParams* params, NvFlowUint numParams); + +/** + * Update internal array of SDFs that can be referenced by sdfOffset + * + * @param[in] grid The Flow grid to apply the emit events. + * @param[in] sdfs Array of shape data referenced by emit params. + * @param[in] numSdfs Number of shapes in the array. + */ +NV_FLOW_API void NvFlowGridUpdateEmitSDFs(NvFlowGrid* grid, NvFlowShapeSDF** sdfs, NvFlowUint numSdfs); + +///@} +// -------------------------- NvFlowGridEmitCustom ------------------------------- +///@defgroup NvFlowGridEmitCustom +///@{ + +//! Necessary parameters/resources for custom grid block allocation +struct NvFlowGridEmitCustomAllocParams +{ + NvFlowResourceRW* maskResourceRW; //!< Integer mask, write 1u where allocation is desired + + NvFlowDim maskDim; //!< Mask dimensions + + NvFlowFloat3 gridLocation; //!< Location of grid's axis aligned bounding box + NvFlowFloat3 gridHalfSize; //!< Half size of grid's axis aligned bounding box + + NvFlowGridMaterialHandle material; //!< Grid material +}; + +typedef void(*NvFlowGridEmitCustomAllocFunc)(void* userdata, const NvFlowGridEmitCustomAllocParams* params); + +/** + * Sets custom allocation callback. + * + * @param[in] grid The grid to use the callback. + * @param[in] func The callback function. + * @param[in] userdata Pointer to provide to the callback function during execution. + */ +NV_FLOW_API void NvFlowGridEmitCustomRegisterAllocFunc(NvFlowGrid* grid, NvFlowGridEmitCustomAllocFunc func, void* userdata); + +//! Handle for requesting per layer emitter data +struct NvFlowGridEmitCustomEmitParams +{ + NvFlowGrid* grid; //!< The grid associated with this callback + NvFlowUint numLayers; //!< The number of layers to write to + void* flowInternal; //!< For Flow internal use, do not modify +}; + +//! Necessary parameters/resources for custom emit operations +struct NvFlowGridEmitCustomEmitLayerParams +{ + NvFlowResourceRW* dataRW[2u]; //!< Read/Write 3D textures for channel data + NvFlowResource* blockTable; //!< Table to map virtual blocks to real blocks + NvFlowResource* blockList; //!< List of active blocks + + NvFlowShaderPointParams shaderParams; //!< Parameters used in GPU side operations + + NvFlowUint numBlocks; //!< Number of active blocks + NvFlowUint maxBlocks; //!< Maximum possible active blocks + + NvFlowFloat3 gridLocation; //!< Location of grid's axis aligned bounding box + NvFlowFloat3 gridHalfSize; //!< Half size of grid's axis aligned bounding box + + NvFlowGridMaterialHandle material; //!< Grid material +}; + +typedef void(*NvFlowGridEmitCustomEmitFunc)(void* userdata, NvFlowUint* dataFrontIdx, const NvFlowGridEmitCustomEmitParams* params); + +/** + * Sets custom emit callback for given simulation channel. + * + * @param[in] grid The Flow grid to use the callback. + * @param[in] channel The simulation channel for this callback. + * @param[in] func The callback function. + * @param[in] userdata Pointer to provide to the callback function during execution. + */ +NV_FLOW_API void NvFlowGridEmitCustomRegisterEmitFunc(NvFlowGrid* grid, NvFlowGridTextureChannel channel, NvFlowGridEmitCustomEmitFunc func, void* userdata); + +/** + * Get per layer custom emit parameters, should only be called inside the custom emit callback. + * + * @param[in] emitParams The custom emit parameters. + * @param[in] layerIdx The layerIdx to fetch, should be least than emitParams->numLayers. + * @param[out] emitLayerParams Pointer to write parameters to. + */ +NV_FLOW_API void NvFlowGridEmitCustomGetLayerParams(const NvFlowGridEmitCustomEmitParams* emitParams, NvFlowUint layerIdx, NvFlowGridEmitCustomEmitLayerParams* emitLayerParams); + +///@} +// -------------------------- NvFlowGridExportImport ------------------------------- +///@defgroup NvFlowGridExport +///@{ + +//! Description of a single exported layer +struct NvFlowGridExportImportLayerMapping +{ + NvFlowGridMaterialHandle material; //!< Grid material associated with this layer + + NvFlowResource* blockTable; //!< Block table for this layer + NvFlowResource* blockList; //!< Block list for this layer + + NvFlowUint numBlocks; //!< Number of active blocks in this layer +}; + +//! Description applying to all exported layers +struct NvFlowGridExportImportLayeredMapping +{ + NvFlowShaderLinearParams shaderParams; //!< Shader parameters for address translation + NvFlowUint maxBlocks; //!< Maximum blocks active, for all layers + + NvFlowUint2* layeredBlockListCPU; //!< CPU list of active blocks, in (blockIdx, layerIdx) pairs + NvFlowUint layeredNumBlocks; //!< Number of blocks in layeredBlockListCPU + + NvFlowFloat4x4 modelMatrix; //!< Transform from grid NDC to world +}; + +///@} +// -------------------------- NvFlowGridExport ------------------------------- +///@defgroup NvFlowGridExport +///@{ + +//! Texture channel export handle +struct NvFlowGridExportHandle +{ + NvFlowGridExport* gridExport; //!< GridExport that created this handle + NvFlowGridTextureChannel channel; //!< Grid texture channel this handle is for + NvFlowUint numLayerViews; //!< Numbers of layers in this grid texture channel +}; + +//! Description of a single exported layer +struct NvFlowGridExportLayerView +{ + NvFlowResource* data; //!< Data resource for this layer view + NvFlowGridExportImportLayerMapping mapping; //!< Mapping of data to virtual space +}; + +//! Description applying to all exported layers +struct NvFlowGridExportLayeredView +{ + NvFlowGridExportImportLayeredMapping mapping; //!< Mapping parameters uniform across layers +}; + +//! Data to visualize simple shape +struct NvFlowGridExportSimpleShape +{ + NvFlowFloat4x4 localToWorld; //!< Transform from shape local to world space + NvFlowShapeDesc shapeDesc; //!< Shape desc to visualize +}; + +//! Debug vis data +struct NvFlowGridExportDebugVisView +{ + NvFlowGridDebugVisFlags debugVisFlags; //!< Debug vis flags to indicate what data is valid + + NvFlowFloat4x4* bounds; //!< Array of emitter bounds + NvFlowUint numBounds; //!< Number of emitter bounds in array + NvFlowGridExportSimpleShape* spheres; //!< Array of spheres + NvFlowUint numSpheres; //!< Number of spheres in array + NvFlowGridExportSimpleShape* capsules; //!< Array of capsules + NvFlowUint numCapsules; //!< Number of capsules in array + NvFlowGridExportSimpleShape* boxes; //!< Array of boxes + NvFlowUint numBoxes; //!< Number of boxes in array +}; + +/** + * Get export handle for the specified grid texture channel. + * + * @param[in] gridExport The grid export. + * @param[in] context The context used to create the grid export. + * @param[in] channel The grid texture channel to return a handle for. + * + * @return Returns export handle. + */ +NV_FLOW_API NvFlowGridExportHandle NvFlowGridExportGetHandle(NvFlowGridExport* gridExport, NvFlowContext* context, NvFlowGridTextureChannel channel); + +/** + * Get layerView data for specified exportHandle and layer index. + * + * @param[in] handle The grid export handle. + * @param[in] layerIdx The layer index to return the layerView of. + * @param[out] layerView Destination for layerView data. + */ +NV_FLOW_API void NvFlowGridExportGetLayerView(NvFlowGridExportHandle handle, NvFlowUint layerIdx, NvFlowGridExportLayerView* layerView); + +/** + * Get layeredView data for specified exportHandle. + * + * @param[in] handle The grid export handle. + * @param[out] layeredView Destination for layeredView data. + */ +NV_FLOW_API void NvFlowGridExportGetLayeredView(NvFlowGridExportHandle handle, NvFlowGridExportLayeredView* layeredView); + +/** + * Get export debug vis data. + * + * @param[in] gridExport The grid export. + * @param[out] view Destination for debug visualization view data. + */ +NV_FLOW_API void NvFlowGridExportGetDebugVisView(NvFlowGridExport* gridExport, NvFlowGridExportDebugVisView* view); + +///@} +// -------------------------- NvFlowGridImport ------------------------------- +///@defgroup NvFlowGridImport +///@{ + +//! Object to expose write access to Flow grid simulation data +struct NvFlowGridImport; + +//! Description required to create GridImport +struct NvFlowGridImportDesc +{ + NvFlowGridExport* gridExport; //!< Grid export to use as template for allocation +}; + +//! Grid import modes +enum NvFlowGridImportMode +{ + eNvFlowGridImportModePoint = 0, //!< Non redundant write target, conversion possible for linear sampling + eNvFlowGridImportModeLinear = 1 //!< Redundant write target, avoids conversion +}; + +//! Parameters for grabbing import view +struct NvFlowGridImportParams +{ + NvFlowGridExport* gridExport; //!< Grid export to serve as template for grid import + NvFlowGridTextureChannel channel; //!< Grid texture channel to generate import data for + NvFlowGridImportMode importMode; //!< Import mode, determines import data format +}; + +//! Texture channel handle +struct NvFlowGridImportHandle +{ + NvFlowGridImport* gridImport; //!< Grid import that created this handle + NvFlowGridTextureChannel channel; //!< Grid texture channel this handle is for + NvFlowUint numLayerViews; //!< Number of layers in this grid texture channel +}; + +//! Description of a single imported layer +struct NvFlowGridImportLayerView +{ + NvFlowResourceRW* dataRW; //!< This always should be written + NvFlowResourceRW* blockTableRW; //!< If StateCPU path is used, this needs to be written, else is nullptr + NvFlowResourceRW* blockListRW; //!< If StateCPU path is used, this needs to be written, else is nullptr + NvFlowGridExportImportLayerMapping mapping; //!< Mapping of data to virtual space +}; + +//! Description applying to all imported layers +struct NvFlowGridImportLayeredView +{ + NvFlowGridExportImportLayeredMapping mapping; //!< Mapping parameters uniform across layers +}; + +/** + * Create a standalone grid import. + * + * @param[in] context The context to use to create the new grid import. + * @param[in] desc Description required to create grid import. + * + * @return Returns new grid import. + */ +NV_FLOW_API NvFlowGridImport* NvFlowCreateGridImport(NvFlowContext* context, const NvFlowGridImportDesc* desc); + +/** + * Release a standalone grid import. + * + * @param[in] gridImport The grid import to release. + */ +NV_FLOW_API void NvFlowReleaseGridImport(NvFlowGridImport* gridImport); + +/** + * Get import handle for the specified grid texture channel and import mode. + * + * @param[in] gridImport The grid import. + * @param[in] context The context used to create the grid import. + * @param[in] params Parameters for import handle. + * + * @return Returns import handle. + */ +NV_FLOW_API NvFlowGridImportHandle NvFlowGridImportGetHandle(NvFlowGridImport* gridImport, NvFlowContext* context, const NvFlowGridImportParams* params); + +/** + * Get layerView data for specified importHandle and layer index. + * + * @param[in] handle The grid import handle. + * @param[in] layerIdx The layer index to return the layerView of. + * @param[out] layerView Destination for layerView data. + */ +NV_FLOW_API void NvFlowGridImportGetLayerView(NvFlowGridImportHandle handle, NvFlowUint layerIdx, NvFlowGridImportLayerView* layerView); + +/** + * Get layeredView data for specified importHandle. + * + * @param[in] handle The grid import handle. + * @param[out] layeredView Destination for layeredView data. + */ +NV_FLOW_API void NvFlowGridImportGetLayeredView(NvFlowGridImportHandle handle, NvFlowGridImportLayeredView* layeredView); + +/** + * Release grid texture channel for grid import, allowing for memory recycle. + * + * @param[in] gridImport The grid import. + * @param[in] context The context used to create the grid import. + * @param[in] channel The grid texture channel to release. + */ +NV_FLOW_API void NvFlowGridImportReleaseChannel(NvFlowGridImport* gridImport, NvFlowContext* context, NvFlowGridTextureChannel channel); + +/** + * Get grid export for read access to grid import data. + * + * @param[in] gridImport The grid import. + * @param[in] context The context used to create the grid import. + * + * @return Returns grid export. + */ +NV_FLOW_API NvFlowGridExport* NvFlowGridImportGetGridExport(NvFlowGridImport* gridImport, NvFlowContext* context); + +//! Object to hold captured CPU export state +struct NvFlowGridImportStateCPU; + +//! Parameters for grabbing import view +struct NvFlowGridImportStateCPUParams +{ + NvFlowGridImportStateCPU* stateCPU; //!< Import CPU state, captured previously with NvFlowGridImportUpdateStateCPU() + NvFlowGridTextureChannel channel; //!< Grid texture channel to generate import data for + NvFlowGridImportMode importMode; //!< Import mode, determines import data format +}; + +/** + * Create a grid import CPU state object. + * + * @param[in] gridImport The grid import to create the CPU state against. + * + * @return Returns new grid import CPU state. + */ +NV_FLOW_API NvFlowGridImportStateCPU* NvFlowCreateGridImportStateCPU(NvFlowGridImport* gridImport); + +/** + * Release a grid import CPU state object. + * + * @param[in] stateCPU The grid import CPU state to release. + */ +NV_FLOW_API void NvFlowReleaseGridImportStateCPU(NvFlowGridImportStateCPU* stateCPU); + +/** + * Capture CPU state from the provided grid export. + * + * @param[in] stateCPU The grid import CPU state to update. + * @param[in] context The context used to create the grid export. + * @param[in] gridExport The grid export to capture the CPU state of. + */ +NV_FLOW_API void NvFlowGridImportUpdateStateCPU(NvFlowGridImportStateCPU* stateCPU, NvFlowContext* context, NvFlowGridExport* gridExport); + +/** + * Get import handle, using previously captured CPU state to control configuration. + * + * @param[in] gridImport The grid import. + * @param[in] context The context used to create the grid import. + * @param[in] params Parameters for import handle. + * + * @return Returns import handle. + */ +NV_FLOW_API NvFlowGridImportHandle NvFlowGridImportStateCPUGetHandle(NvFlowGridImport* gridImport, NvFlowContext* context, const NvFlowGridImportStateCPUParams* params); + +///@} +// -------------------------- NvFlowRenderMaterial ------------------------------- +///@defgroup NvFlowRenderMaterial +///@{ + +//! A pool of render materials +struct NvFlowRenderMaterialPool; + +//! Description necessary to create render material +struct NvFlowRenderMaterialPoolDesc +{ + NvFlowUint colorMapResolution; //!< Dimension of 1D texture used to store color map, 64 is a good default +}; + +/** + * Creates a render material pool object. + * + * @param[in] context The context for GPU resource allocation. + * @param[in] desc Description for memory allocation. + * + * @return The created volume render object. + */ +NV_FLOW_API NvFlowRenderMaterialPool* NvFlowCreateRenderMaterialPool(NvFlowContext* context, const NvFlowRenderMaterialPoolDesc* desc); + +/** + * Releases a volume render object. + * + * @param[in] pool The volume render object to be released. + */ +NV_FLOW_API void NvFlowReleaseRenderMaterialPool(NvFlowRenderMaterialPool* pool); + +//! A handle to a volume render material +struct NvFlowRenderMaterialHandle +{ + NvFlowRenderMaterialPool* pool; //!< The pool that created this material + NvFlowUint64 uid; //!< Unique id for the render material +}; + +//! Render modes +enum NvFlowVolumeRenderMode +{ + eNvFlowVolumeRenderMode_colormap = 0, //!< Uses color map defined in render material + eNvFlowVolumeRenderMode_raw = 1, //!< Treats sampled value as RGBA + eNvFlowVolumeRenderMode_rainbow = 2, //!< Visualizes single component with rainbow color, good for density visualization + eNvFlowVolumeRenderMode_debug = 3, //!< Visualizes xyz components with color, good for velocity visualization + + eNvFlowVolumeRenderModeCount +}; + +//! Per material parameters for Flow grid rendering +struct NvFlowRenderMaterialParams +{ + NvFlowGridMaterialHandle material; //!< Grid material to align these parameters with + + float alphaScale; //!< Global alpha scale for adjust net opacity without color map changes, applied after saturate(alpha) + float additiveFactor; //!< 1.0 makes material blend fully additive + + NvFlowFloat4 colorMapCompMask; //!< Component mask for colormap, control what channel drives color map X axis; + NvFlowFloat4 alphaCompMask; //!< Component mask to control which channel(s) modulation the alpha + NvFlowFloat4 intensityCompMask; //!< Component mask to control which channel(s) modulates the intensity + + float colorMapMinX; //!< Minimum value on the x channel (typically temperature), maps to colorMap u = 0.0 + float colorMapMaxX; //!< Maximum value on the x channel (typically temperature), maps to colorMap u = 1.0 + float alphaBias; //!< Offsets alpha before saturate(alpha) + float intensityBias; //!< Offsets intensity before modulating color +}; + +/** + * Allows the application to request default volume render material parameters from Flow. + * + * @param[out] params The parameters for Flow to fill out. + */ +NV_FLOW_API void NvFlowRenderMaterialParamsDefaults(NvFlowRenderMaterialParams* params); + +/** + * Get the default render material. + * + * @param[in] pool The pool to create/own the material. + * + * @return Returns a handle to the default material. + */ +NV_FLOW_API NvFlowRenderMaterialHandle NvFlowGetDefaultRenderMaterial(NvFlowRenderMaterialPool* pool); + +/** + * Create a render material. + * + * @param[in] context The context to use for GPU resource creation. + * @param[in] pool The pool to create/own the material. + * @param[in] params Material parameters. + * + * @return Returns a handle to the material. + */ +NV_FLOW_API NvFlowRenderMaterialHandle NvFlowCreateRenderMaterial(NvFlowContext* context, NvFlowRenderMaterialPool* pool, const NvFlowRenderMaterialParams* params); + +/** + * Release a render material. + * + * @param[in] handle Handle to the material to release. + */ +NV_FLOW_API void NvFlowReleaseRenderMaterial(NvFlowRenderMaterialHandle handle); + +/** + * Update a render material. + * + * @param[in] handle Handle to the material to update. + * @param[in] params Material parameters. + */ +NV_FLOW_API void NvFlowRenderMaterialUpdate(NvFlowRenderMaterialHandle handle, const NvFlowRenderMaterialParams* params); + +//! Required information for writing to a CPU mapped color map +struct NvFlowColorMapData +{ + NvFlowFloat4* data; //! Red, green, blue, alpha values + NvFlowUint dim; //! Number of float4 elements in mapped array +}; + +/** + * Map the color map associated with the material for write access. + * + * @param[in] context The context to use for mapping. + * @param[in] handle Handle to the material to map. + * + * @return Returns a pointer and range of CPU memory for write access. + */ +NV_FLOW_API NvFlowColorMapData NvFlowRenderMaterialColorMap(NvFlowContext* context, NvFlowRenderMaterialHandle handle); + +/** + * Unmap the color map associated with the material. + * + * @param[in] context The context to perform unmap. + * @param[in] handle Handle to the material to unmap. + */ +NV_FLOW_API void NvFlowRenderMaterialColorUnmap(NvFlowContext* context, NvFlowRenderMaterialHandle handle); + +///@} +// -------------------------- NvFlowVolumeRender ------------------------------- +///@defgroup NvFlowVolumeRender +///@{ + +//! A grid volume renderer +struct NvFlowVolumeRender; + +//! Description needed to a create a volume render object +struct NvFlowVolumeRenderDesc +{ + NvFlowGridExport* gridExport; //!< Grid export, for memory allocation +}; + +/** + * Creates a volume render object. + * + * @param[in] context The context for GPU resource allocation. + * @param[in] desc Description for memory allocation. + * + * @return The created volume render object. + */ +NV_FLOW_API NvFlowVolumeRender* NvFlowCreateVolumeRender(NvFlowContext* context, const NvFlowVolumeRenderDesc* desc); + +/** + * Releases a volume render object. + * + * @param[in] volumeRender The volume render object to be released. + */ +NV_FLOW_API void NvFlowReleaseVolumeRender(NvFlowVolumeRender* volumeRender); + +//! Downsample options for offscreen ray march +enum NvFlowVolumeRenderDownsample +{ + eNvFlowVolumeRenderDownsampleNone = 0, + eNvFlowVolumeRenderDownsample2x2 = 1 +}; + +//! Multiple resolution options for offscreen ray march +enum NvFlowMultiResRayMarch +{ + eNvFlowMultiResRayMarchDisabled = 0, + eNvFlowMultiResRayMarch2x2 = 1, + eNvFlowMultiResRayMarch4x4 = 2, + eNvFlowMultiResRayMarch8x8 = 3, + eNvFlowMultiResRayMarch16x16 = 4, +}; + +//! Rendering viewport +struct NvFlowVolumeRenderViewport +{ + float topLeftX; + float topLeftY; + float width; + float height; +}; + +//! Parameters for VRWorks multires rendering +struct NvFlowVolumeRenderMultiResParams +{ + bool enabled; //!< If true, app render target is assumed multiRes + float centerWidth; //!< Width of central viewport, ranging 0.01..1, where 1 is full orignal viewport width + float centerHeight; //!< Height of central viewport, ranging 0.01..1, where 1 is full orignal viewport height + float centerX; //!< X location of central viewport, ranging 0..1, where 0.5 is the center of the screen + float centerY; //!< Y location of central viewport, ranging 0..1, where 0.5 is the center of the screen + float densityScaleX[3]; //!< Pixel density scale factors: how much the linear pixel density is scaled within each column (1.0 = full density) + float densityScaleY[3]; //!< Pixel density scale factors: how much the linear pixel density is scaled within each row (1.0 = full density) + NvFlowVolumeRenderViewport viewport; //!< Single viewport representing the entire region to composite against + float nonMultiResWidth; //!< The render target width if multires was disabled + float nonMultiResHeight; //!< The render target height if multires was disabled +}; + +//! Parameters for VRWorks lens matched shading rendering +struct NvFlowVolumeRenderLMSParams +{ + bool enabled; //!< If true, app render target is assumed lens matched shading + float warpLeft; + float warpRight; + float warpUp; + float warpDown; + float sizeLeft; + float sizeRight; + float sizeUp; + float sizeDown; + NvFlowVolumeRenderViewport viewport; //!< Single viewport representing the entire region to composite against + float nonLMSWidth; //!< The render target width if lens matched shading was disabled + float nonLMSHeight; //!< The render target height if lens matched shading was disabled +}; + +//! Parameters for Flow grid rendering +struct NvFlowVolumeRenderParams +{ + NvFlowFloat4x4 projectionMatrix; //!< Projection matrix, row major + NvFlowFloat4x4 viewMatrix; //!< View matrix, row major + NvFlowFloat4x4 modelMatrix; //!< Model matrix, row major + + NvFlowDepthStencilView* depthStencilView; //!< Depth stencil view for depth testing with ray march + NvFlowRenderTargetView* renderTargetView; //!< Render target view to composite ray marched result against + + NvFlowRenderMaterialPool* materialPool; //!< Pool of materials to look for matches to GridMaterials + + NvFlowVolumeRenderMode renderMode; //!< Render mode, see NvFlowVolumeRenderMode + NvFlowGridTextureChannel renderChannel; //!< GridExport channel to render + + bool debugMode; //!< If true, wireframe visualization is rendered + + NvFlowVolumeRenderDownsample downsampleFactor; //!< Controls size of ray marching render target relative to app render target. + float screenPercentage; //!< If 1.0, render at full ray march resolution, can be dynamically reduced toward 0.0 to ray march at a lower resolution + NvFlowMultiResRayMarch multiResRayMarch; //!< Coarsest downsample for multiple resolution ray march + float multiResSamplingScale; //!< 1.0 by default, increase for finer screen XY minimum sampling rate + + bool smoothColorUpsample; //!< If true, color upsample will do extra work to remove jaggies around depth discontinuities + + bool preColorCompositeOnly; //!< If true, do all operations except color composite + bool colorCompositeOnly; //!< If true, only apply color composite + bool generateDepth; //!< If true, generate nominal depth, and write to scene depth buffer + bool generateDepthDebugMode; //!< If true, visualize depth estimate + float depthAlphaThreshold; //!< Minimum alpha to trigger depth write + float depthIntensityThreshold; //!< Intensity on R or G or B to trigger depth write + + NvFlowVolumeRenderMultiResParams multiRes; //!< Multires parameters + + NvFlowVolumeRenderLMSParams lensMatchedShading; //!< Lens matched shading parameters +}; + +/** + * Allows the application to request default volume render parameters from Flow. + * + * @param[out] params The parameters for Flow to fill out. + */ +NV_FLOW_API void NvFlowVolumeRenderParamsDefaults(NvFlowVolumeRenderParams* params); + +//! Parameters for Flow grid lighting +struct NvFlowVolumeLightingParams +{ + NvFlowRenderMaterialPool* materialPool; //!< Pool of materials to look for matches to GridMaterials + + NvFlowVolumeRenderMode renderMode; //!< Render mode, see NvFlowVolumeRenderMode + NvFlowGridTextureChannel renderChannel; //!< GridExport channel to render +}; + +/** + * Lights a grid export to produce another grid export that can be ray marched raw. + * + * @param[in] volumeRender The volume render object to perform the lighting. + * @param[in] context The context that created the volume render object. + * @param[in] gridExport The grid export to ray march. + * @param[in] params Parameters for lighting. + * + * @return The lit grid view. + */ +NV_FLOW_API NvFlowGridExport* NvFlowVolumeRenderLightGridExport(NvFlowVolumeRender* volumeRender, NvFlowContext* context, NvFlowGridExport* gridExport, const NvFlowVolumeLightingParams* params); + +/** + * Renders a grid export. + * + * @param[in] volumeRender The volume render object to perform the rendering. + * @param[in] context The context that created the volume render object. + * @param[in] gridExport The grid export to ray march. + * @param[in] params Parameters for rendering. + */ +NV_FLOW_API void NvFlowVolumeRenderGridExport(NvFlowVolumeRender* volumeRender, NvFlowContext* context, NvFlowGridExport* gridExport, const NvFlowVolumeRenderParams* params); + +/** + * Renders a 3D texture. + * + * @param[in] volumeRender The volume render object to perform the rendering. + * @param[in] context The context that created the volume render object. + * @param[in] density The 3D texture to ray march. + * @param[in] params Parameters for rendering. + */ +NV_FLOW_API void NvFlowVolumeRenderTexture3D(NvFlowVolumeRender* volumeRender, NvFlowContext* context, NvFlowTexture3D* density, const NvFlowVolumeRenderParams* params); + +///@} +// -------------------------- NvFlowVolumeShadow ------------------------------- +///@defgroup NvFlowVolumeShadow +///@{ + +//! Object to generate shadows from grid export +struct NvFlowVolumeShadow; + +//! Description required to create volume shadow object +struct NvFlowVolumeShadowDesc +{ + NvFlowGridExport* gridExport; //!< Grid export for memory allocation + + NvFlowUint mapWidth; //!< Virtual width of shadow voxel address space + NvFlowUint mapHeight; //!< Virtual height of shadow voxel address space + NvFlowUint mapDepth; //!< Virtual depth of shadow voxel address space + + float minResidentScale; //!< Minimum (and initial) fraction of virtual cells to allocate memory for + float maxResidentScale; //!< Maximum fraction of virtual cells to allocate memory for +}; + +//! Parameters required to update volume shadows +struct NvFlowVolumeShadowParams +{ + NvFlowFloat4x4 projectionMatrix; //!< Projection matrix, row major + NvFlowFloat4x4 viewMatrix; //!< View matrix, row major + + NvFlowRenderMaterialPool* materialPool; //!< Pool of materials to look for matches to GridMaterials + + NvFlowVolumeRenderMode renderMode; //!< Render mode, see NvFlowVolumeRenderMode + NvFlowGridTextureChannel renderChannel; //!< GridExport channel to render + + float intensityScale; //!< Shadow intensity scale + float minIntensity; //!< Minimum shadow intensity + + NvFlowFloat4 shadowBlendCompMask; //!< Component mask to control which channel(s) modulate the shadow blending + float shadowBlendBias; //!< Bias on shadow blend factor +}; + +//! Parameters required to visualize shadow block allocation +struct NvFlowVolumeShadowDebugRenderParams +{ + NvFlowRenderTargetView* renderTargetView; //!< Render target to draw visualization to + + NvFlowFloat4x4 projectionMatrix; //!< Render target projection matrix, row major + NvFlowFloat4x4 viewMatrix; //!< Render target view matrix, row major +}; + +//! Stats on currently active volume shadow +struct NvFlowVolumeShadowStats +{ + NvFlowUint shadowColumnsActive; + NvFlowUint shadowBlocksActive; + NvFlowUint shadowCellsActive; +}; + +/** + * Creates a volume shadow object. + * + * @param[in] context The context for GPU resource allocation. + * @param[in] desc Description for memory allocation. + * + * @return The created volume shadow object. + */ +NV_FLOW_API NvFlowVolumeShadow* NvFlowCreateVolumeShadow(NvFlowContext* context, const NvFlowVolumeShadowDesc* desc); + +/** + * Releases a volume shadow object. + * + * @param[in] volumeShadow The volume shadow object to be released. + */ +NV_FLOW_API void NvFlowReleaseVolumeShadow(NvFlowVolumeShadow* volumeShadow); + +/** + * Generate shadows from provided grid export. + * + * @param[in] volumeShadow The volume shadow object. + * @param[in] context The context that created the volume shadow object. + * @param[in] gridExport The grid export to use for generating shadows. + * @param[in] params Parameters for shadow generation. + */ +NV_FLOW_API void NvFlowVolumeShadowUpdate(NvFlowVolumeShadow* volumeShadow, NvFlowContext* context, NvFlowGridExport* gridExport, const NvFlowVolumeShadowParams* params); + +/** + * Get grid export with shadow results. Currently, shadow results are placed in z component (the burn component). + * + * @param[in] volumeShadow The volume shadow object. + * @param[in] context The context that created the volume shadow object. + * + * @return Returns grid export with shadow results. + */ +NV_FLOW_API NvFlowGridExport* NvFlowVolumeShadowGetGridExport(NvFlowVolumeShadow* volumeShadow, NvFlowContext* context); + +/** + * Draw debug visualization of sparse volume shadow structure. + * + * @param[in] volumeShadow The volume shadow object. + * @param[in] context The context that created the volume shadow object. + * @param[in] params Parameters for debug visualization. + */ +NV_FLOW_API void NvFlowVolumeShadowDebugRender(NvFlowVolumeShadow* volumeShadow, NvFlowContext* context, const NvFlowVolumeShadowDebugRenderParams* params); + +/** + * Get stats for latest shadow computation. + * + * @param[in] volumeShadow The volume shadow object. + * @param[out] stats Destination for shadow computation stats. + */ +NV_FLOW_API void NvFlowVolumeShadowGetStats(NvFlowVolumeShadow* volumeShadow, NvFlowVolumeShadowStats* stats); + +///@} +// -------------------------- NvFlowCrossSection ------------------------------- +///@defgroup NvFlowCrossSection +///@{ + +//! Object to visualize cross section from grid export +struct NvFlowCrossSection; + +//! Description required to create cross section object +struct NvFlowCrossSectionDesc +{ + NvFlowGridExport* gridExport; //!< Grid export to serve as template for memory allocation +}; + +//! Parameters needed to render cross section +struct NvFlowCrossSectionParams +{ + NvFlowGridExport* gridExport; //!< gridExport used for final rendering + NvFlowGridExport* gridExportDebugVis; //!< gridExport direct from simulation + + NvFlowFloat4x4 projectionMatrix; //!< Projection matrix, row major + NvFlowFloat4x4 viewMatrix; //!< View matrix, row major + + NvFlowDepthStencilView* depthStencilView; //!< Depth stencil view for depth testing with ray march + NvFlowRenderTargetView* renderTargetView; //!< Render target view to composite ray marched result against + + NvFlowRenderMaterialPool* materialPool; //!< Pool of materials to look for matches to GridMaterials + + NvFlowVolumeRenderMode renderMode; //!< Render mode, see NvFlowVolumeRenderMode + NvFlowGridTextureChannel renderChannel; //!< GridExport channel to render + + NvFlowUint crossSectionAxis; //!< Cross section to visualize, 0 to 2 range + NvFlowFloat3 crossSectionPosition; //!< Offset in grid NDC for view + float crossSectionScale; //!< Scale on cross section to allow zooming + + float intensityScale; //!< scales the visualization intensity + + bool pointFilter; //!< If true, point filter so the cells are easy to see + + bool velocityVectors; //!< If true, overlay geometric velocity vectors + float velocityScale; //!< Scale to adjust vector length as a function of velocity + float vectorLengthScale; //!< Controls maximum velocity vector line length + + bool outlineCells; //!< Draw lines around cell boundaries + + bool fullscreen; //!< If true, covers entire viewport, if false, top right corner + + NvFlowFloat4 lineColor; //!< Color to use for any lines drawn + NvFlowFloat4 backgroundColor; //!< Background color + NvFlowFloat4 cellColor; //!< Color for cell outline +}; + +/** + * Allows the application to request default cross section parameters from Flow. + * + * @param[out] params The parameters for Flow to fill out. + */ +NV_FLOW_API void NvFlowCrossSectionParamsDefaults(NvFlowCrossSectionParams* params); + +/** + * Creates a cross section object. + * + * @param[in] context The context for GPU resource allocation. + * @param[in] desc Description for memory allocation. + * + * @return The created cross section object. + */ +NV_FLOW_API NvFlowCrossSection* NvFlowCreateCrossSection(NvFlowContext* context, const NvFlowCrossSectionDesc* desc); + +/** + * Releases a cross section object. + * + * @param[in] crossSection The cross section object to be released. + */ +NV_FLOW_API void NvFlowReleaseCrossSection(NvFlowCrossSection* crossSection); + +/** + * Renders a cross section of a grid export. + * + * @param[in] crossSection The cross section object. + * @param[in] context The context that allocated the cross section object. + * @param[in] params Parameters for cross section rendering. + */ +NV_FLOW_API void NvFlowCrossSectionRender(NvFlowCrossSection* crossSection, NvFlowContext* context, const NvFlowCrossSectionParams* params); + +///@} +// -------------------------- NvFlowGridProxy ------------------------------- +///@defgroup NvFlowGridProxy +///@{ + +//! A proxy for a grid simulated on one device to render on a different device, currently limited to Windows 10 for multi-GPU support. +struct NvFlowGridProxy; + +//! Proxy types +enum NvFlowGridProxyType +{ + eNvFlowGridProxyTypePassThrough = 0, //!< No operation, allows common code path for single versus multiple GPUs in the application + eNvFlowGridProxyTypeMultiGPU = 1, //!< Transports render data between GPUs + eNvFlowGridProxyTypeInterQueue = 2, //!< Versions grid export data for safe async compute +}; + +//! Parameters need to create a grid proxy +struct NvFlowGridProxyDesc +{ + NvFlowContext* gridContext; //!< Context used to simulate grid + NvFlowContext* renderContext; //!< Context used to render grid + NvFlowContext* gridCopyContext; //!< Context with copy capability on gridContext device + NvFlowContext* renderCopyContext; //!< Context with copy capability on renderContext device + + NvFlowGridExport* gridExport; //!< GridExport to base allocation on + + NvFlowGridProxyType proxyType; //!< GridProxy type to create +}; + +//! Parameters need to create a multi-GPU proxy +struct NvFlowGridProxyFlushParams +{ + NvFlowContext* gridContext; //!< Context used to simulate grid + NvFlowContext* gridCopyContext; //!< Context with copy capability on gridContext device + NvFlowContext* renderCopyContext; //!< Context with copy capability on renderContext device +}; + +/** + * Creates a grid proxy. + * + * @param[in] desc Description required to create grid proxy. + * + * @return The created grid proxy. + */ +NV_FLOW_API NvFlowGridProxy* NvFlowCreateGridProxy(const NvFlowGridProxyDesc* desc); + +/** + * Releases a grid proxy. + * + * @param[in] proxy The grid proxy to be released. + */ +NV_FLOW_API void NvFlowReleaseGridProxy(NvFlowGridProxy* proxy); + +/** + * Pushes simulation results to the proxy, should be updated after each simulation update. + * + * @param[in] proxy The grid proxy to be updated. + * @param[in] gridExport The grid export with latest simulation results. + * @param[in] params Parameters needed to flush the data. + */ +NV_FLOW_API void NvFlowGridProxyPush(NvFlowGridProxy* proxy, NvFlowGridExport* gridExport, const NvFlowGridProxyFlushParams* params); + +/** + * Helps simulation results move faster between GPUs, should be called before each render. + * + * @param[in] proxy The grid proxy to be flushed. + * @param[in] params Parameters needed to flush the data. + */ +NV_FLOW_API void NvFlowGridProxyFlush(NvFlowGridProxy* proxy, const NvFlowGridProxyFlushParams* params); + +/** + * Returns the latest grid export available on the render GPU. + * + * @param[in] proxy The grid proxy supplying the grid export. + * @param[in] renderContext The context that will render the grid export. + * + * @return The latest grid export available from the proxy. + */ +NV_FLOW_API NvFlowGridExport* NvFlowGridProxyGetGridExport(NvFlowGridProxy* proxy, NvFlowContext* renderContext); + +///@} +// -------------------------- NvFlowDevice ------------------------------- +///@defgroup NvFlowDevice +///@{ + +//! A device exclusively for Flow simulation +struct NvFlowDevice; + +//! Device Type +enum NvFlowDeviceMode +{ + eNvFlowDeviceModeProxy = 0, //!< Exposes renderContext device + eNvFlowDeviceModeUnique = 1, //!< Generates unique device, not matching renderContext +}; + +//! Description required for creating a Flow device +struct NvFlowDeviceDesc +{ + NvFlowDeviceMode mode; //!< Type of device to create + bool autoSelectDevice; //!< if true, NvFlow tries to identify best compute device + NvFlowUint adapterIdx; //!< preferred device index +}; + +/** + * Allows the application to request a default Flow device description from Flow. + * + * @param[out] desc The description for Flow to fill out. + */ +NV_FLOW_API void NvFlowDeviceDescDefaults(NvFlowDeviceDesc* desc); + +/** + * Checks if a GPU is available that is not being used for application graphics work. + * + * @param[in] renderContext A context that maps to the application graphics GPU. + * + * @return Returns true if dedicated GPU is available. + */ +NV_FLOW_API bool NvFlowDedicatedDeviceAvailable(NvFlowContext* renderContext); + +/** + * Checks if a GPU can support a dedicated queue + * + * @param[in] renderContext A context that maps to the application graphics GPU. + * + * @return Returns true if dedicated device queue is available. + */ +NV_FLOW_API bool NvFlowDedicatedDeviceQueueAvailable(NvFlowContext* renderContext); + +/** + * Creates a Flow compute device. + * + * @param[in] renderContext A context that maps to the application graphics GPU. + * @param[in] desc Description that controls what GPU is selected. + * + * @return The created Flow compute device. + */ +NV_FLOW_API NvFlowDevice* NvFlowCreateDevice(NvFlowContext* renderContext, const NvFlowDeviceDesc* desc); + +/** + * Releases a Flow compute device. + * + * @param[in] device The Flow compute device to be released. + */ +NV_FLOW_API void NvFlowReleaseDevice(NvFlowDevice* device); + +//! A device queue created through an NvFlowDevice +struct NvFlowDeviceQueue; + +//! Types of queues +enum NvFlowDeviceQueueType +{ + eNvFlowDeviceQueueTypeGraphics = 0, + eNvFlowDeviceQueueTypeCompute = 1, + eNvFlowDeviceQueueTypeCopy = 2 +}; + +//! Description required for creating a Flow device queue +struct NvFlowDeviceQueueDesc +{ + NvFlowDeviceQueueType queueType; + bool lowLatency; +}; + +//! Flow device queue status to allow app to throttle maximum queued work +struct NvFlowDeviceQueueStatus +{ + NvFlowUint framesInFlight; //!< Number of flushes that have not completed work on the GPU + NvFlowUint64 lastFenceCompleted; //!< The last fence completed on device queue + NvFlowUint64 nextFenceValue; //!< The fence value signaled after flush +}; + +/** + * Creates a Flow device queue. + * + * @param[in] device The device to create the queue on. + * @param[in] desc Description that controls kind of device queue to create. + * + * @return The created Flow device queue. + */ +NV_FLOW_API NvFlowDeviceQueue* NvFlowCreateDeviceQueue(NvFlowDevice* device, const NvFlowDeviceQueueDesc* desc); + +/** + * Releases a Flow device queue. + * + * @param[in] deviceQueue The Flow device queue to be released. + */ +NV_FLOW_API void NvFlowReleaseDeviceQueue(NvFlowDeviceQueue* deviceQueue); + +/** + * Creates a context that uses a Flow device queue. + * + * @param[in] deviceQueue The Flow device queue to create the context against. + * + * @return The created context. + */ +NV_FLOW_API NvFlowContext* NvFlowDeviceQueueCreateContext(NvFlowDeviceQueue* deviceQueue); + +/** + * Updates a context that uses a Flow device queue. + * + * @param[in] deviceQueue The Flow device queue the context was created against. + * @param[in] context The context update. + * @param[out] status Optional queue status to update, useful to detect if queue is overloaded. + */ +NV_FLOW_API void NvFlowDeviceQueueUpdateContext(NvFlowDeviceQueue* deviceQueue, NvFlowContext* context, NvFlowDeviceQueueStatus* status); + +/** + * Flushes all submitted work to the Flow deviceQueue. Must be called to submit work to queue. + * + * @param[in] deviceQueue The Flow deviceQueue to flush. + * @param[in] context The context to sync with the flush event + */ +NV_FLOW_API void NvFlowDeviceQueueFlush(NvFlowDeviceQueue* deviceQueue, NvFlowContext* context); + +/** + * Flushes all submitted work to the Flow deviceQueue if the context requests a flush. + * + * @param[in] deviceQueue The Flow deviceQueue to conditionally flush. + * @param[in] context The context to sync with the flush event. + */ +NV_FLOW_API void NvFlowDeviceQueueConditionalFlush(NvFlowDeviceQueue* deviceQueue, NvFlowContext* context); + +/** + * Blocks CPU until fenceValue is reached. + * + * @param[in] deviceQueue The Flow deviceQueue to flush. + * @param[in] context The context to sync with the flush event. + * @param[in] fenceValue The fence value to wait for. + */ +NV_FLOW_API void NvFlowDeviceQueueWaitOnFence(NvFlowDeviceQueue* deviceQueue, NvFlowContext* context, NvFlowUint64 fenceValue); + +///@} +// -------------------------- NvFlowSDFGenerator ------------------------------- +///@defgroup NvFlowSDFGenerator +///@{ + +//! A signed distance field generator +struct NvFlowSDFGen; + +//! Description required for creating a signed distance field generator +struct NvFlowSDFGenDesc +{ + NvFlowDim resolution; //!< Resolution of 3D texture storing signed distance field +}; + +//! Simple mesh description +struct NvFlowSDFGenMeshParams +{ + NvFlowUint numVertices; //!< Numbers of vertices in triangle mesh + float* positions; //!< Array of positions, stored in x, y, z order + NvFlowUint positionStride; //!< The distance between the beginning of one position to the beginning of the next position in array, in bytes + float* normals; //!< Array of normals, stored in nx, ny, nz order + NvFlowUint normalStride; //!< The distance between the beginning of one normal to the beginning of the next normal in array, in bytes + + NvFlowUint numIndices; //!< Numbers of indices in triangle mesh + NvFlowUint* indices; //!< Array of indices + + NvFlowFloat4x4 modelMatrix; //!< transforms from model space to SDF NDC space + + NvFlowDepthStencilView* depthStencilView; //!< Depth stencil view to restore after voxelize work, lighter than Flow context push/pop + NvFlowRenderTargetView* renderTargetView; //!< Render target view to restore after voxelize work, lighter than Flow context push/pop +}; + +/** + * Creates a Flow signed distance field generator. + * + * @param[in] context The context for GPU resource allocation. + * @param[in] desc Description for memory allocation. + * + * @return The created signed distance field generator. + */ +NV_FLOW_API NvFlowSDFGen* NvFlowCreateSDFGen(NvFlowContext* context, const NvFlowSDFGenDesc* desc); + +/** + * Releases a signed distance field generator. + * + * @param[in] sdfGen The signed distance field generator to be released. + */ +NV_FLOW_API void NvFlowReleaseSDFGen(NvFlowSDFGen* sdfGen); + +/** + * Clears previous voxelization. + * + * @param[in] sdfGen The signed distance field generator to test. + * @param[in] context The context that created sdfGen. + */ +NV_FLOW_API void NvFlowSDFGenReset(NvFlowSDFGen* sdfGen, NvFlowContext* context); + +/** + * Voxelizes triangle mesh. + * + * @param[in] sdfGen The signed distance field generator to perform voxelization. + * @param[in] context The context that created sdfGen. + * @param[in] params Parameters, including triangle mesh data. + */ +NV_FLOW_API void NvFlowSDFGenVoxelize(NvFlowSDFGen* sdfGen, NvFlowContext* context, const NvFlowSDFGenMeshParams* params); + +/** + * Generates signed distance field from latest voxelization. + * + * @param[in] sdfGen The signed distance field generator to update. + * @param[in] context The context that created sdfGen. + */ +NV_FLOW_API void NvFlowSDFGenUpdate(NvFlowSDFGen* sdfGen, NvFlowContext* context); + +/** + * Provides access to signed distance field 3D Texture. + * + * @param[in] sdfGen The signed distance field generator. + * @param[in] context The context that created sdfGen. + * + * @return The 3D texture storing the latest signed distance field. + */ +NV_FLOW_API NvFlowTexture3D* NvFlowSDFGenShape(NvFlowSDFGen* sdfGen, NvFlowContext* context); + +///@} +// -------------------------- NvFlowParticleSurface ------------------------------- +///@defgroup NvFlowParticleSurface +///@{ + +//! A particle surface generator +struct NvFlowParticleSurface; + +//! Description for creation +struct NvFlowParticleSurfaceDesc +{ + NvFlowFloat3 initialLocation; //!< Initial location of axis aligned bounding box + NvFlowFloat3 halfSize; //!< Initial half size of axis aligned bounding box + + NvFlowDim virtualDim; //!< Resolution of virtual address space inside of bounding box + float residentScale; //!< Fraction of virtual cells to allocate memory for + + NvFlowUint maxParticles; //!< Maximum particle count for memory allocation +}; + +//! Particle data +struct NvFlowParticleSurfaceData +{ + const float* positions; //!< Array of particle positions, xyz components + NvFlowUint positionStride; //!< Stride in bytes between particles + NvFlowUint numParticles; //!< Number of particles in array +}; + +//! Parameters for update +struct NvFlowParticleSurfaceParams +{ + float surfaceThreshold; //!< Threshold used to define isosurface + float smoothRadius; //!< Radius of smoothing kernel + bool separableSmoothing; //!< If true, use separable convolution for smoothing +}; + +//! Parameter for surface emission +struct NvFlowParticleSurfaceEmitParams +{ + float deltaTime; + + NvFlowFloat3 velocityLinear; //!< Linear velocity, in world units, emitter direction + NvFlowFloat3 velocityCoupleRate; //!< Rate of correction to target, inf means instantaneous + + float smoke; //!< Target smoke + float smokeCoupleRate; //!< Rate of correction to target, inf means instantaneous + + float temperature; //!< Target temperature + float temperatureCoupleRate; //!< Rate of correction to target, inf means instantaneous + + float fuel; //!< Target fuel + float fuelCoupleRate; //!< Rate of correction to target, inf means instantaneous +}; + +/** + * Create a particle surface object. + * + * @param[in] context The context to use to create the new particle surface. + * @param[in] desc Description required to create particle surface object. + * + * @return Returns created particle surface object. + */ +NV_FLOW_API NvFlowParticleSurface* NvFlowCreateParticleSurface(NvFlowContext* context, const NvFlowParticleSurfaceDesc* desc); + +/** + * Releases a particle surface object. + * + * @param[in] surface The particle surface object to be released. + */ +NV_FLOW_API void NvFlowReleaseParticleSurface(NvFlowParticleSurface* surface); + +/** + * Update particle data for particle surface. + * + * @param[in] surface The particle surface to update. + * @param[in] context The context used to create the particle surface. + * @param[in] data Particle data. + */ +NV_FLOW_API void NvFlowParticleSurfaceUpdateParticles(NvFlowParticleSurface* surface, NvFlowContext* context, const NvFlowParticleSurfaceData* data); + +/** + * Generate surface using the latest particle data. + * + * @param[in] surface The particle surface to update. + * @param[in] context The context used to create the particle surface. + * @param[in] params Parameters for surface generation. + */ +NV_FLOW_API void NvFlowParticleSurfaceUpdateSurface(NvFlowParticleSurface* surface, NvFlowContext* context, const NvFlowParticleSurfaceParams* params); + +/** + * Apply particle surface allocation to grid. + * + * @param[in] surface The particle surface object. + * @param[in] context The context used to create the particle surface and the grid. + * @param[in] params Parameters for grid custom allocation callback. + */ +NV_FLOW_API void NvFlowParticleSurfaceAllocFunc(NvFlowParticleSurface* surface, NvFlowContext* context, const NvFlowGridEmitCustomAllocParams* params); + +/** + * Apply particle surface emit operation to grid velocity texture channel. + * + * @param[in] surface The particle surface object. + * @param[in] context The context used to create the particle surface and the grid. + * @param[in] dataFrontIdx Pointer to front data index. + * @param[in] params Parameters for grid custom emit callback. + * @param[in] emitParams Parameters to control surface emit behavior. + */ +NV_FLOW_API void NvFlowParticleSurfaceEmitVelocityFunc(NvFlowParticleSurface* surface, NvFlowContext* context, NvFlowUint* dataFrontIdx, const NvFlowGridEmitCustomEmitParams* params, const NvFlowParticleSurfaceEmitParams* emitParams); + +/** + * Apply particle surface emit operation to grid density texture channel. + * + * @param[in] surface The particle surface object. + * @param[in] context The context used to create the particle surface and the grid. + * @param[in] dataFrontIdx Pointer to front data index. + * @param[in] params Parameters for grid custom emit callback. + * @param[in] emitParams Parameters to control surface emit behavior. + */ +NV_FLOW_API void NvFlowParticleSurfaceEmitDensityFunc(NvFlowParticleSurface* surface, NvFlowContext* context, NvFlowUint* dataFrontIdx, const NvFlowGridEmitCustomEmitParams* params, const NvFlowParticleSurfaceEmitParams* emitParams); + +/** + * Get grid export that can be ray marched to visualize the generated particle surface/volume. + * + * @param[in] surface The particle surface object. + * @param[in] context The context used to create the particle surface. + * + * @return Returns the grid export. + */ +NV_FLOW_API NvFlowGridExport* NvFlowParticleSurfaceDebugGridExport(NvFlowParticleSurface* surface, NvFlowContext* context); + +///@}
\ No newline at end of file diff --git a/include/NvFlowContext.h b/include/NvFlowContext.h new file mode 100644 index 0000000..eb80d78 --- /dev/null +++ b/include/NvFlowContext.h @@ -0,0 +1,138 @@ +/* + * 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 + +#include "NvFlowTypes.h" + +#define NV_FLOW_VERSION 0x00010000 + +//! NvFlowContext: A framework for fluid simulation +struct NvFlowContext; + +//! API type +enum NvFlowContextAPI +{ + eNvFlowContextD3D11 = 1, + eNvFlowContextD3D12 = 2 +}; + +//! import interop buffers +struct NvFlowDepthStencilView; +struct NvFlowRenderTargetView; + +//! export interop buffers +struct NvFlowResource; +struct NvFlowResourceRW; +struct NvFlowBuffer; +struct NvFlowTexture3D; + +// --------------------------- NvFlowContext ------------------------------- +///@defgroup NvFlowContext +///@{ + +/** + * Get the API type of the current context + * + * @param[in] context The Flow context to get the type of. + * + * @return context The Flow context to be released. + */ +NV_FLOW_API NvFlowContextAPI NvFlowContextGetContextType(NvFlowContext* context); + +/** + * Push a request for the Flow context to request a flush to queue + * + * @param[in] context The Flow context to make the request on. + */ +NV_FLOW_API void NvFlowContextFlushRequestPush(NvFlowContext* context); + +/** + * Pop any pending requests for the Flow context to flush to queue, resets the request state + * + * @param[in] context The Flow context to check for requests on. + * + * @return true if a flush is requested + */ +NV_FLOW_API bool NvFlowContextFlushRequestPop(NvFlowContext* context); + +/** + * Process pending GPU wait on fence, on deviceQueue associated with this context + * + * @param[in] context The Flow context to submit fence waits on. + */ +NV_FLOW_API void NvFlowContextProcessFenceWait(NvFlowContext* context); + +/** + * Process pending GPU fence signals, on deviceQueue associated with this context + * + * @param[in] context The Flow context to submit fence signals on. + */ +NV_FLOW_API void NvFlowContextProcessFenceSignal(NvFlowContext* context); + +/** + * Releases a Flow context. + * + * @param[in] context The Flow context to be released. + */ +NV_FLOW_API void NvFlowReleaseContext(NvFlowContext* context); + +/** + * Releases a Flow depth stencil view. + * + * @param[in] view The Flow depth stencil view to be released. + */ +NV_FLOW_API void NvFlowReleaseDepthStencilView(NvFlowDepthStencilView* view); + +/** + * Releases a Flow render target view. + * + * @param[in] view The Flow render target view to be released. + */ +NV_FLOW_API void NvFlowReleaseRenderTargetView(NvFlowRenderTargetView* view); + +/** + * Pushes graphics/compute pipeline state for later restoration by NvFlowContextPop. + * + * @param[in] context The Flow context to push. + */ +NV_FLOW_API void NvFlowContextPush(NvFlowContext* context); + +/** + * Restores graphics/compute pipeline state pushed by NvFlowContextPush. + * + * @param[in] context The Flow context to restore. + */ +NV_FLOW_API void NvFlowContextPop(NvFlowContext* context); + +/** + * An optional callback to allow the application to control how Flow allocates CPU memory. + * + * @param[in] malloc The allocation function for Flow to use. + */ +NV_FLOW_API void NvFlowSetMallocFunc(void*(*malloc)(size_t size)); + +/** + * An optional callback to allow the application to control how Flow releases CPU memory. + * + * @param[in] free The free function for Flow to use. + */ +NV_FLOW_API void NvFlowSetFreeFunc(void(*free)(void* ptr)); + +/** + * Should be called before DLL unload, to ensure complete cleanup. + * + * @param[in] timeoutMS Wait timeout, in milliseconds + * + * @return The current number of active deferred release units. + */ +NV_FLOW_API NvFlowUint NvFlowDeferredRelease(float timeoutMS); + +///@}
\ No newline at end of file diff --git a/include/NvFlowContextD3D11.h b/include/NvFlowContextD3D11.h new file mode 100644 index 0000000..02861d6 --- /dev/null +++ b/include/NvFlowContextD3D11.h @@ -0,0 +1,129 @@ +/* + * 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 + +// --------------------------- NvFlowContextD3D11 ------------------------------- +///@defgroup NvFlowContextD3D11 +///@{ + +struct NvFlowDepthStencilViewDescD3D11 +{ + ID3D11DepthStencilView* dsv; + ID3D11ShaderResourceView* srv; + D3D11_VIEWPORT viewport; +}; + +struct NvFlowRenderTargetViewDescD3D11 +{ + ID3D11RenderTargetView* rtv; + D3D11_VIEWPORT viewport; +}; + +struct NvFlowContextDescD3D11 +{ + ID3D11Device* device; + ID3D11DeviceContext* deviceContext; +}; + +struct NvFlowResourceViewDescD3D11 +{ + ID3D11ShaderResourceView* srv; +}; + +struct NvFlowResourceRWViewDescD3D11 +{ + NvFlowResourceViewDescD3D11 resourceView; + ID3D11UnorderedAccessView* uav; +}; + +/** + * Creates a graphics/compute context for Flow. + * + * @param[in] version Should be set by app to NV_FLOW_VERSION. + * @param[in] desc A graphics-API dependent structure containing data needed for a FlowContext to interoperate with the app. + * + * @return The created Flow context. + */ +NV_FLOW_API NvFlowContext* NvFlowCreateContextD3D11(NvFlowUint version, const NvFlowContextDescD3D11* desc); + +/** + * Creates a Flow depth stencil view based on information provided by the application. + * + * @param[in] context The Flow context to create and use the depth stencil view. + * @param[in] desc The graphics API dependent description. + * + * @return The created Flow depth stencil view. + */ +NV_FLOW_API NvFlowDepthStencilView* NvFlowCreateDepthStencilViewD3D11(NvFlowContext* context, const NvFlowDepthStencilViewDescD3D11* desc); + +/** + * Creates a Flow render target view based on information provided by the application. + * + * @param[in] context The Flow context to create and use the render target view. + * @param[in] desc The graphics API dependent description. + * + * @return The created Flow render target view. + */ +NV_FLOW_API NvFlowRenderTargetView* NvFlowCreateRenderTargetViewD3D11(NvFlowContext* context, const NvFlowRenderTargetViewDescD3D11* desc); + +/** + * Updates a Flow context with information provided by the application. + * + * @param[in] context The Flow context to update. + * @param[in] desc The graphics API dependent description. + */ +NV_FLOW_API void NvFlowUpdateContextD3D11(NvFlowContext* context, const NvFlowContextDescD3D11* desc); + +/** + * Gets a Flow context description from a Flow context. + * + * @param[in] context The Flow context. + * @param[out] desc The graphics API dependent description. + */ +NV_FLOW_API void NvFlowUpdateContextDescD3D11(NvFlowContext* context, NvFlowContextDescD3D11* desc); + +/** + * Updates a Flow depth stencil view with information provided by the application. + * + * @param[in] context The Flow context used to create the depth stencil view. + * @param[in] view The Flow depth stencil view to update. + * @param[in] desc The graphics API dependent description. + */ +NV_FLOW_API void NvFlowUpdateDepthStencilViewD3D11(NvFlowContext* context, NvFlowDepthStencilView* view, const NvFlowDepthStencilViewDescD3D11* desc); + +/** + * Updates a Flow render target view with information provided by the application. + * + * @param[in] context The Flow context used to create the render target view. + * @param[in] view The Flow render target view to update. + * @param[in] desc The graphics API dependent description. + */ +NV_FLOW_API void NvFlowUpdateRenderTargetViewD3D11(NvFlowContext* context, NvFlowRenderTargetView* view, const NvFlowRenderTargetViewDescD3D11* desc); + +/** + * Updates an application visible description with internal Flow resource information. + * + * @param[in] context The Flow context that created the resource. + * @param[in] resource The Flow resource to describe. + * @param[out] desc The graphics API dependent Flow resource description. + */ +NV_FLOW_API void NvFlowUpdateResourceViewDescD3D11(NvFlowContext* context, NvFlowResource* resource, NvFlowResourceViewDescD3D11* desc); + +/** + * Updates an application visible description with internal Flow resourceRW information. + * + * @param[in] context The Flow context that created the resourceRW. + * @param[in] resourceRW The Flow resourceRW to describe. + * @param[out] desc The graphics API dependent Flow resourceRW description. + */ +NV_FLOW_API void NvFlowUpdateResourceRWViewDescD3D11(NvFlowContext* context, NvFlowResourceRW* resourceRW, NvFlowResourceRWViewDescD3D11* desc); + +///@}
\ No newline at end of file diff --git a/include/NvFlowContextD3D12.h b/include/NvFlowContextD3D12.h new file mode 100644 index 0000000..54940cd --- /dev/null +++ b/include/NvFlowContextD3D12.h @@ -0,0 +1,161 @@ +/* + * 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 + +// --------------------------- NvFlowContextD3D12 ------------------------------- +///@defgroup NvFlowContextD3D12 +///@{ + +struct NvFlowDepthStencilViewDescD3D12 +{ + D3D12_CPU_DESCRIPTOR_HANDLE dsvHandle; + D3D12_DEPTH_STENCIL_VIEW_DESC dsvDesc; + D3D12_CPU_DESCRIPTOR_HANDLE srvHandle; + D3D12_SHADER_RESOURCE_VIEW_DESC srvDesc; + ID3D12Resource* resource; + D3D12_RESOURCE_STATES currentState; + D3D12_VIEWPORT viewport; +}; + +struct NvFlowRenderTargetViewDescD3D12 +{ + D3D12_CPU_DESCRIPTOR_HANDLE rtvHandle; + D3D12_RENDER_TARGET_VIEW_DESC rtvDesc; + ID3D12Resource* resource; + D3D12_RESOURCE_STATES currentState; + D3D12_VIEWPORT viewport; + D3D12_RECT scissor; +}; + +struct NvFlowDescriptorReserveHandleD3D12 +{ + ID3D12DescriptorHeap* heap; + NvFlowUint descriptorSize; + D3D12_CPU_DESCRIPTOR_HANDLE cpuHandle; + D3D12_GPU_DESCRIPTOR_HANDLE gpuHandle; +}; + +struct NvFlowDynamicDescriptorHeapD3D12 +{ + void* userdata; + NvFlowDescriptorReserveHandleD3D12 (*reserveDescriptors)(void* userdata, NvFlowUint numDescriptors, NvFlowUint64 lastFenceCompleted, NvFlowUint64 nextFenceValue); +}; + +struct NvFlowContextDescD3D12 +{ + ID3D12Device* device; //!< The desired d3d12 device to use + ID3D12CommandQueue* commandQueue; //!< The commandQueue commandList will be submit on + ID3D12Fence* commandQueueFence; //!< Fence marking events on this queue + ID3D12GraphicsCommandList* commandList; //!< The commandlist for recording + UINT64 lastFenceCompleted; //!< The last fence completed on commandQueue + UINT64 nextFenceValue; //!< The fence value signaled after commandList is submitted + + NvFlowDynamicDescriptorHeapD3D12 dynamicHeapCbvSrvUav; //!< Optional interface to share app descriptor heap with Flow +}; + +struct NvFlowResourceViewDescD3D12 +{ + D3D12_CPU_DESCRIPTOR_HANDLE srvHandle; + D3D12_SHADER_RESOURCE_VIEW_DESC srvDesc; + ID3D12Resource* resource; + D3D12_RESOURCE_STATES* currentState; +}; + +struct NvFlowResourceRWViewDescD3D12 +{ + NvFlowResourceViewDescD3D12 resourceView; + D3D12_CPU_DESCRIPTOR_HANDLE uavHandle; + D3D12_UNORDERED_ACCESS_VIEW_DESC uavDesc; +}; + +/** + * Creates a graphics/compute context for Flow. + * + * @param[in] version Should be set by app to NV_FLOW_VERSION. + * @param[in] desc A graphics-API dependent structure containing data needed for a FlowContext to interoperate with the app. + * + * @return The created Flow context. + */ +NV_FLOW_API NvFlowContext* NvFlowCreateContextD3D12(NvFlowUint version, const NvFlowContextDescD3D12* desc); + +/** + * Creates a Flow depth stencil view based on information provided by the application. + * + * @param[in] context The Flow context to create and use the depth stencil view. + * @param[in] desc The graphics API dependent description. + * + * @return The created Flow depth stencil view. + */ +NV_FLOW_API NvFlowDepthStencilView* NvFlowCreateDepthStencilViewD3D12(NvFlowContext* context, const NvFlowDepthStencilViewDescD3D12* desc); + +/** + * Creates a Flow render target view based on information provided by the application. + * + * @param[in] context The Flow context to create and use the render target view. + * @param[in] desc The graphics API dependent description. + * + * @return The created Flow render target view. + */ +NV_FLOW_API NvFlowRenderTargetView* NvFlowCreateRenderTargetViewD3D12(NvFlowContext* context, const NvFlowRenderTargetViewDescD3D12* desc); + +/** + * Updates a Flow context with information provided by the application. + * + * @param[in] context The Flow context to update. + * @param[in] desc The graphics API dependent description. + */ +NV_FLOW_API void NvFlowUpdateContextD3D12(NvFlowContext* context, const NvFlowContextDescD3D12* desc); + +/** + * Gets a Flow context description from a Flow context. + * + * @param[in] context The Flow context. + * @param[out] desc The graphics API dependent description. + */ +NV_FLOW_API void NvFlowUpdateContextDescD3D12(NvFlowContext* context, NvFlowContextDescD3D12* desc); + +/** + * Updates a Flow depth stencil view with information provided by the application. + * + * @param[in] context The Flow context used to create the depth stencil view. + * @param[in] view The Flow depth stencil view to update. + * @param[in] desc The graphics API dependent description. + */ +NV_FLOW_API void NvFlowUpdateDepthStencilViewD3D12(NvFlowContext* context, NvFlowDepthStencilView* view, const NvFlowDepthStencilViewDescD3D12* desc); + +/** + * Updates a Flow render target view with information provided by the application. + * + * @param[in] context The Flow context used to create the render target view. + * @param[in] view The Flow render target view to update. + * @param[in] desc The graphics API dependent description. + */ +NV_FLOW_API void NvFlowUpdateRenderTargetViewD3D12(NvFlowContext* context, NvFlowRenderTargetView* view, const NvFlowRenderTargetViewDescD3D12* desc); + +/** + * Updates an application visible description with internal Flow resource information. + * + * @param[in] context The Flow context that created the resource. + * @param[in] resource The Flow resource to describe. + * @param[out] desc The graphics API dependent Flow resource description. + */ +NV_FLOW_API void NvFlowUpdateResourceViewDescD3D12(NvFlowContext* context, NvFlowResource* resource, NvFlowResourceViewDescD3D12* desc); + +/** + * Updates an application visible description with internal Flow resourceRW information. + * + * @param[in] context The Flow context that created the resourceRW. + * @param[in] buffer The Flow resourceRW to describe. + * @param[out] desc The graphics API dependent Flow resourceRW description. + */ +NV_FLOW_API void NvFlowUpdateResourceRWViewDescD3D12(NvFlowContext* context, NvFlowResourceRW* resourceRW, NvFlowResourceRWViewDescD3D12* desc); + +///@}
\ No newline at end of file diff --git a/include/NvFlowShader.h b/include/NvFlowShader.h new file mode 100644 index 0000000..083af8e --- /dev/null +++ b/include/NvFlowShader.h @@ -0,0 +1,103 @@ +/* + * 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. + */ + +#ifndef NV_FLOW_SHADER_H +#define NV_FLOW_SHADER_H + +// --------------------------- NvFlow Shader Parameters ------------------------------- +///@defgroup NvFlowContext +///@{ + +#if (NV_FLOW_SHADER_UTILS != 0) + +int3 NvFlow_tableVal_to_coord(uint val) +{ + uint valInv = ~val; + return int3( + (valInv >> 0) & 0x3FF, + (valInv >> 10) & 0x3FF, + (valInv >> 20) & 0x3FF); +} + +#define NV_FLOW_DISPATCH_ID_TO_VIRTUAL(blockListSRV, params) \ + int3 DispatchIDToVirtual(uint3 tidx) \ + { \ + uint blockID = tidx.x >> params.blockDimBits.x; \ + int3 vBlockIdx = NvFlow_tableVal_to_coord(blockListSRV[blockID]); \ + int3 vidx = (vBlockIdx << params.blockDimBits.xyz) | (tidx & (params.blockDim.xyz - int3(1,1,1))); \ + return vidx; \ + } + +#define NV_FLOW_VIRTUAL_TO_REAL(name, blockTableSRV, params) \ + int3 name(int3 vidx) \ + { \ + if(params.isVTR.x != 0) \ + { \ + return vidx; \ + } \ + else \ + { \ + int3 vBlockIdx = vidx >> params.blockDimBits.xyz; \ + int3 rBlockIdx = NvFlow_tableVal_to_coord(blockTableSRV[vBlockIdx]); \ + int3 ridx = (rBlockIdx << params.blockDimBits.xyz) | (vidx & (params.blockDim.xyz - int3(1, 1, 1))); \ + return ridx; \ + } \ + } + +#define NV_FLOW_VIRTUAL_TO_REAL_LINEAR(name, blockTableSRV, params) \ + float3 name(float3 vidx) \ + { \ + if(params.isVTR.x != 0) \ + { \ + return vidx; \ + } \ + else \ + { \ + float3 vBlockIdxf = params.blockDimInv.xyz * vidx; \ + int3 vBlockIdx = int3(floor(vBlockIdxf)); \ + int3 rBlockIdx = NvFlow_tableVal_to_coord(blockTableSRV[vBlockIdx]); \ + float3 rBlockIdxf = float3(rBlockIdx); \ + float3 ridx = float3(params.linearBlockDim.xyz * rBlockIdx) + float3(params.blockDim.xyz) * (vBlockIdxf - float3(vBlockIdx)) + float3(params.linearBlockOffset.xyz); \ + return ridx; \ + } \ + } + +#endif + +//! Parameters for shaders using the point format (no linear interpolation) +struct NvFlowShaderPointParams +{ + NvFlowUint4 isVTR; + NvFlowUint4 blockDim; + NvFlowUint4 blockDimBits; + NvFlowUint4 poolGridDim; + NvFlowUint4 gridDim; +}; + +//! Parameters for shaders using the linear format (linear interpolation) +struct NvFlowShaderLinearParams +{ + NvFlowUint4 isVTR; + NvFlowUint4 blockDim; + NvFlowUint4 blockDimBits; + NvFlowUint4 poolGridDim; + NvFlowUint4 gridDim; + + NvFlowFloat4 blockDimInv; + NvFlowUint4 linearBlockDim; + NvFlowUint4 linearBlockOffset; + NvFlowFloat4 dimInv; + NvFlowFloat4 vdim; + NvFlowFloat4 vdimInv; +}; + +///@} + +#endif
\ No newline at end of file diff --git a/include/NvFlowTypes.h b/include/NvFlowTypes.h new file mode 100644 index 0000000..487809f --- /dev/null +++ b/include/NvFlowTypes.h @@ -0,0 +1,99 @@ +/* + * 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 + +#define NV_FLOW_API extern "C" __declspec(dllexport) + +enum NvFlowResult +{ + eNvFlowSuccess = 0, + eNvFlowFail = 1 +}; + +typedef int NvFlowInt; +typedef unsigned int NvFlowUint; +typedef unsigned long long NvFlowUint64; + +struct NvFlowDim +{ + NvFlowUint x, y, z; +}; + +struct NvFlowUint2 +{ + NvFlowUint x, y; +}; + +struct NvFlowUint3 +{ + NvFlowUint x, y, z; +}; + +struct NvFlowUint4 +{ + NvFlowUint x, y, z, w; +}; + +struct NvFlowFloat3 +{ + float x, y, z; +}; + +struct NvFlowFloat4 +{ + float x, y, z, w; +}; + +struct NvFlowFloat4x4 +{ + NvFlowFloat4 x, y, z, w; +}; + +enum NvFlowFormat +{ + eNvFlowFormat_unknown = 0, + + eNvFlowFormat_r32_float = 1, + eNvFlowFormat_r32g32_float = 2, + eNvFlowFormat_r32g32b32a32_float = 3, + + eNvFlowFormat_r16_float = 4, + eNvFlowFormat_r16g16_float = 5, + eNvFlowFormat_r16g16b16a16_float = 6, + + eNvFlowFormat_r32_uint = 7, + eNvFlowFormat_r32g32_uint = 8, + eNvFlowFormat_r32g32b32a32_uint = 9, + + eNvFlowFormat_r8_unorm = 10, + eNvFlowFormat_r8g8_unorm = 11, + eNvFlowFormat_r8g8b8a8_unorm = 12, + + eNvFlowFormat_r16_unorm = 13, + eNvFlowFormat_r16g16_unorm = 14, + eNvFlowFormat_r16g16b16a16_unorm = 15, + + eNvFlowFormat_d32_float = 16, + eNvFlowFormat_d24_unorm_s8_uint = 17, + + eNvFlowFormat_r8_snorm = 18, + eNvFlowFormat_r8g8_snorm = 19, + eNvFlowFormat_r8g8b8a8_snorm = 20, + + eNvFlowFormat_r32_typeless = 21, + eNvFlowFormat_r24_unorm_x8_typeless = 22, + eNvFlowFormat_r24g8_typeless = 23, + + eNvFlowFormat_r16_typeless = 24, + eNvFlowFormat_d16_unorm = 25, + + eNvFlowFormat_max +};
\ No newline at end of file |