BigC
/
ArchitectureColoredPainting
4
2
Fork 0
Code Issues 6 Pull Requests Projects Releases 5 Wiki Activity

将Renderer部分放入Renderer命名空间

dev-VirtualTexture
wuyize 2022-11-14 18:31:20 +08:00
parent 4446ef73dd
commit aee5003475
45 changed files with 854 additions and 773 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
ArchitectureColoredPainting/ArchitectureColoredPainting.vcxproj
View File

@ -103,20 +103,21 @@
<ClCompile Include="src\main.cpp" /> <ClCompile Include="src\main.cpp" />
<ClCompile Include="src\MainWindow.cpp" /> <ClCompile Include="src\MainWindow.cpp" />
<ClCompile Include="src\NavigationBarWidget.cpp" /> <ClCompile Include="src\NavigationBarWidget.cpp" />
<ClCompile Include="src\Renderer\BvhTree.cpp" /> <ClCompile Include="src\Renderer\Painting\BvhTree.cpp" />
<ClCompile Include="src\Renderer\Camera.cpp" /> <ClCompile Include="src\Renderer\Camera.cpp" />
<ClCompile Include="src\Renderer\CubicBezier.cpp" /> <ClCompile Include="src\Renderer\Painting\CubicBezier.cpp" />
<ClCompile Include="src\Renderer\CubicMonotonization.cpp" /> <ClCompile Include="src\Renderer\Painting\CubicMonotonization.cpp" />
<ClCompile Include="src\Renderer\Light.cpp" /> <ClCompile Include="src\Renderer\Light.cpp" />
<ClCompile Include="src\Renderer\Line.cpp" /> <ClCompile Include="src\Renderer\Painting\Line.cpp" />
<ClCompile Include="src\Renderer\Mesh.cpp" /> <ClCompile Include="src\Renderer\Mesh.cpp" />
<ClCompile Include="src\Renderer\Model.cpp" /> <ClCompile Include="src\Renderer\Model.cpp" />
<ClCompile Include="src\Renderer\PaintingHelper.cpp" /> <ClCompile Include="src\Renderer\Painting\Painting.cpp" />
<ClCompile Include="src\Renderer\Painting\PaintingHelper.cpp" />
<ClCompile Include="src\Renderer\PaintingMesh.cpp" /> <ClCompile Include="src\Renderer\PaintingMesh.cpp" />
<ClCompile Include="src\Renderer\RendererGLWidget.cpp" /> <ClCompile Include="src\Renderer\RendererGLWidget.cpp" />
<ClCompile Include="src\Renderer\RendererWidget.cpp" /> <ClCompile Include="src\Renderer\RendererWidget.cpp" />
<ClCompile Include="src\Renderer\ShortCutTree.cpp" /> <ClCompile Include="src\Renderer\Painting\ShortCutTree.cpp" />
<ClCompile Include="src\Renderer\StraightLine.cpp" /> <ClCompile Include="src\Renderer\Painting\StraightLine.cpp" />
<ClCompile Include="src\SvgParser.cpp" /> <ClCompile Include="src\SvgParser.cpp" />
<ClCompile Include="src\TitleWidget.cpp" /> <ClCompile Include="src\TitleWidget.cpp" />
<QtRcc Include="MainWindow.qrc" /> <QtRcc Include="MainWindow.qrc" />
@ -148,6 +149,7 @@
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<QtMoc Include="src\MainWindow.h" /> <QtMoc Include="src\MainWindow.h" />
<ClInclude Include="src\Renderer\Painting\Painting.h" />
<ClInclude Include="src\SvgParser.h" /> <ClInclude Include="src\SvgParser.h" />
<QtMoc Include="src\TitleWidget.h" /> <QtMoc Include="src\TitleWidget.h" />
<QtMoc Include="src\IconWidget.h" /> <QtMoc Include="src\IconWidget.h" />
@ -155,19 +157,19 @@
<QtMoc Include="src\NavigationBarWidget.h" /> <QtMoc Include="src\NavigationBarWidget.h" />
<QtMoc Include="src\Renderer\RendererWidget.h" /> <QtMoc Include="src\Renderer\RendererWidget.h" />
<QtMoc Include="src\Editor\EditorWidget.h" /> <QtMoc Include="src\Editor\EditorWidget.h" />
<ClInclude Include="src\Renderer\BvhTree.h" /> <ClInclude Include="src\Renderer\Painting\BvhTree.h" />
<ClInclude Include="src\Renderer\Camera.h" /> <ClInclude Include="src\Renderer\Camera.h" />
<ClInclude Include="src\Renderer\CubicBezier.h" /> <ClInclude Include="src\Renderer\Painting\CubicBezier.h" />
<ClInclude Include="src\Renderer\CubicMonotonization.h" /> <ClInclude Include="src\Renderer\Painting\CubicMonotonization.h" />
<ClInclude Include="src\Renderer\Drawable.h" /> <ClInclude Include="src\Renderer\Drawable.h" />
<ClInclude Include="src\Renderer\Light.h" /> <ClInclude Include="src\Renderer\Light.h" />
<ClInclude Include="src\Renderer\Line.h" /> <ClInclude Include="src\Renderer\Painting\Line.h" />
<ClInclude Include="src\Renderer\Mesh.h" /> <ClInclude Include="src\Renderer\Mesh.h" />
<ClInclude Include="src\Renderer\Model.h" /> <ClInclude Include="src\Renderer\Model.h" />
<ClInclude Include="src\Renderer\PaintingHelper.h" /> <ClInclude Include="src\Renderer\Painting\PaintingHelper.h" />
<ClInclude Include="src\Renderer\PaintingMesh.h" /> <ClInclude Include="src\Renderer\PaintingMesh.h" />
<ClInclude Include="src\Renderer\ShortCutTree.h" /> <ClInclude Include="src\Renderer\Painting\ShortCutTree.h" />
<ClInclude Include="src\Renderer\StraightLine.h" /> <ClInclude Include="src\Renderer\Painting\StraightLine.h" />
<QtMoc Include="src\Renderer\RendererGLWidget.h" /> <QtMoc Include="src\Renderer\RendererGLWidget.h" />
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>

96
ArchitectureColoredPainting/ArchitectureColoredPainting.vcxproj.filters
View File

