---

---

NvFlow.h

Go to the documentation of this file.

/*
 * 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 -------------------------------

struct NvFlowGrid;

struct NvFlowGridExport;

enum NvFlowGridTextureChannel
{
    eNvFlowGridTextureChannelVelocity = 0,
    eNvFlowGridTextureChannelDensity = 1,
    eNvFlowGridTextureChannelDensityCoarse = 2,

    eNvFlowGridTextureChannelCount
};

enum NvFlowMultiRes
{
    eNvFlowMultiRes1x1x1 = 0,
    eNvFlowMultiRes2x2x2 = 1
};

struct NvFlowGridDesc
{
    NvFlowFloat3 initialLocation;       
    NvFlowFloat3 halfSize;              

    NvFlowDim virtualDim;               
    NvFlowMultiRes densityMultiRes;     

    float residentScale;                
    float coarseResidentScaleFactor;    

    bool enableVTR;                     
    bool lowLatencyMapping;             
};

NV_FLOW_API void NvFlowGridDescDefaults(NvFlowGridDesc* desc);

NV_FLOW_API NvFlowGrid* NvFlowCreateGrid(NvFlowContext* context, const NvFlowGridDesc* desc);

NV_FLOW_API void NvFlowReleaseGrid(NvFlowGrid* grid);

struct NvFlowGridResetDesc
{
    NvFlowFloat3 initialLocation;       
    NvFlowFloat3 halfSize;              
};

NV_FLOW_API void NvFlowGridResetDescDefaults(NvFlowGridResetDesc* desc);

NV_FLOW_API void NvFlowGridReset(NvFlowGrid* grid, const NvFlowGridResetDesc* desc);

NV_FLOW_API void NvFlowGridSetTargetLocation(NvFlowGrid* grid, NvFlowFloat3 targetLocation);

enum NvFlowGridDebugVisFlags
{
    eNvFlowGridDebugVisDisabled = 0x00,     
    eNvFlowGridDebugVisBlocks = 0x01,       
    eNvFlowGridDebugVisEmitBounds = 0x02,   
    eNvFlowGridDebugVisShapesSimple = 0x04, 

    eNvFlowGridDebugVisCount
};

struct NvFlowGridParams
{
    NvFlowFloat3 gravity;                   

    bool singlePassAdvection;               

    bool pressureLegacyMode;                

    bool bigEffectMode;                     
    float bigEffectPredictTime;             

    NvFlowGridDebugVisFlags debugVisFlags;  
};

NV_FLOW_API void NvFlowGridParamsDefaults(NvFlowGridParams* params);

NV_FLOW_API void NvFlowGridSetParams(NvFlowGrid* grid, const NvFlowGridParams* params);

struct NvFlowSupport
{
    bool supportsVTR;       
};

NV_FLOW_API NvFlowResult NvFlowGridQuerySupport(NvFlowGrid* grid, NvFlowContext* context, NvFlowSupport* support);

struct NvFlowQueryTime
{
    float simulation;
};

NV_FLOW_API NvFlowResult NvFlowGridQueryTime(NvFlowGrid* grid, NvFlowQueryTime* gpuTime, NvFlowQueryTime* cpuTime);

NV_FLOW_API void NvFlowGridGPUMemUsage(NvFlowGrid* grid, NvFlowUint64* numBytes);

NV_FLOW_API void NvFlowGridUpdate(NvFlowGrid* grid, NvFlowContext* context, float dt);

NV_FLOW_API NvFlowGridExport* NvFlowGridGetGridExport(NvFlowContext* context, NvFlowGrid* grid);

// -------------------------- NvFlowGridMaterial -------------------------------

struct NvFlowGridMaterialHandle
{
    NvFlowGrid* grid;       
    NvFlowUint64 uid;       
};

enum NvFlowGridComponent
{
    eNvFlowGridComponentVelocity = 0,
    eNvFlowGridComponentSmoke = 1,
    eNvFlowGridComponentTemperature = 2,
    eNvFlowGridComponentFuel = 3,

    eNvFlowGridNumComponents = 4
};

struct NvFlowGridMaterialPerComponent
{
    float damping;                      
    float fade;                         
    float macCormackBlendFactor;        
    float macCormackBlendThreshold;     
    float allocWeight;                  
    float allocThreshold;               
};

struct NvFlowGridMaterialParams
{
    NvFlowGridMaterialPerComponent velocity;    
    NvFlowGridMaterialPerComponent smoke;       
    NvFlowGridMaterialPerComponent temperature; 
    NvFlowGridMaterialPerComponent fuel;        

    float vorticityStrength;                    
    float vorticityVelocityMask;                
    float vorticityTemperatureMask;             
    float vorticitySmokeMask;                   
    float vorticityFuelMask;                    
    float vorticityConstantMask;                

    float ignitionTemp;                         
    float burnPerTemp;                          
    float fuelPerBurn;                          
    float tempPerBurn;                          
    float smokePerBurn;                         
    float divergencePerBurn;                    
    float buoyancyPerTemp;                      
    float coolingRate;                          
};

NV_FLOW_API void NvFlowGridMaterialParamsDefaults(NvFlowGridMaterialParams* params);

NV_FLOW_API NvFlowGridMaterialHandle NvFlowGridGetDefaultMaterial(NvFlowGrid* grid);

NV_FLOW_API NvFlowGridMaterialHandle NvFlowGridCreateMaterial(NvFlowGrid* grid, const NvFlowGridMaterialParams* params);

NV_FLOW_API void NvFlowGridReleaseMaterial(NvFlowGrid* grid, NvFlowGridMaterialHandle material);

NV_FLOW_API void NvFlowGridSetMaterialParams(NvFlowGrid* grid, NvFlowGridMaterialHandle material, const NvFlowGridMaterialParams* params);

// -------------------------- NvFlowShape -------------------------------

enum NvFlowShapeType
{
    eNvFlowShapeTypeSDF = 0,
    eNvFlowShapeTypeSphere = 1,
    eNvFlowShapeTypeBox = 2,
    eNvFlowShapeTypeCapsule = 3,
    eNvFlowShapeTypePlane = 4
};

struct NvFlowShapeSDF;

struct NvFlowShapeDescSDF
{
    NvFlowUint sdfOffset;   
};

struct NvFlowShapeDescSphere
{
    float radius;           
};

struct NvFlowShapeDescBox
{
    NvFlowFloat3 halfSize;  
};

struct NvFlowShapeDescCapsule
{
    float radius;           
    float length;           
};

struct NvFlowShapeDescPlane
{
    NvFlowFloat3 normal;    
    float distance;         
};

union NvFlowShapeDesc
{
    NvFlowShapeDescSDF sdf;
    NvFlowShapeDescSphere sphere;
    NvFlowShapeDescBox box;
    NvFlowShapeDescCapsule capsule;
    NvFlowShapeDescPlane plane;
};

struct NvFlowShapeSDFDesc
{
    NvFlowDim resolution;       
};

NV_FLOW_API void NvFlowShapeSDFDescDefaults(NvFlowShapeSDFDesc* desc);

struct NvFlowShapeSDFData
{
    float* data;                
    NvFlowUint rowPitch;        
    NvFlowUint depthPitch;      
    NvFlowDim dim;              
};

NV_FLOW_API NvFlowShapeSDF* NvFlowCreateShapeSDF(NvFlowContext* context, const NvFlowShapeSDFDesc* desc);

NV_FLOW_API NvFlowShapeSDF* NvFlowCreateShapeSDFFromTexture3D(NvFlowContext* context, NvFlowTexture3D* texture);

NV_FLOW_API void NvFlowReleaseShapeSDF(NvFlowShapeSDF* shape);

NV_FLOW_API NvFlowShapeSDFData NvFlowShapeSDFMap(NvFlowShapeSDF* shape, NvFlowContext* context);

NV_FLOW_API void NvFlowShapeSDFUnmap(NvFlowShapeSDF* shape, NvFlowContext* context);

// -------------------------- NvFlowGridEmit -------------------------------

enum NvFlowGridEmitMode
{
    eNvFlowGridEmitModeDefault = 0,                 
    eNvFlowGridEmitModeDisableVelocity = 0x01,      
    eNvFlowGridEmitModeDisableDensity = 0x02,       
    eNvFlowGridEmitModeDisableAlloc = 0x04,         
    eNvFlowGridEmitModeAllocShape = 0x08,           

    eNvFlowGridEmitModeAllocShapeOnly = 0x0F,       
};

struct NvFlowGridEmitParams
{
    NvFlowUint shapeRangeOffset;                    
    NvFlowUint shapeRangeSize;                      
    NvFlowShapeType shapeType;                      
    float shapeDistScale;                           

    NvFlowFloat4x4 bounds;                          
    NvFlowFloat4x4 localToWorld;                    
    NvFlowFloat3 centerOfMass;                      

    float deltaTime;                                

    NvFlowUint emitMaterialIndex;                   
    NvFlowUint emitMode;                            

    NvFlowFloat3 allocationScale;                   
    float allocationPredict;                        
    NvFlowFloat3 predictVelocity;                   
    float predictVelocityWeight;                    

    float minActiveDist;                            
    float maxActiveDist;                            
    float minEdgeDist;                              
    float maxEdgeDist;                              
    float slipThickness;                            
    float slipFactor;                               

    NvFlowFloat3 velocityLinear;                    
    NvFlowFloat3 velocityAngular;                   
    NvFlowFloat3 velocityCoupleRate;                

    float smoke;                                    
    float smokeCoupleRate;                          

    float temperature;                              
    float temperatureCoupleRate;                    

    float fuel;                                     
    float fuelCoupleRate;                           
    float fuelReleaseTemp;                          
    float fuelRelease;                              
};

NV_FLOW_API void NvFlowGridEmitParamsDefaults(NvFlowGridEmitParams* params);

NV_FLOW_API void NvFlowGridEmit(NvFlowGrid* grid, const NvFlowShapeDesc* shapes, NvFlowUint numShapes, const NvFlowGridEmitParams* params, NvFlowUint numParams);

NV_FLOW_API void NvFlowGridUpdateEmitMaterials(NvFlowGrid* grid, NvFlowGridMaterialHandle* materials, NvFlowUint numMaterials);

NV_FLOW_API void NvFlowGridUpdateEmitSDFs(NvFlowGrid* grid, NvFlowShapeSDF** sdfs, NvFlowUint numSdfs);

// -------------------------- NvFlowGridEmitCustom -------------------------------

struct NvFlowGridEmitCustomAllocParams
{
    NvFlowResourceRW* maskResourceRW;   

    NvFlowDim maskDim;                  

    NvFlowFloat3 gridLocation;          
    NvFlowFloat3 gridHalfSize;          

    NvFlowGridMaterialHandle material;  
};

typedef void(*NvFlowGridEmitCustomAllocFunc)(void* userdata, const NvFlowGridEmitCustomAllocParams* params);

NV_FLOW_API void NvFlowGridEmitCustomRegisterAllocFunc(NvFlowGrid* grid, NvFlowGridEmitCustomAllocFunc func, void* userdata);

struct NvFlowGridEmitCustomEmitParams
{
    NvFlowGrid* grid;           
    NvFlowUint numLayers;       
    void* flowInternal;         
};

struct NvFlowGridEmitCustomEmitLayerParams
{
    NvFlowResourceRW* dataRW[2u];               
    NvFlowResource* blockTable;                 
    NvFlowResource* blockList;                  

    NvFlowShaderPointParams shaderParams;       

    NvFlowUint numBlocks;                       
    NvFlowUint maxBlocks;                       

    NvFlowFloat3 gridLocation;                  
    NvFlowFloat3 gridHalfSize;                  

    NvFlowGridMaterialHandle material;          
};

typedef void(*NvFlowGridEmitCustomEmitFunc)(void* userdata, NvFlowUint* dataFrontIdx, const NvFlowGridEmitCustomEmitParams* params);

NV_FLOW_API void NvFlowGridEmitCustomRegisterEmitFunc(NvFlowGrid* grid, NvFlowGridTextureChannel channel, NvFlowGridEmitCustomEmitFunc func, void* userdata);

NV_FLOW_API void NvFlowGridEmitCustomGetLayerParams(const NvFlowGridEmitCustomEmitParams* emitParams, NvFlowUint layerIdx, NvFlowGridEmitCustomEmitLayerParams* emitLayerParams);

// -------------------------- NvFlowGridExportImport -------------------------------

struct NvFlowGridExportImportLayerMapping
{
    NvFlowGridMaterialHandle material;          

    NvFlowResource* blockTable;                 
    NvFlowResource* blockList;                  

    NvFlowUint numBlocks;                       
};

struct NvFlowGridExportImportLayeredMapping
{
    NvFlowShaderLinearParams shaderParams;      
    NvFlowUint maxBlocks;                       

    NvFlowUint2* layeredBlockListCPU;           
    NvFlowUint layeredNumBlocks;                

    NvFlowFloat4x4 modelMatrix;                 
};

// -------------------------- NvFlowGridExport -------------------------------

struct NvFlowGridExportHandle
{
    NvFlowGridExport* gridExport;           
    NvFlowGridTextureChannel channel;       
    NvFlowUint numLayerViews;               
};

struct NvFlowGridExportLayerView
{
    NvFlowResource* data;                           
    NvFlowGridExportImportLayerMapping mapping;     
};

struct NvFlowGridExportLayeredView
{
    NvFlowGridExportImportLayeredMapping mapping;   
};

struct NvFlowGridExportSimpleShape
{
    NvFlowFloat4x4 localToWorld;        
    NvFlowShapeDesc shapeDesc;          
};

struct NvFlowGridExportDebugVisView
{
    NvFlowGridDebugVisFlags debugVisFlags;      

    NvFlowFloat4x4* bounds;                     
    NvFlowUint numBounds;                       
    NvFlowGridExportSimpleShape* spheres;       
    NvFlowUint numSpheres;                      
    NvFlowGridExportSimpleShape* capsules;      
    NvFlowUint numCapsules;                     
    NvFlowGridExportSimpleShape* boxes;         
    NvFlowUint numBoxes;                        
};

NV_FLOW_API NvFlowGridExportHandle NvFlowGridExportGetHandle(NvFlowGridExport* gridExport, NvFlowContext* context, NvFlowGridTextureChannel channel);

NV_FLOW_API void NvFlowGridExportGetLayerView(NvFlowGridExportHandle handle, NvFlowUint layerIdx, NvFlowGridExportLayerView* layerView);

NV_FLOW_API void NvFlowGridExportGetLayeredView(NvFlowGridExportHandle handle, NvFlowGridExportLayeredView* layeredView);

NV_FLOW_API void NvFlowGridExportGetDebugVisView(NvFlowGridExport* gridExport, NvFlowGridExportDebugVisView* view);

// -------------------------- NvFlowGridImport -------------------------------

struct NvFlowGridImport;

struct NvFlowGridImportDesc
{
    NvFlowGridExport* gridExport;       
};

enum NvFlowGridImportMode
{
    eNvFlowGridImportModePoint = 0,     
    eNvFlowGridImportModeLinear = 1     
};

struct NvFlowGridImportParams
{
    NvFlowGridExport* gridExport;       
    NvFlowGridTextureChannel channel;   
    NvFlowGridImportMode importMode;    
};

struct NvFlowGridImportHandle
{
    NvFlowGridImport* gridImport;       
    NvFlowGridTextureChannel channel;   
    NvFlowUint numLayerViews;           
};

struct NvFlowGridImportLayerView
{
    NvFlowResourceRW* dataRW;                       
    NvFlowResourceRW* blockTableRW;                 
    NvFlowResourceRW* blockListRW;                  
    NvFlowGridExportImportLayerMapping mapping;     
};

struct NvFlowGridImportLayeredView
{
    NvFlowGridExportImportLayeredMapping mapping;   
};

NV_FLOW_API NvFlowGridImport* NvFlowCreateGridImport(NvFlowContext* context, const NvFlowGridImportDesc* desc);

NV_FLOW_API void NvFlowReleaseGridImport(NvFlowGridImport* gridImport);

NV_FLOW_API NvFlowGridImportHandle NvFlowGridImportGetHandle(NvFlowGridImport* gridImport, NvFlowContext* context, const NvFlowGridImportParams* params);

NV_FLOW_API void NvFlowGridImportGetLayerView(NvFlowGridImportHandle handle, NvFlowUint layerIdx, NvFlowGridImportLayerView* layerView);

NV_FLOW_API void NvFlowGridImportGetLayeredView(NvFlowGridImportHandle handle, NvFlowGridImportLayeredView* layeredView);

NV_FLOW_API void NvFlowGridImportReleaseChannel(NvFlowGridImport* gridImport, NvFlowContext* context, NvFlowGridTextureChannel channel);

NV_FLOW_API NvFlowGridExport* NvFlowGridImportGetGridExport(NvFlowGridImport* gridImport, NvFlowContext* context);

struct NvFlowGridImportStateCPU;

struct NvFlowGridImportStateCPUParams
{
    NvFlowGridImportStateCPU* stateCPU;     
    NvFlowGridTextureChannel channel;       
    NvFlowGridImportMode importMode;        
};

NV_FLOW_API NvFlowGridImportStateCPU* NvFlowCreateGridImportStateCPU(NvFlowGridImport* gridImport);

NV_FLOW_API void NvFlowReleaseGridImportStateCPU(NvFlowGridImportStateCPU* stateCPU);

NV_FLOW_API void NvFlowGridImportUpdateStateCPU(NvFlowGridImportStateCPU* stateCPU, NvFlowContext* context, NvFlowGridExport* gridExport);

NV_FLOW_API NvFlowGridImportHandle NvFlowGridImportStateCPUGetHandle(NvFlowGridImport* gridImport, NvFlowContext* context, const NvFlowGridImportStateCPUParams* params);

// -------------------------- NvFlowGridSummary -------------------------------

struct NvFlowGridSummary;

struct NvFlowGridSummaryDesc
{
    NvFlowGridExport* gridExport;       
};

NV_FLOW_API NvFlowGridSummary* NvFlowCreateGridSummary(NvFlowContext* context, const NvFlowGridSummaryDesc* desc);

NV_FLOW_API void NvFlowReleaseGridSummary(NvFlowGridSummary* gridSummary);

struct NvFlowGridSummaryStateCPU;

NV_FLOW_API NvFlowGridSummaryStateCPU* NvFlowCreateGridSummaryStateCPU(NvFlowGridSummary* gridSummary);

NV_FLOW_API void NvFlowReleaseGridSummaryStateCPU(NvFlowGridSummaryStateCPU* stateCPU);

struct NvFlowGridSummaryUpdateParams
{
    NvFlowGridSummaryStateCPU* stateCPU;    

    NvFlowGridExport* gridExport;       
};

NV_FLOW_API void NvFlowGridSummaryUpdate(NvFlowGridSummary* gridSummary, NvFlowContext* context, const NvFlowGridSummaryUpdateParams* params);

struct NvFlowGridSummaryDebugRenderParams
{
    NvFlowGridSummaryStateCPU* stateCPU;

    NvFlowRenderTargetView* renderTargetView;   

    NvFlowFloat4x4 projectionMatrix;            
    NvFlowFloat4x4 viewMatrix;                  
};

NV_FLOW_API void NvFlowGridSummaryDebugRender(NvFlowGridSummary* gridSummary, NvFlowContext* context, const NvFlowGridSummaryDebugRenderParams* params);

struct NvFlowGridSummaryResult
{
    NvFlowFloat4 worldLocation;
    NvFlowFloat4 worldHalfSize;
    NvFlowFloat3 averageVelocity;
    float averageSpeed;
    float averageTemperature;
    float averageFuel;
    float averageBurn;
    float averageSmoke;
};

NV_FLOW_API NvFlowUint NvFlowGridSummaryGetNumLayers(NvFlowGridSummaryStateCPU* stateCPU);

NV_FLOW_API NvFlowGridMaterialHandle NvFlowGridSummaryGetLayerMaterial(NvFlowGridSummaryStateCPU* stateCPU, NvFlowUint layerIdx);

NV_FLOW_API void NvFlowGridSummaryGetSummaries(NvFlowGridSummaryStateCPU* stateCPU, NvFlowGridSummaryResult** results, NvFlowUint* numResults, NvFlowUint layerIdx);

// -------------------------- NvFlowRenderMaterial -------------------------------

struct NvFlowRenderMaterialPool;

struct NvFlowRenderMaterialPoolDesc
{
    NvFlowUint colorMapResolution;      
};

NV_FLOW_API NvFlowRenderMaterialPool* NvFlowCreateRenderMaterialPool(NvFlowContext* context, const NvFlowRenderMaterialPoolDesc* desc);

NV_FLOW_API void NvFlowReleaseRenderMaterialPool(NvFlowRenderMaterialPool* pool);

struct NvFlowRenderMaterialHandle
{
    NvFlowRenderMaterialPool* pool;         
    NvFlowUint64 uid;                       
};

enum NvFlowVolumeRenderMode
{
    eNvFlowVolumeRenderMode_colormap = 0,       
    eNvFlowVolumeRenderMode_raw = 1,            
    eNvFlowVolumeRenderMode_rainbow = 2,        
    eNvFlowVolumeRenderMode_debug = 3,          

    eNvFlowVolumeRenderModeCount
};

struct NvFlowRenderMaterialParams
{
    NvFlowGridMaterialHandle material;          

    float alphaScale;                           
    float additiveFactor;                       

    NvFlowFloat4 colorMapCompMask;              
    NvFlowFloat4 alphaCompMask;                 
    NvFlowFloat4 intensityCompMask;             

    float colorMapMinX;                         
    float colorMapMaxX;                         
    float alphaBias;                            
    float intensityBias;                        
};

NV_FLOW_API void NvFlowRenderMaterialParamsDefaults(NvFlowRenderMaterialParams* params);

NV_FLOW_API NvFlowRenderMaterialHandle NvFlowGetDefaultRenderMaterial(NvFlowRenderMaterialPool* pool);

NV_FLOW_API NvFlowRenderMaterialHandle NvFlowCreateRenderMaterial(NvFlowContext* context, NvFlowRenderMaterialPool* pool, const NvFlowRenderMaterialParams* params);

NV_FLOW_API void NvFlowReleaseRenderMaterial(NvFlowRenderMaterialHandle handle);

NV_FLOW_API void NvFlowRenderMaterialUpdate(NvFlowRenderMaterialHandle handle, const NvFlowRenderMaterialParams* params);

struct NvFlowColorMapData
{
    NvFlowFloat4* data;         
    NvFlowUint dim;             
};

NV_FLOW_API NvFlowColorMapData NvFlowRenderMaterialColorMap(NvFlowContext* context, NvFlowRenderMaterialHandle handle);

NV_FLOW_API void NvFlowRenderMaterialColorUnmap(NvFlowContext* context, NvFlowRenderMaterialHandle handle);

// -------------------------- NvFlowVolumeRender -------------------------------

struct NvFlowVolumeRender;

struct NvFlowVolumeRenderDesc
{
    NvFlowGridExport* gridExport;               
};

NV_FLOW_API NvFlowVolumeRender* NvFlowCreateVolumeRender(NvFlowContext* context, const NvFlowVolumeRenderDesc* desc);

NV_FLOW_API void NvFlowReleaseVolumeRender(NvFlowVolumeRender* volumeRender);

enum NvFlowVolumeRenderDownsample
{
    eNvFlowVolumeRenderDownsampleNone = 0,
    eNvFlowVolumeRenderDownsample2x2 = 1
};

enum NvFlowMultiResRayMarch
{
    eNvFlowMultiResRayMarchDisabled = 0,
    eNvFlowMultiResRayMarch2x2 = 1,
    eNvFlowMultiResRayMarch4x4 = 2,
    eNvFlowMultiResRayMarch8x8 = 3,
    eNvFlowMultiResRayMarch16x16 = 4,
};

struct NvFlowVolumeRenderViewport
{
    float topLeftX;
    float topLeftY;
    float width;
    float height;
};

struct NvFlowVolumeRenderMultiResParams
{
    bool enabled;                           
    float centerWidth;                      
    float centerHeight;                     
    float centerX;                          
    float centerY;                          
    float densityScaleX[3];                 
    float densityScaleY[3];                 
    NvFlowVolumeRenderViewport viewport;    
    float nonMultiResWidth;                 
    float nonMultiResHeight;                
};

struct NvFlowVolumeRenderLMSParams
{
    bool enabled;                           
    float warpLeft;                         
    float warpRight;
    float warpUp;
    float warpDown;
    float sizeLeft;
    float sizeRight;
    float sizeUp;
    float sizeDown;
    NvFlowVolumeRenderViewport viewport;    
    float nonLMSWidth;                      
    float nonLMSHeight;                     
};

struct NvFlowVolumeRenderParams
{
    NvFlowFloat4x4 projectionMatrix;            
    NvFlowFloat4x4 viewMatrix;                  
    NvFlowFloat4x4 modelMatrix;                 

    NvFlowDepthStencilView* depthStencilView;   
    NvFlowRenderTargetView* renderTargetView;   

    NvFlowRenderMaterialPool* materialPool;     

    NvFlowVolumeRenderMode renderMode;          
    NvFlowGridTextureChannel renderChannel;     

    bool debugMode;                             

    NvFlowVolumeRenderDownsample downsampleFactor;  
    float screenPercentage;                         
    NvFlowMultiResRayMarch multiResRayMarch;        
    float multiResSamplingScale;                    

    bool smoothColorUpsample;                       

    bool preColorCompositeOnly;                     
    bool colorCompositeOnly;                        
    bool generateDepth;                             
    bool generateDepthDebugMode;                    
    float depthAlphaThreshold;                      
    float depthIntensityThreshold;                  

    NvFlowVolumeRenderMultiResParams multiRes;          

    NvFlowVolumeRenderLMSParams lensMatchedShading;     
};

NV_FLOW_API void NvFlowVolumeRenderParamsDefaults(NvFlowVolumeRenderParams* params);

struct NvFlowVolumeLightingParams
{
    NvFlowRenderMaterialPool* materialPool;     

    NvFlowVolumeRenderMode renderMode;          
    NvFlowGridTextureChannel renderChannel;     
};

NV_FLOW_API NvFlowGridExport* NvFlowVolumeRenderLightGridExport(NvFlowVolumeRender* volumeRender, NvFlowContext* context, NvFlowGridExport* gridExport, const NvFlowVolumeLightingParams* params);

NV_FLOW_API void NvFlowVolumeRenderGridExport(NvFlowVolumeRender* volumeRender, NvFlowContext* context, NvFlowGridExport* gridExport, const NvFlowVolumeRenderParams* params);

NV_FLOW_API void NvFlowVolumeRenderTexture3D(NvFlowVolumeRender* volumeRender, NvFlowContext* context, NvFlowTexture3D* density, const NvFlowVolumeRenderParams* params);

// -------------------------- NvFlowVolumeShadow -------------------------------

struct NvFlowVolumeShadow;

struct NvFlowVolumeShadowDesc
{
    NvFlowGridExport* gridExport;       

    NvFlowUint mapWidth;                
    NvFlowUint mapHeight;               
    NvFlowUint mapDepth;                

    float minResidentScale;             
    float maxResidentScale;             
};

struct NvFlowVolumeShadowParams
{
    NvFlowFloat4x4 projectionMatrix;            
    NvFlowFloat4x4 viewMatrix;                  

    NvFlowRenderMaterialPool* materialPool;     

    NvFlowVolumeRenderMode renderMode;          
    NvFlowGridTextureChannel renderChannel;     

    float intensityScale;                       
    float minIntensity;                         

    NvFlowFloat4 shadowBlendCompMask;           
    float shadowBlendBias;                      
};

struct NvFlowVolumeShadowDebugRenderParams
{
    NvFlowRenderTargetView* renderTargetView;   

    NvFlowFloat4x4 projectionMatrix;            
    NvFlowFloat4x4 viewMatrix;                  
};

struct NvFlowVolumeShadowStats
{
    NvFlowUint shadowColumnsActive;
    NvFlowUint shadowBlocksActive;
    NvFlowUint shadowCellsActive;
};

NV_FLOW_API NvFlowVolumeShadow* NvFlowCreateVolumeShadow(NvFlowContext* context, const NvFlowVolumeShadowDesc* desc);

NV_FLOW_API void NvFlowReleaseVolumeShadow(NvFlowVolumeShadow* volumeShadow);

NV_FLOW_API void NvFlowVolumeShadowUpdate(NvFlowVolumeShadow* volumeShadow, NvFlowContext* context, NvFlowGridExport* gridExport, const NvFlowVolumeShadowParams* params);

NV_FLOW_API NvFlowGridExport* NvFlowVolumeShadowGetGridExport(NvFlowVolumeShadow* volumeShadow, NvFlowContext* context);

NV_FLOW_API void NvFlowVolumeShadowDebugRender(NvFlowVolumeShadow* volumeShadow, NvFlowContext* context, const NvFlowVolumeShadowDebugRenderParams* params);

NV_FLOW_API void NvFlowVolumeShadowGetStats(NvFlowVolumeShadow* volumeShadow, NvFlowVolumeShadowStats* stats);

// -------------------------- NvFlowCrossSection -------------------------------

struct NvFlowCrossSection;

struct NvFlowCrossSectionDesc
{
    NvFlowGridExport* gridExport;       
};

struct NvFlowCrossSectionParams
{
    NvFlowGridExport* gridExport;               
    NvFlowGridExport* gridExportDebugVis;       

    NvFlowFloat4x4 projectionMatrix;            
    NvFlowFloat4x4 viewMatrix;                  

    NvFlowDepthStencilView* depthStencilView;   
    NvFlowRenderTargetView* renderTargetView;   

    NvFlowRenderMaterialPool* materialPool;     

    NvFlowVolumeRenderMode renderMode;          
    NvFlowGridTextureChannel renderChannel;     

    NvFlowUint crossSectionAxis;                
    NvFlowFloat3 crossSectionPosition;          
    float crossSectionScale;                    

    float intensityScale;                       

    bool pointFilter;                           

    bool velocityVectors;                       
    float velocityScale;                        
    float vectorLengthScale;                    

    bool outlineCells;                          

    bool fullscreen;                            

    NvFlowFloat4 lineColor;                     
    NvFlowFloat4 backgroundColor;               
    NvFlowFloat4 cellColor;                     
};

NV_FLOW_API void NvFlowCrossSectionParamsDefaults(NvFlowCrossSectionParams* params);

NV_FLOW_API NvFlowCrossSection* NvFlowCreateCrossSection(NvFlowContext* context, const NvFlowCrossSectionDesc* desc);

NV_FLOW_API void NvFlowReleaseCrossSection(NvFlowCrossSection* crossSection);

NV_FLOW_API void NvFlowCrossSectionRender(NvFlowCrossSection* crossSection, NvFlowContext* context, const NvFlowCrossSectionParams* params);

// -------------------------- NvFlowGridProxy -------------------------------

struct NvFlowGridProxy;

enum NvFlowGridProxyType
{
    eNvFlowGridProxyTypePassThrough = 0,    
    eNvFlowGridProxyTypeMultiGPU = 1,       
    eNvFlowGridProxyTypeInterQueue = 2,     
};

struct NvFlowGridProxyDesc
{
    NvFlowContext* gridContext;         
    NvFlowContext* renderContext;       
    NvFlowContext* gridCopyContext;     
    NvFlowContext* renderCopyContext;   

    NvFlowGridExport* gridExport;       

    NvFlowGridProxyType proxyType;      
};

struct NvFlowGridProxyFlushParams
{
    NvFlowContext* gridContext;         
    NvFlowContext* gridCopyContext;     
    NvFlowContext* renderCopyContext;   
};

NV_FLOW_API NvFlowGridProxy* NvFlowCreateGridProxy(const NvFlowGridProxyDesc* desc);

NV_FLOW_API void NvFlowReleaseGridProxy(NvFlowGridProxy* proxy);

NV_FLOW_API void NvFlowGridProxyPush(NvFlowGridProxy* proxy, NvFlowGridExport* gridExport, const NvFlowGridProxyFlushParams* params);

NV_FLOW_API void NvFlowGridProxyFlush(NvFlowGridProxy* proxy, const NvFlowGridProxyFlushParams* params);

NV_FLOW_API NvFlowGridExport* NvFlowGridProxyGetGridExport(NvFlowGridProxy* proxy, NvFlowContext* renderContext);

// -------------------------- NvFlowDevice -------------------------------

struct NvFlowDevice;

enum NvFlowDeviceMode
{
    eNvFlowDeviceModeProxy = 0,     
    eNvFlowDeviceModeUnique = 1,    
};

struct NvFlowDeviceDesc
{
    NvFlowDeviceMode mode;          
    bool autoSelectDevice;          
    NvFlowUint adapterIdx;          
};

NV_FLOW_API void NvFlowDeviceDescDefaults(NvFlowDeviceDesc* desc);

NV_FLOW_API bool NvFlowDedicatedDeviceAvailable(NvFlowContext* renderContext);

NV_FLOW_API bool NvFlowDedicatedDeviceQueueAvailable(NvFlowContext* renderContext);

NV_FLOW_API NvFlowDevice* NvFlowCreateDevice(NvFlowContext* renderContext, const NvFlowDeviceDesc* desc);

NV_FLOW_API void NvFlowReleaseDevice(NvFlowDevice* device);

struct NvFlowDeviceQueue;

enum NvFlowDeviceQueueType
{
    eNvFlowDeviceQueueTypeGraphics = 0,
    eNvFlowDeviceQueueTypeCompute = 1,
    eNvFlowDeviceQueueTypeCopy = 2
};

struct NvFlowDeviceQueueDesc
{
    NvFlowDeviceQueueType queueType;
    bool lowLatency;
};

struct NvFlowDeviceQueueStatus
{
    NvFlowUint framesInFlight;          
    NvFlowUint64 lastFenceCompleted;    
    NvFlowUint64 nextFenceValue;        
};

NV_FLOW_API NvFlowDeviceQueue* NvFlowCreateDeviceQueue(NvFlowDevice* device, const NvFlowDeviceQueueDesc* desc);

NV_FLOW_API void NvFlowReleaseDeviceQueue(NvFlowDeviceQueue* deviceQueue);

NV_FLOW_API NvFlowContext* NvFlowDeviceQueueCreateContext(NvFlowDeviceQueue* deviceQueue);

NV_FLOW_API void NvFlowDeviceQueueUpdateContext(NvFlowDeviceQueue* deviceQueue, NvFlowContext* context, NvFlowDeviceQueueStatus* status);

NV_FLOW_API void NvFlowDeviceQueueFlush(NvFlowDeviceQueue* deviceQueue, NvFlowContext* context);

NV_FLOW_API void NvFlowDeviceQueueConditionalFlush(NvFlowDeviceQueue* deviceQueue, NvFlowContext* context);

NV_FLOW_API void NvFlowDeviceQueueWaitOnFence(NvFlowDeviceQueue* deviceQueue, NvFlowContext* context, NvFlowUint64 fenceValue);

// -------------------------- NvFlowSDFGenerator -------------------------------

struct NvFlowSDFGen;

struct NvFlowSDFGenDesc
{
    NvFlowDim resolution;       
};

struct NvFlowSDFGenMeshParams
{
    NvFlowUint numVertices;         
    float* positions;               
    NvFlowUint positionStride;      
    float* normals;                 
    NvFlowUint normalStride;        

    NvFlowUint numIndices;          
    NvFlowUint* indices;            

    NvFlowFloat4x4 modelMatrix;     

    NvFlowDepthStencilView* depthStencilView;   
    NvFlowRenderTargetView* renderTargetView;   
};

NV_FLOW_API NvFlowSDFGen* NvFlowCreateSDFGen(NvFlowContext* context, const NvFlowSDFGenDesc* desc);

NV_FLOW_API void NvFlowReleaseSDFGen(NvFlowSDFGen* sdfGen);

NV_FLOW_API void NvFlowSDFGenReset(NvFlowSDFGen* sdfGen, NvFlowContext* context);

NV_FLOW_API void NvFlowSDFGenVoxelize(NvFlowSDFGen* sdfGen, NvFlowContext* context, const NvFlowSDFGenMeshParams* params);

NV_FLOW_API void NvFlowSDFGenUpdate(NvFlowSDFGen* sdfGen, NvFlowContext* context);

NV_FLOW_API NvFlowTexture3D* NvFlowSDFGenShape(NvFlowSDFGen* sdfGen, NvFlowContext* context);

// -------------------------- NvFlowParticleSurface -------------------------------

struct NvFlowParticleSurface;

struct NvFlowParticleSurfaceDesc
{
    NvFlowFloat3 initialLocation;       
    NvFlowFloat3 halfSize;              

    NvFlowDim virtualDim;               
    float residentScale;                

    NvFlowUint maxParticles;            
};

struct NvFlowParticleSurfaceData
{
    const float* positions;         
    NvFlowUint positionStride;      
    NvFlowUint numParticles;        
};

struct NvFlowParticleSurfaceParams
{
    float surfaceThreshold;         
    float smoothRadius;             
    bool separableSmoothing;        
};

struct NvFlowParticleSurfaceEmitParams
{
    float deltaTime;

    NvFlowFloat3 velocityLinear;                    
    NvFlowFloat3 velocityCoupleRate;                

    float smoke;                                    
    float smokeCoupleRate;                          

    float temperature;                              
    float temperatureCoupleRate;                    

    float fuel;                                     
    float fuelCoupleRate;                           
};

NV_FLOW_API NvFlowParticleSurface* NvFlowCreateParticleSurface(NvFlowContext* context, const NvFlowParticleSurfaceDesc* desc);

NV_FLOW_API void NvFlowReleaseParticleSurface(NvFlowParticleSurface* surface);

NV_FLOW_API void NvFlowParticleSurfaceUpdateParticles(NvFlowParticleSurface* surface, NvFlowContext* context, const NvFlowParticleSurfaceData* data);

NV_FLOW_API void NvFlowParticleSurfaceUpdateSurface(NvFlowParticleSurface* surface, NvFlowContext* context, const NvFlowParticleSurfaceParams* params);

NV_FLOW_API void NvFlowParticleSurfaceAllocFunc(NvFlowParticleSurface* surface, NvFlowContext* context, const NvFlowGridEmitCustomAllocParams* params);

NV_FLOW_API void NvFlowParticleSurfaceEmitVelocityFunc(NvFlowParticleSurface* surface, NvFlowContext* context, NvFlowUint* dataFrontIdx, const NvFlowGridEmitCustomEmitParams* params, const NvFlowParticleSurfaceEmitParams* emitParams);

NV_FLOW_API void NvFlowParticleSurfaceEmitDensityFunc(NvFlowParticleSurface* surface, NvFlowContext* context, NvFlowUint* dataFrontIdx, const NvFlowGridEmitCustomEmitParams* params, const NvFlowParticleSurfaceEmitParams* emitParams);

NV_FLOW_API NvFlowGridExport* NvFlowParticleSurfaceDebugGridExport(NvFlowParticleSurface* surface, NvFlowContext* context);

Copyright © 2014-2016 NVIDIA Corporation, 2701 San Tomas Expressway, Santa Clara, CA 95050 U.S.A. All rights reserved. www.nvidia.com