RayMarchingShader.h

Go to the documentation of this file.

#include <Corrade/Utility/Resource.h>
#include <Magnum/GL/AbstractShaderProgram.h>
#include <Magnum/GL/Shader.h>
#include <Magnum/GL/Texture.h>
#include <Magnum/GL/Version.h>
 
using namespace Magnum;
 
class RayMarchingShader : public GL::AbstractShaderProgram {
public:
    RayMarchingShader() {
        Utility::Resource rs("data");
 
        GL::Shader vertShader{GL::Version::GL460, GL::Shader::Type::Vertex};
        GL::Shader fragShader{GL::Version::GL460, GL::Shader::Type::Fragment};
        vertShader.addSource(rs.getString("RayMarchingShader.vert"));
        fragShader.addSource(rs.getString("RayMarchingShader.frag"));
 
        CORRADE_INTERNAL_ASSERT_OUTPUT(vertShader.compile() && fragShader.compile());
        this->attachShaders({vertShader, fragShader});
        CORRADE_INTERNAL_ASSERT(this->link());
 
        this->viewportSizeUniform = this->uniformLocation("viewportSize");
        this->viewMatrixUniform = this->uniformLocation("viewMatrix");
        this->projectionMatrixUniform = this->uniformLocation("projectionMatrix");
        this->cameraPositionUniform = this->uniformLocation("cameraPosition");
        this->sdfSizeUniform = this->uniformLocation("sdfSize");
        this->surfaceRenderingModeUniform = this->uniformLocation("surfaceRenderingMode");
        this->displayModeUniform = this->uniformLocation("displayMode");
        this->dmaxUniform = this->uniformLocation("dmax");
        this->reflectionCountUniform = this->uniformLocation("reflectionCount");
        this->SSSUniform = this->uniformLocation("enableSubsurfaceScattering");
        this->surfaceColorUniform = this->uniformLocation("surfaceColor");
        this->SSSModeUniform = this->uniformLocation("sssMode");
        this->subSurfaceColorUniform = this->uniformLocation("subSurfaceColor");
        this->subSurfaceStrengthUniform = this->uniformLocation("subSurfaceStrength");
    }
 
    void RayMarchingShader::bindSdf(GL::Texture3D& texture) {
        texture.bind(SDFTextureUnit);
    }
 
    void RayMarchingShader::bindStructure(GL::Texture2D& texture) {
        texture.bind(StructureTextureUnit);
    }
 
    void RayMarchingShader::bindStructurePos(GL::Texture2D& texture) {
        texture.bind(StructurePosTextureUnit);
    }
 
    void RayMarchingShader::bindStructureMask(GL::Texture2D& texture) {
        texture.bind(StructureMaskTextureUnit);
    }
 
    void RayMarchingShader::setViewportSize(const Vector2ui& viewportSize) {
        this->setUniform(this->viewportSizeUniform, viewportSize);
    }
 
    void RayMarchingShader::setProjectionMatrix(const Matrix4 &matrix) {
        this->setUniform(this->projectionMatrixUniform, matrix);
    }
 
    void RayMarchingShader::setViewMatrix(const Matrix4 &matrix) {
        this->setUniform(this->viewMatrixUniform, matrix);
    }
 
    void RayMarchingShader::setCameraPosition(const Vector3 &position) {
        this->setUniform(this->cameraPositionUniform, position);
    }
 
    void RayMarchingShader::setSdfSize(const Vector3 &size) {
        this->setUniform(this->sdfSizeUniform, size);
    }
 
    void RayMarchingShader::setSurfaceRenderingMode(const UnsignedInt& mode) {
        this->setUniform(this->surfaceRenderingModeUniform, mode);
    }
 
    void RayMarchingShader::setDisplayMode(const UnsignedInt& mode) {
        this->setUniform(this->displayModeUniform, mode);
    }
 
    void RayMarchingShader::setDmax(const float dmax) {
        this->setUniform(this->dmaxUniform, dmax);
    }
 
    void RayMarchingShader::setSSS(const bool SSS) {
        this->setUniform(this->SSSUniform, SSS);
    }
 
    void RayMarchingShader::setSSSMode(const UnsignedInt& mode) {
        this->setUniform(this->SSSModeUniform, mode);
    }
 
    void RayMarchingShader::setReflectionCount(const UnsignedInt& reflectionCount) {
        this->setUniform(this->reflectionCountUniform, reflectionCount);
    }
 
    void RayMarchingShader::setSurfaceColor(const Color3& color) {
        this->setUniform(this->surfaceColorUniform, color);
    }
 
    void RayMarchingShader::setSubSurfaceColor(const Color3& color) {
        this->setUniform(this->subSurfaceColorUniform, color);
    }
 
    void RayMarchingShader::setSubSurfaceStrength(const float strength) {
        this->setUniform(this->subSurfaceStrengthUniform, strength);
    }
 
private:
    enum : Int {
        SDFTextureUnit = 0,
        StructureTextureUnit = 1,
        StructurePosTextureUnit = 2,
        StructureMaskTextureUnit = 3
    };
 
    Int viewportSizeUniform;
    Int viewMatrixUniform;
    Int projectionMatrixUniform;
    Int cameraPositionUniform;
    Int sdfSizeUniform;
    Int surfaceRenderingModeUniform;
    Int displayModeUniform;
    Int dmaxUniform;
    Int SSSUniform;
    Int SSSModeUniform;
    Int reflectionCountUniform;
    Int surfaceColorUniform;
    Int subSurfaceColorUniform;
    Int subSurfaceStrengthUniform;
};