@ -35,6 +35,12 @@
<Filter Include="Resource Files\Shaders"> <Filter Include="Resource Files\Shaders">
<UniqueIdentifier>{60515177-3da7-420f-8f5b-27c16bb2b77b}</UniqueIdentifier> <UniqueIdentifier>{60515177-3da7-420f-8f5b-27c16bb2b77b}</UniqueIdentifier>
</Filter> </Filter>
<Filter Include="Source Files\Renderer\Painting">
<UniqueIdentifier>{653d1291-0de8-4e0a-855d-7cfc755f7632}</UniqueIdentifier>
</Filter>
<Filter Include="Header Files\Renderer\Painting">
<UniqueIdentifier>{22909273-2b23-49fa-84ab-444cefb09656}</UniqueIdentifier>
</Filter>
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<QtUic Include="MainWindow.ui"> <QtUic Include="MainWindow.ui">
@ -51,45 +57,24 @@
<ClCompile Include="src\Editor\EditorWidget.cpp"> <ClCompile Include="src\Editor\EditorWidget.cpp">
<Filter>Source Files\Editor</Filter> <Filter>Source Files\Editor</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="src\Renderer\BvhTree.cpp">
<Filter>Source Files\Renderer</Filter>
</ClCompile>
<ClCompile Include="src\Renderer\Camera.cpp"> <ClCompile Include="src\Renderer\Camera.cpp">
<Filter>Source Files\Renderer</Filter> <Filter>Source Files\Renderer</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="src\Renderer\CubicBezier.cpp">
<Filter>Source Files\Renderer</Filter>
</ClCompile>
<ClCompile Include="src\Renderer\CubicMonotonization.cpp">
<Filter>Source Files\Renderer</Filter>
</ClCompile>
<ClCompile Include="src\Renderer\Light.cpp"> <ClCompile Include="src\Renderer\Light.cpp">
<Filter>Source Files\Renderer</Filter> <Filter>Source Files\Renderer</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="src\Renderer\Line.cpp">
<Filter>Source Files\Renderer</Filter>
</ClCompile>
<ClCompile Include="src\Renderer\Mesh.cpp"> <ClCompile Include="src\Renderer\Mesh.cpp">
<Filter>Source Files\Renderer</Filter> <Filter>Source Files\Renderer</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="src\Renderer\Model.cpp"> <ClCompile Include="src\Renderer\Model.cpp">
<Filter>Source Files\Renderer</Filter> <Filter>Source Files\Renderer</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="src\Renderer\PaintingHelper.cpp">
<Filter>Source Files\Renderer</Filter>
</ClCompile>
<ClCompile Include="src\Renderer\PaintingMesh.cpp"> <ClCompile Include="src\Renderer\PaintingMesh.cpp">
<Filter>Source Files\Renderer</Filter> <Filter>Source Files\Renderer</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="src\Renderer\RendererGLWidget.cpp"> <ClCompile Include="src\Renderer\RendererGLWidget.cpp">
<Filter>Source Files\Renderer</Filter> <Filter>Source Files\Renderer</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="src\Renderer\ShortCutTree.cpp">
<Filter>Source Files\Renderer</Filter>
</ClCompile>
<ClCompile Include="src\Renderer\StraightLine.cpp">
<Filter>Source Files\Renderer</Filter>
</ClCompile>
<ClCompile Include="src\main.cpp"> <ClCompile Include="src\main.cpp">
<Filter>Source Files</Filter> <Filter>Source Files</Filter>
</ClCompile> </ClCompile>
@ -114,6 +99,30 @@
<ClCompile Include="src\TitleWidget.cpp"> <ClCompile Include="src\TitleWidget.cpp">
<Filter>Source Files</Filter> <Filter>Source Files</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="src\Renderer\Painting\BvhTree.cpp">
<Filter>Source Files\Renderer\Painting</Filter>
</ClCompile>
<ClCompile Include="src\Renderer\Painting\CubicBezier.cpp">
<Filter>Source Files\Renderer\Painting</Filter>
</ClCompile>
<ClCompile Include="src\Renderer\Painting\CubicMonotonization.cpp">
<Filter>Source Files\Renderer\Painting</Filter>
</ClCompile>
<ClCompile Include="src\Renderer\Painting\PaintingHelper.cpp">
<Filter>Source Files\Renderer\Painting</Filter>
</ClCompile>
<ClCompile Include="src\Renderer\Painting\ShortCutTree.cpp">
<Filter>Source Files\Renderer\Painting</Filter>
</ClCompile>
<ClCompile Include="src\Renderer\Painting\StraightLine.cpp">
<Filter>Source Files\Renderer\Painting</Filter>
</ClCompile>
<ClCompile Include="src\Renderer\Painting\Painting.cpp">
<Filter>Source Files\Renderer\Painting</Filter>
</ClCompile>
<ClCompile Include="src\Renderer\Painting\Line.cpp">
<Filter>Source Files\Renderer\Painting</Filter>
</ClCompile>
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<QtMoc Include="src\Renderer\RendererGLWidget.h"> <QtMoc Include="src\Renderer\RendererGLWidget.h">
@ -206,48 +215,51 @@
</QtUic> </QtUic>
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<ClInclude Include="src\Renderer\BvhTree.h">
<Filter>Header Files\Renderer</Filter>
</ClInclude>
<ClInclude Include="src\Renderer\Camera.h"> <ClInclude Include="src\Renderer\Camera.h">
<Filter>Header Files\Renderer</Filter> <Filter>Header Files\Renderer</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="src\Renderer\CubicBezier.h">
<Filter>Header Files\Renderer</Filter>
</ClInclude>
<ClInclude Include="src\Renderer\CubicMonotonization.h">
<Filter>Header Files\Renderer</Filter>
</ClInclude>
<ClInclude Include="src\Renderer\Drawable.h"> <ClInclude Include="src\Renderer\Drawable.h">
<Filter>Header Files\Renderer</Filter> <Filter>Header Files\Renderer</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="src\Renderer\Light.h"> <ClInclude Include="src\Renderer\Light.h">
<Filter>Header Files\Renderer</Filter> <Filter>Header Files\Renderer</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="src\Renderer\Line.h">
<Filter>Header Files\Renderer</Filter>
</ClInclude>
<ClInclude Include="src\Renderer\Mesh.h"> <ClInclude Include="src\Renderer\Mesh.h">
<Filter>Header Files\Renderer</Filter> <Filter>Header Files\Renderer</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="src\Renderer\Model.h"> <ClInclude Include="src\Renderer\Model.h">
<Filter>Header Files\Renderer</Filter> <Filter>Header Files\Renderer</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="src\Renderer\PaintingHelper.h">
<Filter>Header Files\Renderer</Filter>
</ClInclude>
<ClInclude Include="src\Renderer\PaintingMesh.h"> <ClInclude Include="src\Renderer\PaintingMesh.h">
<Filter>Header Files\Renderer</Filter> <Filter>Header Files\Renderer</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="src\Renderer\ShortCutTree.h">
<Filter>Header Files\Renderer</Filter>
</ClInclude>
<ClInclude Include="src\Renderer\StraightLine.h">
<Filter>Header Files\Renderer</Filter>
</ClInclude>
<ClInclude Include="src\SvgParser.h"> <ClInclude Include="src\SvgParser.h">
<Filter>Header Files</Filter> <Filter>Header Files</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="src\Renderer\Painting\BvhTree.h">
<Filter>Header Files\Renderer\Painting</Filter>
</ClInclude>
<ClInclude Include="src\Renderer\Painting\CubicBezier.h">
<Filter>Header Files\Renderer\Painting</Filter>
</ClInclude>
<ClInclude Include="src\Renderer\Painting\CubicMonotonization.h">
<Filter>Header Files\Renderer\Painting</Filter>
</ClInclude>
<ClInclude Include="src\Renderer\Painting\Line.h">
<Filter>Header Files\Renderer\Painting</Filter>
</ClInclude>
<ClInclude Include="src\Renderer\Painting\PaintingHelper.h">
<Filter>Header Files\Renderer\Painting</Filter>
</ClInclude>
<ClInclude Include="src\Renderer\Painting\ShortCutTree.h">
<Filter>Header Files\Renderer\Painting</Filter>
</ClInclude>
<ClInclude Include="src\Renderer\Painting\StraightLine.h">
<Filter>Header Files\Renderer\Painting</Filter>
</ClInclude>
<ClInclude Include="src\Renderer\Painting\Painting.h">
<Filter>Header Files\Renderer\Painting</Filter>
</ClInclude>
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<QtRcc Include="MainWindow.qrc"> <QtRcc Include="MainWindow.qrc">

4
ArchitectureColoredPainting/MainWindow.ui
View File

@ -94,7 +94,7 @@ QTabWidget::pane {
<string>纹理编辑</string> <string>纹理编辑</string>
</attribute> </attribute>
</widget> </widget>
<widget class="RendererWidget" name="rendererWidget"> <widget class="Renderer::RendererWidget" name="rendererWidget">
<attribute name="title"> <attribute name="title">
<string>场景渲染</string> <string>场景渲染</string>
</attribute> </attribute>
@ -109,7 +109,7 @@ QTabWidget::pane {
<layoutdefault spacing="6" margin="11"/> <layoutdefault spacing="6" margin="11"/>
<customwidgets> <customwidgets>
<customwidget> <customwidget>
<class>RendererWidget</class> <class>Renderer::RendererWidget</class>
<extends>QWidget</extends> <extends>QWidget</extends>
<header>Renderer/RendererWidget.h</header> <header>Renderer/RendererWidget.h</header>
</customwidget> </customwidget>

4
ArchitectureColoredPainting/RendererWidget.ui
View File

@ -48,7 +48,7 @@
<enum>QLayout::SetDefaultConstraint</enum> <enum>QLayout::SetDefaultConstraint</enum>
</property> </property>
<item> <item>
<widget class="RendererGLWidget" name="openGLWidget"> <widget class="Renderer::RendererGLWidget" name="openGLWidget">
<property name="sizePolicy"> <property name="sizePolicy">
<sizepolicy hsizetype="Preferred" vsizetype="Expanding"> <sizepolicy hsizetype="Preferred" vsizetype="Expanding">
<horstretch>0</horstretch> <horstretch>0</horstretch>
@ -94,7 +94,7 @@
<layoutdefault spacing="6" margin="11"/> <layoutdefault spacing="6" margin="11"/>
<customwidgets> <customwidgets>
<customwidget> <customwidget>
<class>RendererGLWidget</class> <class>Renderer::RendererGLWidget</class>
<extends>QOpenGLWidget</extends> <extends>QOpenGLWidget</extends>
<header>RendererGLWidget.h</header> <header>RendererGLWidget.h</header>
</customwidget> </customwidget>

2
ArchitectureColoredPainting/src/MainWindow.cpp
View File

@ -110,7 +110,7 @@ CentralWidget::CentralWidget(QWidget* parent) : QMainWindow(parent)
QObject::connect(navigationBarWidget->buttonGroup, &QButtonGroup::idClicked, QObject::connect(navigationBarWidget->buttonGroup, &QButtonGroup::idClicked,
ui.tabWidget, &QTabWidget::setCurrentIndex); ui.tabWidget, &QTabWidget::setCurrentIndex);
QObject::connect(ui.tabWidget, &QTabWidget::currentChanged, QObject::connect(ui.tabWidget, &QTabWidget::currentChanged,
ui.rendererWidget, &RendererWidget::currentTabChanged); ui.rendererWidget, &Renderer::RendererWidget::currentTabChanged);
} }
CentralWidget::~CentralWidget() CentralWidget::~CentralWidget()

88
ArchitectureColoredPainting/src/Renderer/BvhTree.h
View File

@ -1,88 +0,0 @@
#pragma once
#include <QOpenGLTexture>
#include <QOpenGLContext>
#include <QTextCodec>
#include <algorithm>
#include <QVector4D>
#include <iostream>
#include <memory>
#include <vector>
#include <cmath>
using std::shared_ptr;
struct BvhTreeData {
QVector4D bound;
GLuint leftSon, rightSon;
void show() {
printf("Bvh: (%lf, %lf) (%lf, %lf): %d %d\n",
bound.x(), bound.y(), bound.z(), bound.w(),
leftSon, rightSon);
}
BvhTreeData(QVector4D bound, GLuint leftSon, GLuint rightSon)
: bound(bound), leftSon(leftSon), rightSon(rightSon) {}
BvhTreeData()
: leftSon(0), rightSon(0) {}
~BvhTreeData() {}
};
// BvhTree 节点
struct BvhNode {
GLuint lab;
bool isLeaf;
QVector4D bound;
shared_ptr<BvhNode> child[2];
static bool x_compare(BvhTreeData a, BvhTreeData b) {
return a.bound.x() < b.bound.x();
}
static bool y_compare(BvhTreeData a, BvhTreeData b) {
return a.bound.y() < b.bound.y();
}
GLuint getLeftSon(int k) {
if (isLeaf) {
return 0x80000000+child[0]->lab;
}
return child[0]->lab;
}
GLuint getRightSon(int k) {
if (isLeaf) {
return child[1]->lab;
}
return child[1]->lab;
}
BvhNode() {
child[0] = child[1] = NULL;
isLeaf = false;
lab = 0;
}
int maximumBound() {
return (std::fabs(bound.x() - bound.w()) < std::fabs(bound.y() - bound.z()));
}
~BvhNode() {}
};
typedef std::shared_ptr<BvhNode> BvhPtr;
class BvhTree
{
private:
GLuint tot;
BvhPtr root;
static QVector4D calcBound(BvhTreeData initBound[], int l, int r);
static QVector4D Union(QVector4D a, QVector4D b);
BvhPtr subBvhTree(BvhTreeData initBound[], int l, int r);
void traverseBvhTree(BvhPtr now, std::vector<GLuint>& children, std::vector<QVector4D>& bounds);
public:
BvhTree() {
tot = 0;
root = NULL;
}
// 根据底层包围盒生成bvh树
void buildBvhTree(BvhTreeData initBound[], int len);
// 获得 Bvh （rootBvh部分）的 children 数组，包围盒数组 vector 传输
void getBvhArray(std::vector<GLuint>& children, std::vector<QVector4D>& bounds);
// 获得 BvhTree 中节点总数
GLuint getBvhNodeNum();
};

