mirror of
https://bitbucket.org/mfeemster/fractorium.git
synced 2025-01-22 05:30:06 -05:00
1dfbd4eff2
-Add new preset dimensions to the right click menu of the width and height fields in the editor. -Change QSS stylesheets to properly handle tabs. -Make tabs rectangular by default. For some reason, they had always been triangular. --Bug fixes -Incremental rendering times in the editor were wrong. --Code changes -Migrate to Qt6. There is probably more work to be done here. -Migrate to VS2022. -Migrate to Wix 4 installer. -Change installer to install to program files for all users. -Fix many VS2022 code analysis warnings. -No longer use byte typedef, because std::byte is now a type. Revert all back to unsigned char. -Upgrade OpenCL headers to version 3.0 and keep locally now rather than trying to look for system files. -No longer link to Nvidia or AMD specific OpenCL libraries. Use the generic installer located at OCL_ROOT too. -Add the ability to change OpenCL grid dimensions. This was attempted for investigating possible performance improvments, but made no difference. This has not been verified on Linux or Mac yet.
275 lines
12 KiB
C++
Executable File
275 lines
12 KiB
C++
Executable File
#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;
|
|
};
|
|
}
|