IRenderer.h

Go to the documentation of this file.

#pragma once
 
 
#include "gui/objects/Color.h"
#include "gui/objects/Point.h"
#include "gui/objects/Texture.h"
#include "objects/wrappers/Any.h"
#include "objects/wrappers/Flags.h"
#include "quantities/Particle.h"
#include "thread/ThreadLocal.h"
#include <atomic>
 
NAMESPACE_SPH_BEGIN
 
class ICamera;
struct CameraRay;
class ITracker;
class IColorizer;
class IColorMap;
class FrameBuffer;
class Statistics;
class GuiSettings;
 
enum class TextAlign {
    LEFT = 1 << 0,
    RIGHT = 1 << 1,
    HORIZONTAL_CENTER = 1 << 2,
    TOP = 1 << 3,
    BOTTOM = 1 << 4,
    VERTICAL_CENTER = 1 << 5,
};
 
class IRenderOutput : public Polymorphic {
public:
    struct Label {
        std::wstring text;
        Rgba color;
        int fontSize;
        Flags<TextAlign> align;
        Pixel position;
    };
 
    virtual void update(const Bitmap<Rgba>& bitmap, Array<Label>&& labels, const bool isFinal) = 0;
 
    virtual void update(Bitmap<Rgba>&& bitmap, Array<Label>&& labels, const bool isFinal) = 0;
};
 
 
struct RenderParams {
 
    AutoPtr<ICamera> camera;
 
    AutoPtr<ITracker> tracker;
 
    Rgba background = Rgba::black();
 
    bool showKey = true;
 
    struct {
        float scale = 1.f;
 
        Optional<Size> selected = NOTHING;
 
        bool grayScale = false;
 
        bool doAntialiasing = false;
 
        bool smoothed = false;
 
        bool renderGhosts = true;
 
    } particles;
 
    struct {
 
        float length = 100.f;
 
    } vectors;
 
    struct {
 
        float level = 0.15f;
 
        float ambientLight = 0.3f;
 
        float sunLight = 0.7f;
 
        float emission = 1.f;
 
        float filterWidth = 2.f;
 
    } surface;
 
    struct {
        float emission = 1.f;
 
        float absorption = 0.f;
 
        float compressionFactor = 2.f;
    } volume;
 
    struct {
 
        float isoStep = 30.f;
 
        Size gridSize = 100;
 
        bool showLabels = true;
 
    } contours;
 
    void initialize(const GuiSettings& gui);
};
 
class IRenderer : public Polymorphic {
public:
    virtual void initialize(const Storage& storage, const IColorizer& colorizer, const ICamera& camera) = 0;
 
    virtual bool isInitialized() const = 0;
 
    virtual void render(const RenderParams& params, Statistics& stats, IRenderOutput& output) const = 0;
 
    virtual void cancelRender() = 0;
};
 
class IRaytracer : public IRenderer {
protected:
    SharedPtr<IScheduler> scheduler;
 
    struct ThreadData {
        UniformRng rng;
 
        Any data;
 
        ThreadData(int seed);
    };
 
    mutable ThreadLocal<ThreadData> threadData;
 
    mutable std::atomic_bool shouldContinue;
 
private:
    struct {
 
        AutoPtr<IColorMap> colorMap;
 
        struct {
 
            Rgba color = Rgba::black();
 
            Texture hdri;
 
        } enviro;
 
        Size iterationLimit;
 
        Size subsampling;
 
    } fixed;
 
public:
    IRaytracer(SharedPtr<IScheduler> scheduler, const GuiSettings& gui);
 
    virtual void render(const RenderParams& params, Statistics& stats, IRenderOutput& output) const final;
 
    virtual void cancelRender() override {
        shouldContinue = false;
    }
 
protected:
    virtual Rgba shade(const RenderParams& params, const CameraRay& ray, ThreadData& data) const = 0;
 
    Rgba getEnviroColor(const CameraRay& ray) const;
 
private:
    void refine(const RenderParams& params, const Size iteration, FrameBuffer& fb) const;
};
 
NAMESPACE_SPH_END