mirror of
https://bitbucket.org/mfeemster/fractorium.git
synced 2025-01-21 05:00:06 -05:00
275 lines
12 KiB
C++
275 lines
12 KiB
C++
#pragma once
|
|
|
|
#include "EmberCLPch.h"
|
|
#include "OpenCLWrapper.h"
|
|
#include "DEOpenCLKernelCreator.h"
|
|
#include "FinalAccumOpenCLKernelCreator.h"
|
|
#include "RendererClDevice.h"
|
|
|
|
/// <summary>
|
|
/// RendererCLBase and RendererCL classes.
|
|
/// </summary>
|
|
|
|
namespace EmberCLns
|
|
{
|
|
/// <summary>
|
|
/// Serves only as an interface for OpenCL specific rendering functions.
|
|
/// </summary>
|
|
class EMBERCL_API RendererCLBase
|
|
{
|
|
public:
|
|
virtual ~RendererCLBase() { }
|
|
virtual bool ReadFinal(v4F* pixels) { return false; }
|
|
virtual bool ClearFinal() { return false; }
|
|
virtual bool AnyNvidia() const noexcept { return false; }
|
|
bool OptAffine() const noexcept { return m_OptAffine; }
|
|
void OptAffine(bool optAffine) noexcept { m_OptAffine = optAffine; }
|
|
|
|
std::function<void(void)> m_CompileBegun;
|
|
|
|
protected:
|
|
bool m_OptAffine = false;
|
|
};
|
|
|
|
/// <summary>
|
|
/// RendererCL is a derivation of the basic CPU renderer which
|
|
/// overrides various functions to render on the GPU using OpenCL.
|
|
/// This supports multi-GPU rendering and is done in the following manner:
|
|
/// -When rendering a single image, the iterations will be split between devices in sub batches.
|
|
/// -When animating, a renderer for each device will be created by the calling code,
|
|
/// and the frames will each be rendered by a single device as available.
|
|
/// The synchronization across devices is done through a single atomic counter.
|
|
/// Since this class derives from EmberReport and also contains an
|
|
/// OpenCLWrapper member which also derives from EmberReport, the
|
|
/// reporting functions are overridden to aggregate the errors from
|
|
/// both sources.
|
|
/// Template argument T expected to be float or double.
|
|
/// Template argument bucketT must always be float.
|
|
/// </summary>
|
|
template <typename T, typename bucketT>
|
|
class EMBERCL_API RendererCL : public Renderer<T, bucketT>, public RendererCLBase
|
|
{
|
|
using EmberNs::Renderer<T, bucketT>::RendererBase::Abort;
|
|
using EmberNs::Renderer<T, bucketT>::RendererBase::EarlyClip;
|
|
using EmberNs::Renderer<T, bucketT>::RendererBase::EnterResize;
|
|
using EmberNs::Renderer<T, bucketT>::RendererBase::LeaveResize;
|
|
using EmberNs::Renderer<T, bucketT>::RendererBase::FinalRasW;
|
|
using EmberNs::Renderer<T, bucketT>::RendererBase::FinalRasH;
|
|
using EmberNs::Renderer<T, bucketT>::RendererBase::SuperRasW;
|
|
using EmberNs::Renderer<T, bucketT>::RendererBase::SuperRasH;
|
|
using EmberNs::Renderer<T, bucketT>::RendererBase::SuperSize;
|
|
using EmberNs::Renderer<T, bucketT>::RendererBase::BytesPerChannel;
|
|
using EmberNs::Renderer<T, bucketT>::RendererBase::TemporalSamples;
|
|
using EmberNs::Renderer<T, bucketT>::RendererBase::ItersPerTemporalSample;
|
|
using EmberNs::Renderer<T, bucketT>::RendererBase::FuseCount;
|
|
using EmberNs::Renderer<T, bucketT>::RendererBase::DensityFilterOffset;
|
|
using EmberNs::Renderer<T, bucketT>::RendererBase::PrepFinalAccumVector;
|
|
using EmberNs::Renderer<T, bucketT>::RendererBase::Paused;
|
|
using EmberNs::Renderer<T, bucketT>::RendererBase::m_ProgressParameter;
|
|
using EmberNs::Renderer<T, bucketT>::RendererBase::m_YAxisUp;
|
|
using EmberNs::Renderer<T, bucketT>::RendererBase::m_LockAccum;
|
|
using EmberNs::Renderer<T, bucketT>::RendererBase::m_Abort;
|
|
using EmberNs::Renderer<T, bucketT>::RendererBase::m_LastIter;
|
|
using EmberNs::Renderer<T, bucketT>::RendererBase::m_LastIterPercent;
|
|
using EmberNs::Renderer<T, bucketT>::RendererBase::m_Stats;
|
|
using EmberNs::Renderer<T, bucketT>::RendererBase::m_Callback;
|
|
using EmberNs::Renderer<T, bucketT>::RendererBase::m_Rand;
|
|
using EmberNs::Renderer<T, bucketT>::RendererBase::m_RenderTimer;
|
|
using EmberNs::Renderer<T, bucketT>::RendererBase::m_IterTimer;
|
|
using EmberNs::Renderer<T, bucketT>::RendererBase::m_ProgressTimer;
|
|
using EmberNs::Renderer<T, bucketT>::RendererBase::EmberReport::AddToReport;
|
|
using EmberNs::Renderer<T, bucketT>::RendererBase::m_ResizeCs;
|
|
using EmberNs::Renderer<T, bucketT>::RendererBase::m_ProcessAction;
|
|
using EmberNs::Renderer<T, bucketT>::m_RotMat;
|
|
using EmberNs::Renderer<T, bucketT>::m_Ember;
|
|
using EmberNs::Renderer<T, bucketT>::m_Csa;
|
|
using EmberNs::Renderer<T, bucketT>::m_CurvesSet;
|
|
using EmberNs::Renderer<T, bucketT>::CenterX;
|
|
using EmberNs::Renderer<T, bucketT>::CenterY;
|
|
using EmberNs::Renderer<T, bucketT>::K1;
|
|
using EmberNs::Renderer<T, bucketT>::K2;
|
|
using EmberNs::Renderer<T, bucketT>::Supersample;
|
|
using EmberNs::Renderer<T, bucketT>::HighlightPower;
|
|
using EmberNs::Renderer<T, bucketT>::HistBuckets;
|
|
using EmberNs::Renderer<T, bucketT>::AccumulatorBuckets;
|
|
using EmberNs::Renderer<T, bucketT>::GetDensityFilter;
|
|
using EmberNs::Renderer<T, bucketT>::GetSpatialFilter;
|
|
using EmberNs::Renderer<T, bucketT>::CoordMap;
|
|
using EmberNs::Renderer<T, bucketT>::XformDistributions;
|
|
using EmberNs::Renderer<T, bucketT>::XformDistributionsSize;
|
|
using EmberNs::Renderer<T, bucketT>::m_Dmap;
|
|
using EmberNs::Renderer<T, bucketT>::m_DensityFilter;
|
|
using EmberNs::Renderer<T, bucketT>::m_SpatialFilter;
|
|
|
|
public:
|
|
RendererCL(const vector<pair<size_t, size_t>>& devices, bool shared = false, GLuint outputTexID = 0);
|
|
RendererCL(const RendererCL<T, bucketT>& renderer) = delete;
|
|
RendererCL<T, bucketT>& operator = (const RendererCL<T, bucketT>& renderer) = delete;
|
|
virtual ~RendererCL() = default;
|
|
|
|
//Non-virtual member functions for OpenCL specific tasks.
|
|
bool Init(const vector<pair<size_t, size_t>>& devices, bool shared, GLuint outputTexID);
|
|
bool SetOutputTexture(GLuint outputTexID);
|
|
|
|
//Iters per kernel/block/grid.
|
|
inline size_t IterCountPerKernel() const noexcept;
|
|
inline size_t IterCountPerBlock() const noexcept;
|
|
inline size_t IterCountPerGrid() const noexcept;
|
|
|
|
//Kernels per block.
|
|
inline size_t IterBlockKernelWidth() const noexcept;
|
|
inline size_t IterBlockKernelHeight() const noexcept;
|
|
inline size_t IterBlockKernelCount() const noexcept;
|
|
|
|
//Kernels per grid.
|
|
inline size_t IterGridKernelWidth() const noexcept;
|
|
inline size_t IterGridKernelHeight() const noexcept;
|
|
inline size_t IterGridKernelCount() const noexcept;
|
|
|
|
//Blocks per grid.
|
|
inline size_t IterGridBlockWidth() const noexcept;
|
|
inline size_t IterGridBlockHeight() const noexcept;
|
|
inline size_t IterGridBlockCount() const noexcept;
|
|
|
|
//Allow for changing the number of blocks in each dimension of the grid.
|
|
void IterBlocksWide(size_t w) noexcept;
|
|
void IterBlocksHigh(size_t h) noexcept;
|
|
|
|
bool ReadHist(size_t device);
|
|
bool ReadAccum();
|
|
bool ReadPoints(size_t device, vector<PointCL<T>>& vec);
|
|
bool ClearHist();
|
|
bool ClearHist(size_t device);
|
|
bool ClearAccum();
|
|
bool WritePoints(size_t device, vector<PointCL<T>>& vec);
|
|
#ifdef TEST_CL
|
|
bool WriteRandomPoints(size_t device);
|
|
#endif
|
|
void InitStateVec();
|
|
void SubBatchPercentPerThread(float f);
|
|
float SubBatchPercentPerThread() const;
|
|
const string& IterKernel() const;
|
|
const string& DEKernel() const;
|
|
const string& FinalAccumKernel() const;
|
|
|
|
//Access to underlying OpenCL structures. Use cautiously.
|
|
const vector<unique_ptr<RendererClDevice>>& Devices() const;
|
|
|
|
//Virtual functions overridden from RendererCLBase.
|
|
virtual bool ReadFinal(v4F* pixels);
|
|
virtual bool ClearFinal();
|
|
|
|
//Public virtual functions overridden from Renderer or RendererBase.
|
|
size_t MemoryAvailable() override;
|
|
bool Ok() const override;
|
|
size_t SubBatchSize() const override;
|
|
size_t ThreadCount() const override;
|
|
bool CreateDEFilter(bool& newAlloc) override;
|
|
bool CreateSpatialFilter(bool& newAlloc) override;
|
|
eRendererType RendererType() const override;
|
|
bool Shared() const override;
|
|
void ClearErrorReport() noexcept override;
|
|
string ErrorReportString() override;
|
|
vector<string> ErrorReport() override;
|
|
bool RandVec(vector<QTIsaac<ISAAC_SIZE, ISAAC_INT>>& randVec) override;
|
|
bool AnyNvidia() const noexcept override;
|
|
|
|
#ifndef TEST_CL
|
|
protected:
|
|
#endif
|
|
//Protected virtual functions overridden from Renderer.
|
|
bool Alloc(bool histOnly = false) override;
|
|
bool ResetBuckets(bool resetHist = true, bool resetAccum = true) override;
|
|
eRenderStatus LogScaleDensityFilter(bool forceOutput = false) override;
|
|
eRenderStatus GaussianDensityFilter() override;
|
|
eRenderStatus AccumulatorToFinalImage(vector<v4F>& pixels, size_t finalOffset) override;
|
|
EmberStats Iterate(size_t iterCount, size_t temporalSample) override;
|
|
|
|
#ifndef TEST_CL
|
|
private:
|
|
#endif
|
|
//Private functions for making and running OpenCL programs.
|
|
bool BuildIterProgramForEmber(bool doAccum = true);
|
|
bool RunIter(size_t iterCount, size_t temporalSample, size_t& itersRan);
|
|
eRenderStatus RunLogScaleFilter();
|
|
eRenderStatus RunDensityFilter();
|
|
eRenderStatus RunFinalAccum();
|
|
bool ClearBuffer(size_t device, const string& bufferName, uint width, uint height, uint elementSize);
|
|
bool RunDensityFilterPrivate(size_t kernelIndex, size_t gridW, size_t gridH, size_t blockW, size_t blockH, uint chunkSizeW, uint chunkSizeH, uint colChunkPass, uint rowChunkPass);
|
|
int MakeAndGetDensityFilterProgram(size_t ss, uint filterWidth);
|
|
int MakeAndGetFinalAccumProgram();
|
|
int MakeAndGetGammaCorrectionProgram();
|
|
bool CreateHostBuffer();
|
|
bool SumDeviceHist();
|
|
void FillSeeds();
|
|
|
|
//Private functions passing data to OpenCL programs.
|
|
void ConvertDensityFilter();
|
|
void ConvertSpatialFilter();
|
|
void ConvertEmber(Ember<T>& ember, EmberCL<T>& emberCL, vector<XformCL<T>>& xformsCL);
|
|
void ConvertCarToRas(const CarToRas<T>& carToRas);
|
|
std::string ErrorStr(const std::string& loc, const std::string& error, RendererClDevice* dev);
|
|
bool m_Init = false;
|
|
bool m_Shared = false;
|
|
bool m_DoublePrecision = typeid(T) == typeid(double);
|
|
float m_SubBatchPercentPerThread = 0.025f;//0.025 * 10,240 gives a default value of 256 iters per thread for the default sub batch size of 10,240 which almost all flames will use.
|
|
//It's critical that these numbers never change. They are
|
|
//based on the cuburn model of each kernel launch containing
|
|
//256 threads. 32 wide by 8 high. Everything done in the OpenCL
|
|
//iteraion kernel depends on these dimensions.
|
|
size_t m_IterCountPerKernel = 256;
|
|
size_t m_IterBlocksWide = 64, m_IterBlockWidth = 32;
|
|
size_t m_IterBlocksHigh = 2, m_IterBlockHeight = 8;
|
|
size_t m_MaxDEBlockSizeW;
|
|
size_t m_MaxDEBlockSizeH;
|
|
|
|
//Buffer names.
|
|
string m_EmberBufferName = "Ember";
|
|
string m_XformsBufferName = "Xforms";
|
|
string m_ParVarsBufferName = "ParVars";
|
|
string m_GlobalSharedBufferName = "GlobalShared";
|
|
string m_SeedsBufferName = "Seeds";
|
|
string m_DistBufferName = "Dist";
|
|
string m_CarToRasBufferName = "CarToRas";
|
|
string m_DEFilterParamsBufferName = "DEFilterParams";
|
|
string m_SpatialFilterParamsBufferName = "SpatialFilterParams";
|
|
string m_DECoefsBufferName = "DECoefs";
|
|
string m_DEWidthsBufferName = "DEWidths";
|
|
string m_DECoefIndicesBufferName = "DECoefIndices";
|
|
string m_SpatialFilterCoefsBufferName = "SpatialFilterCoefs";
|
|
string m_CurvesCsaName = "CurvesCsa";
|
|
string m_HostBufferName = "Host";
|
|
string m_HistBufferName = "Hist";
|
|
string m_AccumBufferName = "Accum";
|
|
string m_FinalImageName = "Final";
|
|
string m_PointsBufferName = "Points";
|
|
#ifdef KNL_USE_GLOBAL_CONSEC
|
|
string m_ConsecBufferName = "Consec";
|
|
#endif
|
|
string m_VarStateBufferName = "VarState";
|
|
|
|
//Kernels.
|
|
string m_IterKernel;
|
|
|
|
cl::ImageFormat m_PaletteFormat;
|
|
cl::ImageFormat m_FinalFormat;
|
|
cl::Image2D m_Palette;
|
|
cl::ImageGL m_AccumImage;
|
|
GLuint m_OutputTexID;
|
|
EmberCL<T> m_EmberCL;
|
|
vector<XformCL<T>> m_XformsCL;
|
|
vector<vector<glm::highp_uvec2>> m_Seeds;
|
|
CarToRasCL<T> m_CarToRasCL;
|
|
DensityFilterCL<bucketT> m_DensityFilterCL;
|
|
SpatialFilterCL<bucketT> m_SpatialFilterCL;
|
|
IterOpenCLKernelCreator<T> m_IterOpenCLKernelCreator;
|
|
DEOpenCLKernelCreator m_DEOpenCLKernelCreator;
|
|
FinalAccumOpenCLKernelCreator m_FinalAccumOpenCLKernelCreator;
|
|
pair<string, vector<T>> m_Params;
|
|
pair<string, vector<T>> m_GlobalShared;
|
|
vector<T> m_VarStates;
|
|
vector<unique_ptr<RendererClDevice>> m_Devices;
|
|
Ember<T> m_LastBuiltEmber;
|
|
};
|
|
}
|