2
ArchitectureColoredPainting/src/Renderer/Camera.cpp
View File

@ -1,5 +1,5 @@
#include "Camera.h" #include "Camera.h"
using namespace Renderer;
// constructor with vectors // constructor with vectors

111
ArchitectureColoredPainting/src/Renderer/Camera.h
View File

@ -5,66 +5,69 @@
#include <QtMath> #include <QtMath>
#include <QOpenGLFunctions_4_5_Compatibility> #include <QOpenGLFunctions_4_5_Compatibility>
// Default camera values namespace Renderer
const float YAW = -90.0f;
const float PITCH = 0.0f;
const float SPEED = 200.f;
const float SENSITIVITY = 0.1f;
const float ZOOM = 45.0f;
// Defines several possible options for camera movement. Used as abstraction to stay away from window-system specific input methods
enum Camera_Movement {
FORWARD,
BACKWARD,
LEFT,
RIGHT,
UP,
DOWN
};
class Camera
{ {
public: // Defines several possible options for camera movement. Used as abstraction to stay away from window-system specific input methods
// camera Attributes enum Camera_Movement {
QVector3D Position; FORWARD,
QVector3D Front; BACKWARD,
QVector3D Up; LEFT,
QVector3D Right; RIGHT,
QVector3D WorldUp; UP,
QVector3D PositionFront; DOWN
QVector3D PositionRight; };
// euler Angles, ½Ç¶ÈÖÆ
float Yaw;
float Pitch;
// camera options
float MovementSpeed;
float MouseSensitivity;
float Zoom;
float Ratio;
float NearPlane = 10.f;
float FarPlane = 5000.f;
// constructor with vectors class Camera
Camera(QVector3D position = QVector3D(0.0f, 0.0f, 0.0f), QVector3D up = QVector3D(0.0f, 1.0f, 0.0f), float yaw = YAW, float pitch = PITCH); {
// constructor with scalar values public:
Camera(float posX, float posY, float posZ, float upX, float upY, float upZ, float yaw, float pitch); // Default camera values
static constexpr float YAW = -90.0f;
static constexpr float PITCH = 0.0f;
static constexpr float SPEED = 200.f;
static constexpr float SENSITIVITY = 0.1f;
static constexpr float ZOOM = 45.0f;
// camera Attributes
QVector3D Position;
QVector3D Front;
QVector3D Up;
QVector3D Right;
QVector3D WorldUp;
QVector3D PositionFront;
QVector3D PositionRight;
// euler Angles, ½Ç¶ÈÖÆ
float Yaw;
float Pitch;
// camera options
float MovementSpeed;
float MouseSensitivity;
float Zoom;
float Ratio;
float NearPlane = 10.f;
float FarPlane = 5000.f;
// returns the view matrix calculated using Euler Angles and the LookAt Matrix // constructor with vectors
QMatrix4x4 GetViewMatrix(); Camera(QVector3D position = QVector3D(0.0f, 0.0f, 0.0f), QVector3D up = QVector3D(0.0f, 1.0f, 0.0f), float yaw = YAW, float pitch = PITCH);
// processes input received from any keyboard-like input system. Accepts input parameter in the form of camera defined ENUM (to abstract it from windowing systems)
void ProcessKeyboard(Camera_Movement direction, float deltaTime);
// processes input received from a mouse input system. Expects the offset value in both the x and y direction. // constructor with scalar values
void ProcessMouseMovement(float xoffset, float yoffset, GLboolean constrainPitch = true); Camera(float posX, float posY, float posZ, float upX, float upY, float upZ, float yaw, float pitch);
// processes input received from a mouse scroll-wheel event. Only requires input on the vertical wheel-axis // returns the view matrix calculated using Euler Angles and the LookAt Matrix
void ProcessMouseScroll(float yoffset); QMatrix4x4 GetViewMatrix();
private: // processes input received from any keyboard-like input system. Accepts input parameter in the form of camera defined ENUM (to abstract it from windowing systems)
// calculates the front vector from the Camera's (updated) Euler Angles void ProcessKeyboard(Camera_Movement direction, float deltaTime);
void updateCameraVectors();
};
// processes input received from a mouse input system. Expects the offset value in both the x and y direction.
void ProcessMouseMovement(float xoffset, float yoffset, GLboolean constrainPitch = true);
// processes input received from a mouse scroll-wheel event. Only requires input on the vertical wheel-axis
void ProcessMouseScroll(float yoffset);
private:
// calculates the front vector from the Camera's (updated) Euler Angles
void updateCameraVectors();
};
}

20
ArchitectureColoredPainting/src/Renderer/CubicBezier.h
View File

@ -1,20 +0,0 @@
#pragma once
#include "Line.h"
#include <memory>
class CubicBezier : public Line
{
using Line::Line;
private:
static Point getPointByT(Point a, Point b, double t);
static Point calculateControlPoint(Point a, Point b);
static void findPointsOfDivison(vector<double> &p, vector<double>& res);
void splitBezierCubic(double t, vector<LinePtr>& res);
public:
virtual double findTByValue(double value, bool isY);
virtual void monotonization(vector <LinePtr>& res);
virtual double getLineValueByT(double t, bool isY);
virtual int judgeBoundIntersection(double xy, double l, double r, bool isY);
void transformToCubic();
};

24
ArchitectureColoredPainting/src/Renderer/CubicMonotonization.h
View File

@ -1,24 +0,0 @@
#include <utility>
#include <vector>
#include <algorithm>
#pragma once
using std::pair;
using std::vector;
using std::min;
using std::max;
using std::sort;
class CubicMonotonization
{
typedef pair<double, double> point;
typedef vector<point> Line;
private:
static const double eps;
point getPointByT(point a, point b, double t) const;
void findPointsOfDivison(vector<double> p, vector<double> &res);
double getBezierPoint(vector<double> &p, double t) const;
void splitBezierCubic(Line& p, point mid, double t, vector <Line> &res);
public:
// p 为端点、控制点、控制点、端点， res 为所有导数为0的点
void getPointsOfDivision(Line p, vector <Line> &res);
};

14
ArchitectureColoredPainting/src/Renderer/Drawable.h
View File

@ -1,8 +1,10 @@
#pragma once #pragma once
class Drawable namespace Renderer
{ {
public: class Drawable
virtual void draw() = 0; {
virtual void drawShadow() = 0; public:
}; virtual void draw() = 0;
virtual void drawShadow() = 0;
};
}

2
ArchitectureColoredPainting/src/Renderer/Light.cpp
View File

@ -1,6 +1,6 @@
#include "Light.h" #include "Light.h"
#include <qDebug> #include <qDebug>
using namespace Renderer;
Light::Light(Camera* camera) Light::Light(Camera* camera)
: camera(camera) : camera(camera)
//, shadowCascadeLevels{ camera->FarPlane / 25.0f, camera->FarPlane / 12.0f, camera->FarPlane / 6.0f, camera->FarPlane / 3.0f } //, shadowCascadeLevels{ camera->FarPlane / 25.0f, camera->FarPlane / 12.0f, camera->FarPlane / 6.0f, camera->FarPlane / 3.0f }

35
ArchitectureColoredPainting/src/Renderer/Light.h
View File

@ -9,21 +9,24 @@
#include "Camera.h" #include "Camera.h"
#include "Model.h" #include "Model.h"
class Light namespace Renderer
{ {
public: class Light
QVector3D lightDirection = QVector3D(0.2, 4, 1).normalized(); {
std::vector<float> shadowCascadeLevels; public:
float blendRatio = 0.3; QVector3D lightDirection = QVector3D(0.2, 4, 1).normalized();
std::vector<float> frustumSizes; std::vector<float> shadowCascadeLevels;
Model* model; float blendRatio = 0.3;
Light(Camera* camera); std::vector<float> frustumSizes;
std::vector<QVector4D> getFrustumCornersWorldSpace(const QMatrix4x4& projview); Model* model;
std::vector<QVector4D> getFrustumCornersWorldSpace(const QMatrix4x4& proj, const QMatrix4x4& view); Light(Camera* camera);
QMatrix4x4 getLightSpaceMatrix(const float nearPlane, const float farPlane); std::vector<QVector4D> getFrustumCornersWorldSpace(const QMatrix4x4& projview);
std::vector<QMatrix4x4> getLightSpaceMatrices(); std::vector<QVector4D> getFrustumCornersWorldSpace(const QMatrix4x4& proj, const QMatrix4x4& view);
private: QMatrix4x4 getLightSpaceMatrix(const float nearPlane, const float farPlane);
Camera* camera; std::vector<QMatrix4x4> getLightSpaceMatrices();
private:
}; Camera* camera;
};
}

65
ArchitectureColoredPainting/src/Renderer/Line.h
View File

@ -1,65 +0,0 @@
#pragma once
#include <vector>
#include <utility>
#include <vector>
#include <QVector4D>
#include <algorithm>
#include <memory>
#include <iostream>
using std::vector;
using std::pair;
using std::min;
using std::max;
using std::sort;
using std::shared_ptr;
using std::make_shared;
using std::swap;
const double eps = 1e-5;
struct Point {
double x, y;
Point operator + (const Point a) { return { x + a.x, y + a.y }; }
Point operator - (const Point a) { return { x - a.x, y - a.y }; }
Point operator * (const double a) { return { x * a, y * a }; }
double operator * (const Point a) { return x * a.y - y * a.x; }
bool operator== (const Point& a) const {
return fabs(x - a.x) <= eps && fabs(y - a.y) <= eps;
}
bool operator< (const Point& a) const {
return fabs(x - a.x) <= eps ? y < a.y : x < a.x;
}
void show() {
std::cout << '(' << x << ',' << y << ')' << ' ';
}
};
class Line
{
protected:
vector<double> vX, vY;
int siz;
public:
typedef shared_ptr<Line> LinePtr;
Line() :siz(0) {}
Line(vector<Point> Vp);
int size();
void clear();
Point getBegin();
Point getEnd();
int direction(bool isY);
virtual double getLineValueByT(double t, bool isY) = 0;
virtual void monotonization(vector <LinePtr>& res) = 0;
virtual int judgeBoundIntersection(double xy, double l, double r, bool isY) = 0;
virtual bool judgeIntersection(QVector4D bound);
bool isLineContained(QVector4D bound);
Point operator[](int index) const;
Point getPointByIndex(int index) const;
vector<Point> toPointVector() const;
void setPointByIndex(int index, Point now);
void push_back(Point now);
virtual ~Line() {}
};
typedef shared_ptr<Line> LinePtr;

