Helper.h

Go to the documentation of this file.

#pragma once
#include <xgl/Color.h>
#include <xgl/Dynamic.h>
#include <xgl/ShaderProgram.h>
#include <xgl/VertexArrayBase.h>
#include <xgl/global.h>
 
namespace sf::xgl
{
 
class _XGL_CLASS Helper
{
  public:
    typedef Matrix44::value_type value_type;
 
    explicit Helper(ShaderProgram* sp);
 
    explicit Helper(Dynamic* dynamic = nullptr);
 
    void setFlags(bool solid, bool paint = false);
 
    void setCameraAndModelMatrix(const QMatrix4x4& camera, const QMatrix4x4& model);
 
    bool isSolid() const;
 
    bool isPainting() const;
 
    void pushMatrix();
 
    void popMatrix();
 
    void pushCulling(CullingState state);
 
    void popCulling();
 
    Matrix44& matrix();
 
    void translate(value_type x, value_type y, value_type z);
 
    void rotate(value_type angle, value_type x, value_type y, value_type z);
 
    void setColor(const Color& color);
 
    void setColor(const QColor& color);
 
    void setColor(float r, float g, float b, float a);
 
    void setLineWidth(float width = 1.0f);
 
    void render(VertexArrayBase* object, bool is_model = true);
 
    void render(const std::function<void()>& callback, bool is_model = true);
 
    void beginMode(GLenum mode);
    void endMode();
    void setNormal(double x, double y, double z);
    void setVertex(double x, double y, double z);
    void setVertex(Vector3D vec);
    void setTexCoord(double x, double y);
    void drawSphere(double radius, int slices, int stacks);
    void drawDisk(double innerRadius, double outerRadius, int slices, int loops);
    void drawCylinder(double baseRadius, double topRadius, double height, int slices, int stacks);
    void drawPlaneLines(const Vector3D& a, const Vector3D& b, const Vector3D&, const Vector3D& d, int w_lines, int h_lines);
 
    ShaderProgram* shaderProgram();
 
  private:
    ShaderProgram* _shaderProgram;
    Matrix44 _matrix;
    Matrix44 _cameraMatrix;
    Matrix44 _modelMatrix;
    Color _color;
    vector3f _normal{0.0f, 0.0f, 0.0f};
    std::stack<Matrix44> _matrixStack;
    std::stack<CullingState> _cullingStack;
    bool _flagPaint{false};
    bool _flagSolid{false};
    CullingState _cullingState{cfDisabled};
 
    Dynamic* _dynamic{nullptr};
};
 
class _XGL_CLASS ScopedMatrix
{
  public:
    explicit ScopedMatrix(Helper& helper);
 
    ~ScopedMatrix();
 
  private:
    Helper& _helper;
};
 
class _XGL_FUNC ScopedCulling
{
  public:
    explicit ScopedCulling(Helper& helper, CullingState state = {cfEnabled | cfCCW | cfBackside});
 
    ~ScopedCulling();
 
  private:
    Helper& _helper;
};
 
}// namespace sf::xgl
 
// Include all inlined functions and template implementations.
#include <xgl/Helper.hpp>