2
ArchitectureColoredPainting/src/Renderer/Mesh.cpp
View File

@ -1,5 +1,5 @@
#include "Mesh.h" #include "Mesh.h"
using namespace Renderer;
Mesh::Mesh(QOpenGLFunctions_4_5_Compatibility* glFunc, QOpenGLShaderProgram* shaderProgram, QOpenGLShaderProgram* shadowProgram, aiMatrix4x4 model) Mesh::Mesh(QOpenGLFunctions_4_5_Compatibility* glFunc, QOpenGLShaderProgram* shaderProgram, QOpenGLShaderProgram* shadowProgram, aiMatrix4x4 model)
: glFunc(glFunc) : glFunc(glFunc)
, shaderProgram(shaderProgram) , shaderProgram(shaderProgram)

82
ArchitectureColoredPainting/src/Renderer/Mesh.h
View File

@ -13,49 +13,51 @@
#include <assimp/scene.h> #include <assimp/scene.h>
#include <assimp/postprocess.h> #include <assimp/postprocess.h>
#include "Drawable.h" #include "Drawable.h"
namespace Renderer
struct Vertex
{ {
QVector3D Position; struct Vertex
QVector3D Normal; {
QVector2D TexCoords; QVector3D Position;
QVector3D Tangent; QVector3D Normal;
QVector3D Bitangent; QVector2D TexCoords;
}; QVector3D Tangent;
QVector3D Bitangent;
};
struct Texture struct Texture
{ {
QOpenGLTexture texture; QOpenGLTexture texture;
QString type; QString type;
QString path; QString path;
Texture() :texture(QOpenGLTexture::Target2D) { Texture() :texture(QOpenGLTexture::Target2D) {
texture.create(); texture.create();
texture.setWrapMode(QOpenGLTexture::DirectionS, QOpenGLTexture::Repeat); texture.setWrapMode(QOpenGLTexture::DirectionS, QOpenGLTexture::Repeat);
texture.setWrapMode(QOpenGLTexture::DirectionT, QOpenGLTexture::Repeat); texture.setWrapMode(QOpenGLTexture::DirectionT, QOpenGLTexture::Repeat);
texture.setMinMagFilters(QOpenGLTexture::LinearMipMapLinear, QOpenGLTexture::Linear); texture.setMinMagFilters(QOpenGLTexture::LinearMipMapLinear, QOpenGLTexture::Linear);
} }
}; };
class Mesh : public Drawable class Mesh : public Drawable
{ {
public: public:
/* 网格数据 */ /* 网格数据 */
QVector<Vertex> vertices; //顶点数据 QVector<Vertex> vertices; //顶点数据
QVector<unsigned int> indices; //索引数组 QVector<unsigned int> indices; //索引数组
QVector<Texture*> textures; //纹理数据 QVector<Texture*> textures; //纹理数据
QMatrix4x4 model; //模型矩阵 QMatrix4x4 model; //模型矩阵
QOpenGLFunctions_4_5_Compatibility* glFunc; //opengl函数入口 QOpenGLFunctions_4_5_Compatibility* glFunc; //opengl函数入口
QOpenGLShaderProgram* shaderProgram, * shadowProgram; //着色器程序 QOpenGLShaderProgram* shaderProgram, * shadowProgram; //着色器程序
/* 函数 */ /* 函数 */
Mesh(QOpenGLFunctions_4_5_Compatibility* glFunc, QOpenGLShaderProgram* shaderProgram, QOpenGLShaderProgram* shadowProgram, aiMatrix4x4 model); Mesh(QOpenGLFunctions_4_5_Compatibility* glFunc, QOpenGLShaderProgram* shaderProgram, QOpenGLShaderProgram* shadowProgram, aiMatrix4x4 model);
void draw() override; void draw() override;
void drawShadow() override; void drawShadow() override;
void setupMesh(); void setupMesh();
private: private:
/* 渲染数据 */ /* 渲染数据 */
QOpenGLVertexArrayObject VAO; QOpenGLVertexArrayObject VAO;
QOpenGLBuffer VBO, EBO; QOpenGLBuffer VBO, EBO;
}; };
}

9
ArchitectureColoredPainting/src/Renderer/Model.cpp
View File

@ -6,10 +6,11 @@
#include <iostream> #include <iostream>
#include "PaintingMesh.h" #include "PaintingMesh.h"
#include <QtMath> #include <QtMath>
#include "BvhTree.h" #include "Painting/BvhTree.h"
#include "ShortCutTree.h" #include "Painting/ShortCutTree.h"
#include "../SvgParser.h" #include "../SvgParser.h"
using namespace Renderer;
using std::vector;
Model::Model(QString path, QOpenGLContext* context, QOpenGLShaderProgram* shaderProgram) Model::Model(QString path, QOpenGLContext* context, QOpenGLShaderProgram* shaderProgram)
: context(context) : context(context)
, glFunc(context->versionFunctions<QOpenGLFunctions_4_5_Compatibility>()) , glFunc(context->versionFunctions<QOpenGLFunctions_4_5_Compatibility>())
@ -175,7 +176,7 @@ Drawable* Model::processMesh(aiMesh* mesh, const aiScene* scene, aiMatrix4x4 mod
m_mesh->indices.push_back(face.mIndices[j]); m_mesh->indices.push_back(face.mIndices[j]);
} }
} }
BvhTree rootBvhTree; BvhTree rootBvhTree;
vector<BvhTreeData> rootBvhTreeData; vector<BvhTreeData> rootBvhTreeData;
for (int i = 0; i < 1000; i++) for (int i = 0; i < 1000; i++)

73
ArchitectureColoredPainting/src/Renderer/Model.h
View File

@ -2,49 +2,52 @@
#include "Mesh.h" #include "Mesh.h"
#include "Drawable.h" #include "Drawable.h"
#include "PaintingHelper.h" #include "Painting/PaintingHelper.h"
#include <QDir> #include <QDir>
class Model namespace Renderer
{ {
public: class Model
std::vector<QVector3D> AABB; {
public:
std::vector<QVector3D> AABB;
void draw(); void draw();
void drawShadow(); void drawShadow();
void destroy(); void destroy();
static Model* createModel(QString path, QOpenGLContext* context, QOpenGLShaderProgram* shaderProgram); static Model* createModel(QString path, QOpenGLContext* context, QOpenGLShaderProgram* shaderProgram);
Model(QString path, QOpenGLContext* context, QOpenGLShaderProgram* shaderProgram, QOpenGLShaderProgram* paintingProgram, QOpenGLShaderProgram* shadowProgram, PaintingHelper* paintingHelper); Model(QString path, QOpenGLContext* context, QOpenGLShaderProgram* shaderProgram, QOpenGLShaderProgram* paintingProgram, QOpenGLShaderProgram* shadowProgram, PaintingHelper* paintingHelper);
private: private:
Model(QString path, QOpenGLContext* context, QOpenGLShaderProgram* shaderProgram); Model(QString path, QOpenGLContext* context, QOpenGLShaderProgram* shaderProgram);
~Model(); ~Model();
QOpenGLContext* context; //opengl函数入口 QOpenGLContext* context; //opengl函数入口
QOpenGLFunctions_4_5_Compatibility* glFunc; QOpenGLFunctions_4_5_Compatibility* glFunc;
QOpenGLShaderProgram* shaderProgram = nullptr; QOpenGLShaderProgram* shaderProgram = nullptr;
QOpenGLShaderProgram* paintingProgram = nullptr; //彩绘着色器程序 QOpenGLShaderProgram* paintingProgram = nullptr; //彩绘着色器程序
QOpenGLShaderProgram* shadowProgram = nullptr; QOpenGLShaderProgram* shadowProgram = nullptr;
PaintingHelper* paintingHelper = nullptr; PaintingHelper* paintingHelper = nullptr;
/* 模型数据 */ /* 模型数据 */
QVector<Texture*> textures_loaded; //纹理 QVector<Texture*> textures_loaded; //纹理
QVector<Drawable*> meshes; //网格 QVector<Drawable*> meshes; //网格
QDir directory; //模型所在路径 QDir directory; //模型所在路径
float minX = std::numeric_limits<float>::max(); float minX = std::numeric_limits<float>::max();
float maxX = std::numeric_limits<float>::min(); float maxX = std::numeric_limits<float>::min();
float minY = std::numeric_limits<float>::max(); float minY = std::numeric_limits<float>::max();
float maxY = std::numeric_limits<float>::min(); float maxY = std::numeric_limits<float>::min();
float minZ = std::numeric_limits<float>::max(); float minZ = std::numeric_limits<float>::max();
float maxZ = std::numeric_limits<float>::min(); float maxZ = std::numeric_limits<float>::min();
//递归遍历结点 //递归遍历结点
void processNode(aiNode* node, const aiScene* scene, aiMatrix4x4 mat4 = aiMatrix4x4()); void processNode(aiNode* node, const aiScene* scene, aiMatrix4x4 mat4 = aiMatrix4x4());
//加载网格 //加载网格
Drawable* processMesh(aiMesh* mesh, const aiScene* scene, aiMatrix4x4 model); Drawable* processMesh(aiMesh* mesh, const aiScene* scene, aiMatrix4x4 model);
//加载材质纹理 //加载材质纹理
QVector<Texture*> loadMaterialTextures(aiMaterial* mat, aiTextureType type, QString typeName); QVector<Texture*> loadMaterialTextures(aiMaterial* mat, aiTextureType type, QString typeName);
}; };
}

2
ArchitectureColoredPainting/src/Renderer/BvhTree.cpp → ArchitectureColoredPainting/src/Renderer/Painting/BvhTree.cpp
View File

@ -1,5 +1,5 @@
#include "BvhTree.h" #include "BvhTree.h"
using namespace Renderer;
GLuint BvhTree::getBvhNodeNum() { GLuint BvhTree::getBvhNodeNum() {
return tot; return tot;
} }

89
ArchitectureColoredPainting/src/Renderer/Painting/BvhTree.h Normal file
View File

@ -0,0 +1,89 @@
#pragma once
#include <QOpenGLTexture>
#include <QOpenGLContext>
#include <QTextCodec>
#include <algorithm>
#include <QVector4D>
#include <iostream>
#include <memory>
#include <vector>
#include <cmath>
namespace Renderer
{
struct BvhTreeData {
QVector4D bound;
GLuint leftSon, rightSon;
void show() {
printf("Bvh: (%lf, %lf) (%lf, %lf): %d %d\n",
bound.x(), bound.y(), bound.z(), bound.w(),
leftSon, rightSon);
}
BvhTreeData(QVector4D bound, GLuint leftSon, GLuint rightSon)
: bound(bound), leftSon(leftSon), rightSon(rightSon) {}
BvhTreeData()
: leftSon(0), rightSon(0) {}
~BvhTreeData() {}
};
// BvhTree 节点
struct BvhNode {
GLuint lab;
bool isLeaf;
QVector4D bound;
std::shared_ptr<BvhNode> child[2];
static bool x_compare(BvhTreeData a, BvhTreeData b) {
return a.bound.x() < b.bound.x();
}
static bool y_compare(BvhTreeData a, BvhTreeData b) {
return a.bound.y() < b.bound.y();
}
GLuint getLeftSon(int k) {
if (isLeaf) {
return 0x80000000 + child[0]->lab;
}
return child[0]->lab;
}
GLuint getRightSon(int k) {
if (isLeaf) {
return child[1]->lab;
}
return child[1]->lab;
}
BvhNode() {
child[0] = child[1] = NULL;
isLeaf = false;
lab = 0;
}
int maximumBound() {
return (std::fabs(bound.x() - bound.w()) < std::fabs(bound.y() - bound.z()));
}
~BvhNode() {}
};
typedef std::shared_ptr<BvhNode> BvhPtr;
class BvhTree
{
private:
GLuint tot;
BvhPtr root;
static QVector4D calcBound(BvhTreeData initBound[], int l, int r);
static QVector4D Union(QVector4D a, QVector4D b);
BvhPtr subBvhTree(BvhTreeData initBound[], int l, int r);
void traverseBvhTree(BvhPtr now, std::vector<GLuint>& children, std::vector<QVector4D>& bounds);
public:
BvhTree() {
tot = 0;
root = NULL;
}
// 根据底层包围盒生成bvh树
void buildBvhTree(BvhTreeData initBound[], int len);
// 获得 Bvh （rootBvh部分）的 children 数组，包围盒数组 vector 传输
void getBvhArray(std::vector<GLuint>& children, std::vector<QVector4D>& bounds);
// 获得 BvhTree 中节点总数
GLuint getBvhNodeNum();
};
}

3
ArchitectureColoredPainting/src/Renderer/CubicBezier.cpp → ArchitectureColoredPainting/src/Renderer/Painting/CubicBezier.cpp
View File

@ -1,5 +1,6 @@
#include "CubicBezier.h" #include "CubicBezier.h"
using namespace Renderer;
using std::vector;
double CubicBezier::getLineValueByT(double t, bool isY) { double CubicBezier::getLineValueByT(double t, bool isY) {
vector<double> p; vector<double> p;
if (isY) p = vY; if (isY) p = vY;

21
ArchitectureColoredPainting/src/Renderer/Painting/CubicBezier.h Normal file
View File

@ -0,0 +1,21 @@
#pragma once
#include "Line.h"
#include <memory>
namespace Renderer
{
class CubicBezier : public Line
{
using Line::Line;
private:
static Point getPointByT(Point a, Point b, double t);
static Point calculateControlPoint(Point a, Point b);
static void findPointsOfDivison(std::vector<double>& p, std::vector<double>& res);
void splitBezierCubic(double t, std::vector<LinePtr>& res);
public:
virtual double findTByValue(double value, bool isY);
virtual void monotonization(std::vector <LinePtr>& res);
virtual double getLineValueByT(double t, bool isY);
virtual int judgeBoundIntersection(double xy, double l, double r, bool isY);
void transformToCubic();
};
}

6
ArchitectureColoredPainting/src/Renderer/CubicMonotonization.cpp → ArchitectureColoredPainting/src/Renderer/Painting/CubicMonotonization.cpp
View File

@ -1,5 +1,9 @@
#include "CubicMonotonization.h" #include "CubicMonotonization.h"
using namespace Renderer;
using std::vector;
using std::min;
using std::max;
using std::sort;
const double CubicMonotonization::eps = 1e-6; const double CubicMonotonization::eps = 1e-6;

23
ArchitectureColoredPainting/src/Renderer/Painting/CubicMonotonization.h Normal file
View File

@ -0,0 +1,23 @@
#pragma once
#include <utility>
#include <vector>
#include <algorithm>
namespace Renderer
{
class CubicMonotonization
{
typedef std::pair<double, double> point;
typedef std::vector<point> Line;
private:
static const double eps;
point getPointByT(point a, point b, double t) const;
void findPointsOfDivison(std::vector<double> p, std::vector<double>& res);
double getBezierPoint(std::vector<double>& p, double t) const;
void splitBezierCubic(Line& p, point mid, double t, std::vector <Line>& res);
public:
// p 为端点、控制点、控制点、端点， res 为所有导数为0的点
void getPointsOfDivision(Line p, std::vector <Line>& res);
};
}

10
ArchitectureColoredPainting/src/Renderer/Line.cpp → ArchitectureColoredPainting/src/Renderer/Painting/Line.cpp
View File

@ -1,5 +1,13 @@
#include "Line.h" #include "Line.h"
using namespace Renderer;
using std::vector;
using std::pair;
using std::min;
using std::max;
using std::sort;
using std::shared_ptr;
using std::make_shared;
using std::swap;
Line::Line(vector<Point> Vp) { Line::Line(vector<Point> Vp) {
siz = Vp.size(); siz = Vp.size();
for (Point now : Vp) { for (Point now : Vp) {

57
ArchitectureColoredPainting/src/Renderer/Painting/Line.h Normal file
View File

@ -0,0 +1,57 @@
#pragma once
#include <vector>
#include <utility>
#include <vector>
#include <QVector4D>
#include <algorithm>
#include <memory>
#include <iostream>
namespace Renderer
{
const double eps = 1e-5;
struct Point {
double x, y;
Point operator + (const Point a) { return { x + a.x, y + a.y }; }
Point operator - (const Point a) { return { x - a.x, y - a.y }; }
Point operator * (const double a) { return { x * a, y * a }; }
double operator * (const Point a) { return x * a.y - y * a.x; }
bool operator== (const Point& a) const {
return fabs(x - a.x) <= eps && fabs(y - a.y) <= eps;
}
bool operator< (const Point& a) const {
return fabs(x - a.x) <= eps ? y < a.y : x < a.x;
}
void show() {
std::cout << '(' << x << ',' << y << ')' << ' ';
}
};
class Line
{
protected:
std::vector<double> vX, vY;
int siz;
public:
typedef std::shared_ptr<Line> LinePtr;
Line() :siz(0) {}
Line(std::vector<Point> Vp);
int size();
void clear();
Point getBegin();
Point getEnd();
int direction(bool isY);
virtual double getLineValueByT(double t, bool isY) = 0;
virtual void monotonization(std::vector <LinePtr>& res) = 0;
virtual int judgeBoundIntersection(double xy, double l, double r, bool isY) = 0;
virtual bool judgeIntersection(QVector4D bound);
bool isLineContained(QVector4D bound);
Point operator[](int index) const;
Point getPointByIndex(int index) const;
std::vector<Point> toPointVector() const;
void setPointByIndex(int index, Point now);
void push_back(Point now);
virtual ~Line() {}
};
}

8
ArchitectureColoredPainting/src/Renderer/Painting/Painting.cpp Normal file
View File

@ -0,0 +1,8 @@
#include "Painting.h"
using namespace Renderer;
Painting::Painting()
{
}

23
ArchitectureColoredPainting/src/Renderer/Painting/Painting.h Normal file
View File

@ -0,0 +1,23 @@
#pragma once
#include <vector>
#include <QOpenGLFunctions_4_5_Compatibility>
#include "Line.h"
namespace Renderer
{
class Painting
{
std::vector<GLuint> paintingOffsets;
std::vector<GLuint> bvhChildren;
std::vector<QVector4D> bvhBound;
std::vector<GLuint> elementOffset;
std::vector<GLuint> elementIndex;
std::vector<GLfloat> elementData;
int paintingId = 0;
public:
Painting();
};
}

2
ArchitectureColoredPainting/src/Renderer/PaintingHelper.cpp → ArchitectureColoredPainting/src/Renderer/Painting/PaintingHelper.cpp
View File

@ -1,5 +1,5 @@
#include "PaintingHelper.h" #include "PaintingHelper.h"
using namespace Renderer;
PaintingHelper::PaintingHelper(QOpenGLFunctions_4_5_Compatibility* glFunc) :glFunc(glFunc) PaintingHelper::PaintingHelper(QOpenGLFunctions_4_5_Compatibility* glFunc) :glFunc(glFunc)
{ {

31
ArchitectureColoredPainting/src/Renderer/Painting/PaintingHelper.h Normal file
View File

@ -0,0 +1,31 @@
#pragma once
#include <vector>
#include <QDebug>
#include <QVector4D>
#include <QOpenGLFunctions_4_5_Compatibility>
#include "BvhTree.h"
namespace Renderer
{
class PaintingHelper
{
private:
QOpenGLFunctions_4_5_Compatibility* glFunc;
GLuint paintingOffsetsSSBO, bvhSSBO, bvhBoundSSBO, elementOffsetSSBO, elementIndexSSBO, elementDataSSBO;
std::vector<GLuint> paintingOffsets;
std::vector<GLuint> bvhChildren;
std::vector<QVector4D> bvhBound;
std::vector<GLuint> elementOffset;
std::vector<GLuint> elementIndex;
std::vector<GLfloat> elementData;
int paintingCount = 0;
public:
PaintingHelper(QOpenGLFunctions_4_5_Compatibility* glFunc);
int addPainting(GLuint paintingBvhLength, std::vector<GLuint> bvhChildren, std::vector<QVector4D> bvhBound,
std::vector<GLuint> elementOffset, std::vector<GLuint> elementIndex, std::vector<GLfloat> elementData);
void allocateBuffers();
void bindPaintingBuffers();
};
}

12
ArchitectureColoredPainting/src/Renderer/ShortCutTree.cpp → ArchitectureColoredPainting/src/Renderer/Painting/ShortCutTree.cpp
View File

@ -1,6 +1,12 @@
#include "ShortCutTree.h" #include "ShortCutTree.h"
#include <qDebug> #include <qDebug>
using namespace Renderer;
using std::queue;
using std::map;
using std::for_each;
using std::set;
using std::pair;
using std::vector;
void ShortCutTree::init() { void ShortCutTree::init() {
restOfTreeNodes.clear(); restOfTreeNodes.clear();
allLine.clear(); allLine.clear();
@ -57,9 +63,9 @@ bool ShortCutTree::isLineEqual(PointIndexVector& a, PointIndexVector& b) const {
return true; return true;
} }
void ShortCutTree::monotonization(vector<PointVector>& inLines, vector<LinePtr>& outLines) { void ShortCutTree::monotonization(vector<PointVector>& inLines, vector<std::shared_ptr<Line>>& outLines) {
for (PointVector&l: inLines) { for (PointVector&l: inLines) {
LinePtr nowLine; std::shared_ptr<Line> nowLine;
switch(l.size()) { switch(l.size()) {
case 2: nowLine.reset(new StraightLine(l)); break; case 2: nowLine.reset(new StraightLine(l)); break;
case 3: case 4: nowLine.reset(new CubicBezier(l)); break; case 3: case 4: nowLine.reset(new CubicBezier(l)); break;

62
ArchitectureColoredPainting/src/Renderer/Painting/ShortCutTree.h Normal file
View File

@ -0,0 +1,62 @@
#pragma once
#include "CubicBezier.h"
#include "StraightLine.h"
#include "BvhTree.h"
#include <queue>
#include <set>
namespace Renderer
{
struct ShortCutNode {
typedef std::vector<Point> vectorPoint;
int windingIncrement, eastGroup;
bool divided;
/* type 代表进入广度优先搜索队列的节点种类：
0：不需要拆开的节点
1：需要拆分*/
QVector4D bound;
std::vector<int> lineSet;
ShortCutNode() {
divided = true;
windingIncrement = 0;
eastGroup = 0;
lineSet.clear();
bound = { 0, 0, 0, 0 };
}
~ShortCutNode() {}
};
class ShortCutTree
{
typedef std::vector<Point> PointVector;
typedef std::vector<int> PointIndexVector;
private:
std::vector<ShortCutNode> restOfTreeNodes;
std::vector<std::shared_ptr<Line>> allLine;
int RequiredLineMin, numPoint, numLine;
std::map<Point, int> pointMap;
std::vector<int> lineIndexs;
int getPointIndex(Point nowPoint);
void generateShortCutsegmentement(ShortCutNode& nowTreeNode);
bool handleShortCutNode(ShortCutNode& fa, ShortCutNode& nowTreeNode, double yValue, std::vector<ShortCutNode>& v, int& sumIncrement);
void spliteToShortCutTree();
static void monotonization(std::vector<PointVector>& inL, std::vector<std::shared_ptr<Line>>& outL);
bool isLineEqual(PointIndexVector& a, PointIndexVector& b) const;
void simplifyLineVector();
// 需要测试，随机获得合理的边界
static bool IsBorderValueResonable(double value, std::set <double>& valueSet);
static double findBorderValueNotOnLine(double value, std::set <double>& valueSet);
public:
void init();
//lineMin最小线数目，即划分终止条件
ShortCutTree(int lineMin = 3)
:RequiredLineMin(lineMin), numPoint(0), numLine(0) {}
// 传入一个vector<vector<Point> > 作为所有输入的线
void buildShortCutTree(std::vector<PointVector>& lineSet);
// 获得点集合和线集合 返回输入BvhTree的数据集合
std::vector<BvhTreeData> getPointLineAndBvhTree(std::vector<float>& pointSet, std::vector<GLuint>& lineSet);
~ShortCutTree() {}
};
}

3
ArchitectureColoredPainting/src/Renderer/StraightLine.cpp → ArchitectureColoredPainting/src/Renderer/Painting/StraightLine.cpp
View File

@ -1,5 +1,6 @@
#include "StraightLine.h" #include "StraightLine.h"
using namespace Renderer;
using std::swap;
double StraightLine::getLineValueByT(double t, bool isY) { double StraightLine::getLineValueByT(double t, bool isY) {
double valueBegin, valueEnd; double valueBegin, valueEnd;
if (isY) { if (isY) {

12
ArchitectureColoredPainting/src/Renderer/Painting/StraightLine.h Normal file
View File

@ -0,0 +1,12 @@
#include "Line.h"
namespace Renderer
{
class StraightLine : public Line
{
using Line::Line;
virtual double getLineValueByT(double t, bool isY);
virtual void monotonization(std::vector <LinePtr>& res) {};
virtual double findTByValue(double value, bool isY);
virtual int judgeBoundIntersection(double xy, double l, double r, bool isY);
};
}

29
ArchitectureColoredPainting/src/Renderer/PaintingHelper.h
View File

@ -1,29 +0,0 @@
#pragma once
#include <vector>
#include <QDebug>
#include <QVector4D>
#include <QOpenGLFunctions_4_5_Compatibility>
#include "BvhTree.h"
class PaintingHelper
{
private:
QOpenGLFunctions_4_5_Compatibility* glFunc;
GLuint paintingOffsetsSSBO, bvhSSBO, bvhBoundSSBO, elementOffsetSSBO, elementIndexSSBO, elementDataSSBO;
std::vector<GLuint> paintingOffsets;
std::vector<GLuint> bvhChildren;
std::vector<QVector4D> bvhBound;
std::vector<GLuint> elementOffset;
std::vector<GLuint> elementIndex;
std::vector<GLfloat> elementData;
int paintingCount = 0;
public:
PaintingHelper(QOpenGLFunctions_4_5_Compatibility* glFunc);
int addPainting(GLuint paintingBvhLength, std::vector<GLuint> bvhChildren, std::vector<QVector4D> bvhBound,
std::vector<GLuint> elementOffset, std::vector<GLuint> elementIndex, std::vector<GLfloat> elementData);
void allocateBuffers();
void bindPaintingBuffers();
};

2
ArchitectureColoredPainting/src/Renderer/PaintingMesh.cpp
View File

@ -1,5 +1,5 @@
#include "PaintingMesh.h" #include "PaintingMesh.h"
using namespace Renderer;
PaintingMesh::PaintingMesh(QOpenGLFunctions_4_5_Compatibility* glFunc, QOpenGLShaderProgram* shaderProgram, QOpenGLShaderProgram* shadowProgram, aiMatrix4x4 model) PaintingMesh::PaintingMesh(QOpenGLFunctions_4_5_Compatibility* glFunc, QOpenGLShaderProgram* shaderProgram, QOpenGLShaderProgram* shadowProgram, aiMatrix4x4 model)
: glFunc(glFunc) : glFunc(glFunc)
, shaderProgram(shaderProgram) , shaderProgram(shaderProgram)

57
ArchitectureColoredPainting/src/Renderer/PaintingMesh.h
View File

@ -15,34 +15,37 @@
#include <assimp/postprocess.h> #include <assimp/postprocess.h>
#include "Drawable.h" #include "Drawable.h"
struct PaintingVertex namespace Renderer
{ {
QVector3D Position; struct PaintingVertex
QVector3D Normal; {
QVector2D TexCoords; QVector3D Position;
QVector3D Tangent; QVector3D Normal;
QVector3D Bitangent; QVector2D TexCoords;
}; QVector3D Tangent;
QVector3D Bitangent;
};
class PaintingMesh : public Drawable class PaintingMesh : public Drawable
{ {
public: public:
/* 网格数据 */ /* 网格数据 */
QVector<PaintingVertex> vertices; //顶点数据 QVector<PaintingVertex> vertices; //顶点数据
QVector<unsigned int> indices; //索引数组 QVector<unsigned int> indices; //索引数组
QMatrix4x4 model; //模型矩阵 QMatrix4x4 model; //模型矩阵
QOpenGLFunctions_4_5_Compatibility* glFunc; //opengl函数入口 QOpenGLFunctions_4_5_Compatibility* glFunc; //opengl函数入口
QOpenGLShaderProgram* shaderProgram, * shadowProgram; //着色器程序 QOpenGLShaderProgram* shaderProgram, * shadowProgram; //着色器程序
GLuint paintingIndex; GLuint paintingIndex;
/* 函数 */ /* 函数 */
PaintingMesh(QOpenGLFunctions_4_5_Compatibility* glFunc, QOpenGLShaderProgram* shaderProgram, QOpenGLShaderProgram* shadowProgram, aiMatrix4x4 model); PaintingMesh(QOpenGLFunctions_4_5_Compatibility* glFunc, QOpenGLShaderProgram* shaderProgram, QOpenGLShaderProgram* shadowProgram, aiMatrix4x4 model);
void draw() override; void draw() override;
void drawShadow() override; void drawShadow() override;
void setupMesh(); void setupMesh();
private: private:
/* 渲染数据 */ /* 渲染数据 */
QOpenGLVertexArrayObject VAO; QOpenGLVertexArrayObject VAO;
QOpenGLBuffer VBO, EBO; QOpenGLBuffer VBO, EBO;
}; };
}

2
ArchitectureColoredPainting/src/Renderer/RendererGLWidget.cpp
View File

@ -6,7 +6,7 @@
#include <QScreen> #include <QScreen>
#include <QGuiApplication> #include <QGuiApplication>
#include <random> #include <random>
using namespace Renderer;
//QVector3D lightPositions[] = { 2000 * QVector3D(0.2, 4, 1).normalized(), QVector3D(100,100,100) ,QVector3D(-100,100,100) ,QVector3D(100,100,-100) }; //QVector3D lightPositions[] = { 2000 * QVector3D(0.2, 4, 1).normalized(), QVector3D(100,100,100) ,QVector3D(-100,100,100) ,QVector3D(100,100,-100) };
QVector3D lightColors[] = { 20 * QVector3D(0.7529,0.7450,0.6784).normalized(), QVector3D(0,0,0) ,QVector3D(0,0,0) ,QVector3D(0,0,0) }; QVector3D lightColors[] = { 20 * QVector3D(0.7529,0.7450,0.6784).normalized(), QVector3D(0,0,0) ,QVector3D(0,0,0) ,QVector3D(0,0,0) };
static float sunPitch = 105, sunYaw = 80; static float sunPitch = 105, sunYaw = 80;

105
ArchitectureColoredPainting/src/Renderer/RendererGLWidget.h
View File

@ -10,59 +10,60 @@
#include "Camera.h" #include "Camera.h"
#include "Light.h" #include "Light.h"
#include "Model.h" #include "Model.h"
#include "PaintingHelper.h" #include "Painting/PaintingHelper.h"
namespace Renderer
class RendererGLWidget : public QOpenGLWidget, protected QOpenGLFunctions_4_5_Compatibility
{ {
Q_OBJECT class RendererGLWidget : public QOpenGLWidget, protected QOpenGLFunctions_4_5_Compatibility
public: {
RendererGLWidget(QWidget* parent = nullptr); Q_OBJECT
~RendererGLWidget(); public:
RendererGLWidget(QWidget* parent = nullptr);
~RendererGLWidget();
void startTimer(); void startTimer();
void stopTimer(); void stopTimer();
public slots: public slots:
void setMainLightPitch(float pitch); void setMainLightPitch(float pitch);
void setMainLightYaw(float yaw); void setMainLightYaw(float yaw);
protected: protected:
void initializeGL() override; void initializeGL() override;
void paintGL() override; void paintGL() override;
void resizeGL(int width, int height) override; void resizeGL(int width, int height) override;
void timerEvent(QTimerEvent* event) override; void timerEvent(QTimerEvent* event) override;
void keyPressEvent(QKeyEvent* event) override; void keyPressEvent(QKeyEvent* event) override;
void keyReleaseEvent(QKeyEvent* event) override; void keyReleaseEvent(QKeyEvent* event) override;
void wheelEvent(QWheelEvent* event) override; void wheelEvent(QWheelEvent* event) override;
void focusInEvent(QFocusEvent* event) override; void focusInEvent(QFocusEvent* event) override;
void focusOutEvent(QFocusEvent* event) override; void focusOutEvent(QFocusEvent* event) override;
private: private:
int timerId = -1; int timerId = -1;
int frameWidth, frameHeight; int frameWidth, frameHeight;
int depthWidth, depthHeight; int depthWidth, depthHeight;
QSet<int> pressedKeys; QSet<int> pressedKeys;
Camera camera; Camera camera;
Light light; Light light;
clock_t lastFrame; clock_t lastFrame;
float deltaTime; float deltaTime;
int shadowMapResolution; int shadowMapResolution;
QOpenGLShaderProgram* shadowProgramPtr = nullptr;
QOpenGLShaderProgram* modelProgramPtr = nullptr;
QOpenGLShaderProgram* paintingProgramPtr = nullptr;
QOpenGLShaderProgram* paintingCompProgramPtr = nullptr;
QOpenGLShaderProgram* depthInitProgramPtr = nullptr;
QOpenGLShaderProgram* depthMipmapProgramPtr = nullptr;
QOpenGLShaderProgram* shadowMappingProgramPtr = nullptr;
QOpenGLShaderProgram* ssgiProgramPtr = nullptr;
QOpenGLShaderProgram* finalProgramPtr = nullptr;
QOpenGLFramebufferObject* fboPtr = nullptr;
GLuint gbuffers[10];
GLuint shadowFboHandle = 0;
GLuint shadowGbuffer;
GLuint lightSpaceMatricesUBO;
QOpenGLBuffer quadVBO;
QOpenGLVertexArrayObject quadVAO;
Model* model;
PaintingHelper* paintingHelper;
};
QOpenGLShaderProgram* shadowProgramPtr = nullptr;
QOpenGLShaderProgram* modelProgramPtr = nullptr;
QOpenGLShaderProgram* paintingProgramPtr = nullptr;
QOpenGLShaderProgram* paintingCompProgramPtr = nullptr;
QOpenGLShaderProgram* depthInitProgramPtr = nullptr;
QOpenGLShaderProgram* depthMipmapProgramPtr = nullptr;
QOpenGLShaderProgram* shadowMappingProgramPtr = nullptr;
QOpenGLShaderProgram* ssgiProgramPtr = nullptr;
QOpenGLShaderProgram* finalProgramPtr = nullptr;
QOpenGLFramebufferObject* fboPtr = nullptr;
GLuint gbuffers[10];
GLuint shadowFboHandle = 0;
GLuint shadowGbuffer;
GLuint lightSpaceMatricesUBO;
QOpenGLBuffer quadVBO;
QOpenGLVertexArrayObject quadVAO;
Model* model;
PaintingHelper* paintingHelper;
};
}

2
ArchitectureColoredPainting/src/Renderer/RendererWidget.cpp
View File

@ -1,6 +1,6 @@
#include "RendererWidget.h" #include "RendererWidget.h"
#include "RendererGLWidget.h" #include "RendererGLWidget.h"
using namespace Renderer;
RendererWidget::RendererWidget(QWidget *parent) RendererWidget::RendererWidget(QWidget *parent)
: QWidget(parent) : QWidget(parent)
{ {

24
ArchitectureColoredPainting/src/Renderer/RendererWidget.h
View File

@ -2,17 +2,19 @@
#include <QWidget> #include <QWidget>
#include "ui_RendererWidget.h" #include "ui_RendererWidget.h"
namespace Renderer
class RendererWidget : public QWidget
{ {
Q_OBJECT class RendererWidget : public QWidget
{
Q_OBJECT
public: public:
RendererWidget(QWidget *parent = nullptr); RendererWidget(QWidget* parent = nullptr);
~RendererWidget(); ~RendererWidget();
public slots: public slots:
void currentTabChanged(int index); void currentTabChanged(int index);
private: private:
Ui::RendererWidgetClass ui; Ui::RendererWidgetClass ui;
}; };
}

63
ArchitectureColoredPainting/src/Renderer/ShortCutTree.h
View File

@ -1,63 +0,0 @@
#pragma once
#include "CubicBezier.h"
#include "StraightLine.h"
#include "BvhTree.h"
#include <queue>
#include <set>
using std::queue;
using std::map;
using std::for_each;
using std::set;
struct ShortCutNode {
typedef vector<Point> vectorPoint;
int windingIncrement, eastGroup;
bool divided;
/* type 代表进入广度优先搜索队列的节点种类：
0：不需要拆开的节点
1：需要拆分*/
QVector4D bound;
vector<int> lineSet;
ShortCutNode() {
divided = true;
windingIncrement = 0;
eastGroup = 0;
lineSet.clear();
bound = { 0, 0, 0, 0 };
}
~ShortCutNode() {}
};
class ShortCutTree
{
typedef vector<Point> PointVector;
typedef vector<int> PointIndexVector;
private:
vector<ShortCutNode> restOfTreeNodes;
vector<LinePtr> allLine;
int RequiredLineMin, numPoint, numLine;
map<Point, int> pointMap;
vector<int> lineIndexs;
int getPointIndex(Point nowPoint);
void generateShortCutsegmentement(ShortCutNode& nowTreeNode);
bool handleShortCutNode(ShortCutNode& fa, ShortCutNode& nowTreeNode, double yValue, vector<ShortCutNode>& v, int& sumIncrement);
void spliteToShortCutTree();
static void monotonization(vector<PointVector>& inL, vector<LinePtr> &outL);
bool isLineEqual(PointIndexVector& a, PointIndexVector& b) const;
void simplifyLineVector();
// 需要测试，随机获得合理的边界
static bool IsBorderValueResonable(double value, set <double>& valueSet);
static double findBorderValueNotOnLine(double value, set <double>& valueSet);
public:
void init();
//lineMin最小线数目，即划分终止条件
ShortCutTree(int lineMin = 3)
:RequiredLineMin(lineMin), numPoint(0), numLine(0) {}
// 传入一个vector<vector<Point> > 作为所有输入的线
void buildShortCutTree(vector<PointVector>& lineSet);
// 获得点集合和线集合 返回输入BvhTree的数据集合
vector<BvhTreeData> getPointLineAndBvhTree(vector<float> &pointSet, vector<GLuint> &lineSet);
~ShortCutTree() {}
};

10
ArchitectureColoredPainting/src/Renderer/StraightLine.h
View File

@ -1,10 +0,0 @@
#include "Line.h"
class StraightLine : public Line
{
using Line::Line;
virtual double getLineValueByT(double t, bool isY);
virtual void monotonization(vector <LinePtr>& res) {};
virtual double findTByValue(double value, bool isY);
virtual int judgeBoundIntersection(double xy, double l, double r, bool isY);
};

2
ArchitectureColoredPainting/src/SvgParser.cpp
View File

@ -484,7 +484,7 @@ namespace SVGParser
} }
}; // namespace SVGParser }; // namespace SVGParser
using Renderer::Point;
SvgParser::SvgParser(const std::string path, double width, double height) : path(path), width(width), height(height) SvgParser::SvgParser(const std::string path, double width, double height) : path(path), width(width), height(height)
{ {
} }

304
ArchitectureColoredPainting/src/SvgParser.h
View File

@ -1,173 +1,173 @@
#pragma once #pragma once
#include "Renderer/Line.h" #include "Renderer/Painting/Line.h"
#include <cmath> #include <cmath>
#include <string> #include <string>
using namespace std;
namespace SVGParser namespace SVGParser
{ {
enum SVGCommandType enum SVGCommandType
{ {
SVG_INVALID = -1, SVG_INVALID = -1,
// SVG_MOVE_TO_REL, SVG_LINE_TO_REL, SVG_QUADRATIC_CURVE_TO_REL, SVG_CUBIC_CURVE_TO_REL, // SVG_MOVE_TO_REL, SVG_LINE_TO_REL, SVG_QUADRATIC_CURVE_TO_REL, SVG_CUBIC_CURVE_TO_REL,
// SVG_MOVE_TO_ABS, SVG_LINE_TO_ABS, SVG_QUADRATIC_CURVE_TO_ABS, SVG_CUBIC_CURVE_TO_ABS, // SVG_MOVE_TO_ABS, SVG_LINE_TO_ABS, SVG_QUADRATIC_CURVE_TO_ABS, SVG_CUBIC_CURVE_TO_ABS,
SVG_MOVE_TO_REL, SVG_MOVE_TO_REL,
SVG_MOVE_TO_ABS, SVG_MOVE_TO_ABS,
SVG_LINE_TO_REL, SVG_LINE_TO_REL,
SVG_LINE_TO_ABS, SVG_LINE_TO_ABS,
SVG_HORIZONTAL_LINE_TO_REL, SVG_HORIZONTAL_LINE_TO_REL,
SVG_HORIZONTAL_LINE_TO_ABS, SVG_HORIZONTAL_LINE_TO_ABS,
SVG_VERTICAL_LINE_TO_REL, SVG_VERTICAL_LINE_TO_REL,
SVG_VERTICAL_LINE_TO_ABS, SVG_VERTICAL_LINE_TO_ABS,
SVG_QUADRATIC_CURVE_TO_REL, SVG_QUADRATIC_CURVE_TO_REL,
SVG_QUADRATIC_CURVE_TO_ABS, SVG_QUADRATIC_CURVE_TO_ABS,
SVG_CUBIC_CURVE_TO_REL, SVG_CUBIC_CURVE_TO_REL,
SVG_CUBIC_CURVE_TO_ABS, SVG_CUBIC_CURVE_TO_ABS,
SVG_SMOOTH_CUBIC_CURVE_TO_REL, SVG_SMOOTH_CUBIC_CURVE_TO_REL,
SVG_SMOOTH_CUBIC_CURVE_TO_ABS, SVG_SMOOTH_CUBIC_CURVE_TO_ABS,
SVG_SMOOTH_QUADRATIC_CURVE_TO_REL, SVG_SMOOTH_QUADRATIC_CURVE_TO_REL,
SVG_SMOOTH_QUADRATIC_CURVE_TO_ABS, SVG_SMOOTH_QUADRATIC_CURVE_TO_ABS,
SVG_ARC_TO_REL, SVG_ARC_TO_REL,
SVG_ARC_TO_ABS, SVG_ARC_TO_ABS,
SVG_CLOSE_PATH SVG_CLOSE_PATH
}; };
bool isAbsolute(SVGCommandType); bool isAbsolute(SVGCommandType);
class SVGCommand class SVGCommand
{ {
public: public:
SVGCommand(double, double, bool = false); SVGCommand(double, double, bool = false);
static const int length; static const int length;
double x, y; double x, y;
bool absolute; bool absolute;
virtual const std::string toString() const = 0; virtual const std::string toString() const = 0;
virtual SVGCommandType getType() = 0; virtual SVGCommandType getType() = 0;
virtual std::string toString2() = 0; virtual std::string toString2() = 0;
}; };
class SVGMoveTo : public SVGCommand class SVGMoveTo : public SVGCommand
{ {
public: public:
static const int length = 2; static const int length = 2;
SVGMoveTo(double, double, bool = false); SVGMoveTo(double, double, bool = false);
virtual const std::string toString() const; virtual const std::string toString() const;
virtual SVGCommandType getType(); virtual SVGCommandType getType();
virtual std::string toString2(); virtual std::string toString2();
}; };
class SVGLineTo : public SVGCommand class SVGLineTo : public SVGCommand
{ {
public: public:
static const int length = 2; static const int length = 2;
SVGLineTo(double, double, bool = false); SVGLineTo(double, double, bool = false);
virtual const std::string toString() const; virtual const std::string toString() const;
virtual SVGCommandType getType(); virtual SVGCommandType getType();
virtual std::string toString2(); virtual std::string toString2();
}; };
class SVGHLineTo : public SVGCommand class SVGHLineTo : public SVGCommand
{ {
public: public:
static const int length = 1; static const int length = 1;
SVGHLineTo(double, bool = false); SVGHLineTo(double, bool = false);
virtual const std::string toString() const; virtual const std::string toString() const;
virtual SVGCommandType getType(); virtual SVGCommandType getType();
virtual std::string toString2(); virtual std::string toString2();
}; };
class SVGVLineTo : public SVGCommand class SVGVLineTo : public SVGCommand
{ {
public: public:
static const int length = 1; static const int length = 1;
SVGVLineTo(double, bool = false); SVGVLineTo(double, bool = false);
virtual const std::string toString() const; virtual const std::string toString() const;
virtual SVGCommandType getType(); virtual SVGCommandType getType();
virtual std::string toString2(); virtual std::string toString2();
}; };
class SVGQuadraticCurveTo : public SVGCommand class SVGQuadraticCurveTo : public SVGCommand
{ {
public: public:
SVGQuadraticCurveTo(double, double, double, double, bool = false); SVGQuadraticCurveTo(double, double, double, double, bool = false);
double x0, y0; double x0, y0;
virtual const std::string toString() const; virtual const std::string toString() const;
virtual SVGCommandType getType(); virtual SVGCommandType getType();
virtual std::string toString2(); virtual std::string toString2();
}; };
class SVGCubicCurveTo : public SVGCommand class SVGCubicCurveTo : public SVGCommand
{ {
public: public:
double x0, y0, x1, y1; double x0, y0, x1, y1;
SVGCubicCurveTo(double, double, double, double, double, double, bool = false); SVGCubicCurveTo(double, double, double, double, double, double, bool = false);
virtual const std::string toString() const; virtual const std::string toString() const;
virtual SVGCommandType getType(); virtual SVGCommandType getType();
virtual std::string toString2(); virtual std::string toString2();
}; };
class SVGSmoothQuadraticCurveTo : public SVGCommand class SVGSmoothQuadraticCurveTo : public SVGCommand
{ {
public: public:
SVGSmoothQuadraticCurveTo(double, double, bool = false); SVGSmoothQuadraticCurveTo(double, double, bool = false);
virtual const std::string toString() const; virtual const std::string toString() const;
virtual SVGCommandType getType(); virtual SVGCommandType getType();
virtual std::string toString2(); virtual std::string toString2();
}; };
class SVGSmoothCubicCurveTo : public SVGCommand class SVGSmoothCubicCurveTo : public SVGCommand
{ {
public: public:
double x1, y1; double x1, y1;
SVGSmoothCubicCurveTo(double, double, double, double, bool = false); SVGSmoothCubicCurveTo(double, double, double, double, bool = false);
virtual const std::string toString() const; virtual const std::string toString() const;
virtual SVGCommandType getType(); virtual SVGCommandType getType();
virtual std::string toString2(); virtual std::string toString2();
}; };
class SVGArcTo : public SVGCommand class SVGArcTo : public SVGCommand
{ {
public: public:
double rx, ry, rot; double rx, ry, rot;
bool large, sweep; bool large, sweep;
SVGArcTo(double, double, double, bool, bool, double, double, bool = false); SVGArcTo(double, double, double, bool, bool, double, double, bool = false);
virtual const std::string toString() const; virtual const std::string toString() const;
virtual SVGCommandType getType(); virtual SVGCommandType getType();
virtual std::string toString2(); virtual std::string toString2();
}; };
class SVGClosePath : public SVGCommand class SVGClosePath : public SVGCommand
{ {
public: public:
SVGClosePath(bool = false); SVGClosePath(bool = false);
virtual const std::string toString() const; virtual const std::string toString() const;
virtual SVGCommandType getType(); virtual SVGCommandType getType();
virtual std::string toString2(); virtual std::string toString2();
}; };
typedef vector<std::shared_ptr<SVGCommand>> SVGPath; typedef std::vector<std::shared_ptr<SVGCommand>> SVGPath;
SVGPath parsePath(std::istream &); SVGPath parsePath(std::istream&);
std::ostream &operator<<(std::ostream &, const SVGParser::SVGPath &); std::ostream& operator<<(std::ostream&, const SVGParser::SVGPath&);
std::ostream &operator<<(std::ostream &, const SVGParser::SVGCommand *); std::ostream& operator<<(std::ostream&, const SVGParser::SVGCommand*);
}; // namespace SVGParser }; // namespace SVGParser
class SvgParser class SvgParser
{ {
public: public:
SvgParser(const std::string path, const double width, const double height); SvgParser(const std::string path, const double width, const double height);
vector<vector<Point>> parse(); std::vector<std::vector<Renderer::Point>> parse();
private: private:
static constexpr const double eps = 1e-6; static constexpr const double eps = 1e-6;
static constexpr const double PI = 3.14159265358979323846; static constexpr const double PI = 3.14159265358979323846;
const std::string path; const std::string path;
const double width; const double width;
const double height; const double height;
Point convertPoint(double x, double y); Renderer::Point convertPoint(double x, double y);
Point clampPoint(Point p); Renderer::Point clampPoint(Renderer::Point p);
Point convertAbsPoint(double x, double y); Renderer::Point convertAbsPoint(double x, double y);
Point convertRelPoint(Point pointBegin, double x, double y); Renderer::Point convertRelPoint(Renderer::Point pointBegin, double x, double y);
void ellipticalArcConverter(Point beginPoint, double radiusX, double radiusY, double phi, bool flagA, void ellipticalArcConverter(Renderer::Point beginPoint, double radiusX, double radiusY, double phi, bool flagA,
bool flagS, Point endPoint,vector<vector<Point>>& lines); bool flagS, Renderer::Point endPoint, std::vector<std::vector<Renderer::Point>>& lines);
vector<double> centerConverter(Point beginPoint, double radiusX, double radiusY, double phi, bool flagA, bool flagS, std::vector<double> centerConverter(Renderer::Point beginPoint, double radiusX, double radiusY, double phi, bool flagA, bool flagS,
Point endPoint); Renderer::Point endPoint);
double angleConverter(Point u, Point v); double angleConverter(Renderer::Point u, Renderer::Point v);
Point eConverter(Point c, Point r, double cosPhi, double sinPhi, double t); Renderer::Point eConverter(Renderer::Point c, Renderer::Point r, double cosPhi, double sinPhi, double t);
Point e2Converter(Point c, Point r, double cosPhi, double sinPhi, double t); Renderer::Point e2Converter(Renderer::Point c, Renderer::Point r, double cosPhi, double sinPhi, double t);
}; };