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\MainWindow.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\CubicBezier.cpp" />
<ClCompile Include="src\Renderer\CubicMonotonization.cpp" />
<ClCompile Include="src\Renderer\Painting\CubicBezier.cpp" />
<ClCompile Include="src\Renderer\Painting\CubicMonotonization.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\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\RendererGLWidget.cpp" />
<ClCompile Include="src\Renderer\RendererWidget.cpp" />
<ClCompile Include="src\Renderer\ShortCutTree.cpp" />
<ClCompile Include="src\Renderer\StraightLine.cpp" />
<ClCompile Include="src\Renderer\Painting\ShortCutTree.cpp" />
<ClCompile Include="src\Renderer\Painting\StraightLine.cpp" />
<ClCompile Include="src\SvgParser.cpp" />
<ClCompile Include="src\TitleWidget.cpp" />
<QtRcc Include="MainWindow.qrc" />
@ -148,6 +149,7 @@
</ItemGroup>
<ItemGroup>
<QtMoc Include="src\MainWindow.h" />
<ClInclude Include="src\Renderer\Painting\Painting.h" />
<ClInclude Include="src\SvgParser.h" />
<QtMoc Include="src\TitleWidget.h" />
<QtMoc Include="src\IconWidget.h" />
@ -155,19 +157,19 @@
<QtMoc Include="src\NavigationBarWidget.h" />
<QtMoc Include="src\Renderer\RendererWidget.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\CubicBezier.h" />
<ClInclude Include="src\Renderer\CubicMonotonization.h" />
<ClInclude Include="src\Renderer\Painting\CubicBezier.h" />
<ClInclude Include="src\Renderer\Painting\CubicMonotonization.h" />
<ClInclude Include="src\Renderer\Drawable.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\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\ShortCutTree.h" />
<ClInclude Include="src\Renderer\StraightLine.h" />
<ClInclude Include="src\Renderer\Painting\ShortCutTree.h" />
<ClInclude Include="src\Renderer\Painting\StraightLine.h" />
<QtMoc Include="src\Renderer\RendererGLWidget.h" />
</ItemGroup>
<ItemGroup>

96
ArchitectureColoredPainting/ArchitectureColoredPainting.vcxproj.filters
View File

@ -35,6 +35,12 @@
<Filter Include="Resource Files\Shaders">
<UniqueIdentifier>{60515177-3da7-420f-8f5b-27c16bb2b77b}</UniqueIdentifier>
</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>
<QtUic Include="MainWindow.ui">
@ -51,45 +57,24 @@
<ClCompile Include="src\Editor\EditorWidget.cpp">
<Filter>Source Files\Editor</Filter>
</ClCompile>
<ClCompile Include="src\Renderer\BvhTree.cpp">
<Filter>Source Files\Renderer</Filter>
</ClCompile>
<ClCompile Include="src\Renderer\Camera.cpp">
<Filter>Source Files\Renderer</Filter>
</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">
<Filter>Source Files\Renderer</Filter>
</ClCompile>
<ClCompile Include="src\Renderer\Line.cpp">
<Filter>Source Files\Renderer</Filter>
</ClCompile>
<ClCompile Include="src\Renderer\Mesh.cpp">
<Filter>Source Files\Renderer</Filter>
</ClCompile>
<ClCompile Include="src\Renderer\Model.cpp">
<Filter>Source Files\Renderer</Filter>
</ClCompile>
<ClCompile Include="src\Renderer\PaintingHelper.cpp">
<Filter>Source Files\Renderer</Filter>
</ClCompile>
<ClCompile Include="src\Renderer\PaintingMesh.cpp">
<Filter>Source Files\Renderer</Filter>
</ClCompile>
<ClCompile Include="src\Renderer\RendererGLWidget.cpp">
<Filter>Source Files\Renderer</Filter>
</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">
<Filter>Source Files</Filter>
</ClCompile>
@ -114,6 +99,30 @@
<ClCompile Include="src\TitleWidget.cpp">
<Filter>Source Files</Filter>
</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>
<QtMoc Include="src\Renderer\RendererGLWidget.h">
@ -206,48 +215,51 @@
</QtUic>
</ItemGroup>
<ItemGroup>
<ClInclude Include="src\Renderer\BvhTree.h">
<Filter>Header Files\Renderer</Filter>
</ClInclude>
<ClInclude Include="src\Renderer\Camera.h">
<Filter>Header Files\Renderer</Filter>
</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">
<Filter>Header Files\Renderer</Filter>
</ClInclude>
<ClInclude Include="src\Renderer\Light.h">
<Filter>Header Files\Renderer</Filter>
</ClInclude>
<ClInclude Include="src\Renderer\Line.h">
<Filter>Header Files\Renderer</Filter>
</ClInclude>
<ClInclude Include="src\Renderer\Mesh.h">
<Filter>Header Files\Renderer</Filter>
</ClInclude>
<ClInclude Include="src\Renderer\Model.h">
<Filter>Header Files\Renderer</Filter>
</ClInclude>
<ClInclude Include="src\Renderer\PaintingHelper.h">
<Filter>Header Files\Renderer</Filter>
</ClInclude>
<ClInclude Include="src\Renderer\PaintingMesh.h">
<Filter>Header Files\Renderer</Filter>
</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">
<Filter>Header Files</Filter>
</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>
<QtRcc Include="MainWindow.qrc">

4
ArchitectureColoredPainting/MainWindow.ui
View File

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

4
ArchitectureColoredPainting/RendererWidget.ui
View File

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

2
ArchitectureColoredPainting/src/MainWindow.cpp
View File

@ -110,7 +110,7 @@ CentralWidget::CentralWidget(QWidget* parent) : QMainWindow(parent)
QObject::connect(navigationBarWidget->buttonGroup, &QButtonGroup::idClicked,
ui.tabWidget, &QTabWidget::setCurrentIndex);
QObject::connect(ui.tabWidget, &QTabWidget::currentChanged,
ui.rendererWidget, &RendererWidget::currentTabChanged);
ui.rendererWidget, &Renderer::RendererWidget::currentTabChanged);
}
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"
using namespace Renderer;
// constructor with vectors

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

@ -5,12 +5,8 @@
#include <QtMath>
#include <QOpenGLFunctions_4_5_Compatibility>
// Default camera values
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;
namespace Renderer
{
// Defines several possible options for camera movement. Used as abstraction to stay away from window-system specific input methods
enum Camera_Movement {
@ -26,6 +22,12 @@ class Camera
{
public:
// 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;
@ -68,3 +70,4 @@ private:
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);
};

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

@ -1,8 +1,10 @@
#pragma once
namespace Renderer
{
class Drawable
{
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 <qDebug>
using namespace Renderer;
Light::Light(Camera* camera)
: camera(camera)
//, shadowCascadeLevels{ camera->FarPlane / 25.0f, camera->FarPlane / 12.0f, camera->FarPlane / 6.0f, camera->FarPlane / 3.0f }

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

@ -9,6 +9,8 @@
#include "Camera.h"
#include "Model.h"
namespace Renderer
{
class Light
{
public:
@ -26,4 +28,5 @@ 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"
using namespace Renderer;
Mesh::Mesh(QOpenGLFunctions_4_5_Compatibility* glFunc, QOpenGLShaderProgram* shaderProgram, QOpenGLShaderProgram* shadowProgram, aiMatrix4x4 model)
: glFunc(glFunc)
, shaderProgram(shaderProgram)

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

@ -13,7 +13,8 @@
#include <assimp/scene.h>
#include <assimp/postprocess.h>
#include "Drawable.h"
namespace Renderer
{
struct Vertex
{
QVector3D Position;
@ -59,3 +60,4 @@ private:
QOpenGLBuffer VBO, EBO;
};
}

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

@ -6,10 +6,11 @@
#include <iostream>
#include "PaintingMesh.h"
#include <QtMath>
#include "BvhTree.h"
#include "ShortCutTree.h"
#include "Painting/BvhTree.h"
#include "Painting/ShortCutTree.h"
#include "../SvgParser.h"
using namespace Renderer;
using std::vector;
Model::Model(QString path, QOpenGLContext* context, QOpenGLShaderProgram* shaderProgram)
: context(context)
, glFunc(context->versionFunctions<QOpenGLFunctions_4_5_Compatibility>())

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

@ -2,9 +2,11 @@
#include "Mesh.h"
#include "Drawable.h"
#include "PaintingHelper.h"
#include "Painting/PaintingHelper.h"
#include <QDir>
namespace Renderer
{
class Model
{
public:
@ -48,3 +50,4 @@ private:
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"
using namespace Renderer;
GLuint BvhTree::getBvhNodeNum() {
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"
using namespace Renderer;
using std::vector;
double CubicBezier::getLineValueByT(double t, bool isY) {
vector<double> p;
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"
using namespace Renderer;
using std::vector;
using std::min;
using std::max;
using std::sort;
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"
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) {
siz = Vp.size();
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"
using namespace Renderer;
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 <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() {
restOfTreeNodes.clear();
allLine.clear();
@ -57,9 +63,9 @@ bool ShortCutTree::isLineEqual(PointIndexVector& a, PointIndexVector& b) const {
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) {
LinePtr nowLine;
std::shared_ptr<Line> nowLine;
switch(l.size()) {
case 2: nowLine.reset(new StraightLine(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"
using namespace Renderer;
using std::swap;
double StraightLine::getLineValueByT(double t, bool isY) {
double valueBegin, valueEnd;
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"
using namespace Renderer;
PaintingMesh::PaintingMesh(QOpenGLFunctions_4_5_Compatibility* glFunc, QOpenGLShaderProgram* shaderProgram, QOpenGLShaderProgram* shadowProgram, aiMatrix4x4 model)
: glFunc(glFunc)
, shaderProgram(shaderProgram)

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

@ -15,6 +15,8 @@
#include <assimp/postprocess.h>
#include "Drawable.h"
namespace Renderer
{
struct PaintingVertex
{
QVector3D Position;
@ -46,3 +48,4 @@ private:
QOpenGLBuffer VBO, EBO;
};
}

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

@ -6,7 +6,7 @@
#include <QScreen>
#include <QGuiApplication>
#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 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;

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

@ -10,8 +10,9 @@
#include "Camera.h"
#include "Light.h"
#include "Model.h"
#include "PaintingHelper.h"
#include "Painting/PaintingHelper.h"
namespace Renderer
{
class RendererGLWidget : public QOpenGLWidget, protected QOpenGLFunctions_4_5_Compatibility
{
Q_OBJECT
@ -65,4 +66,4 @@ private:
Model* model;
PaintingHelper* paintingHelper;
};
}

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

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

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

@ -2,7 +2,8 @@
#include <QWidget>
#include "ui_RendererWidget.h"
namespace Renderer
{
class RendererWidget : public QWidget
{
Q_OBJECT
@ -16,3 +17,4 @@ public slots:
private:
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
using Renderer::Point;
SvgParser::SvgParser(const std::string path, double width, double height) : path(path), width(width), height(height)
{
}

30
ArchitectureColoredPainting/src/SvgParser.h
View File

@ -1,9 +1,9 @@
#pragma once
#include "Renderer/Line.h"
#include "Renderer/Painting/Line.h"
#include <cmath>
#include <string>
using namespace std;
namespace SVGParser
{
enum SVGCommandType
@ -140,7 +140,7 @@ class SVGClosePath : public SVGCommand
virtual SVGCommandType getType();
virtual std::string toString2();
};
typedef vector<std::shared_ptr<SVGCommand>> SVGPath;
typedef std::vector<std::shared_ptr<SVGCommand>> SVGPath;
SVGPath parsePath(std::istream&);
std::ostream& operator<<(std::ostream&, const SVGParser::SVGPath&);
@ -150,7 +150,7 @@ class SvgParser
{
public:
SvgParser(const std::string path, const double width, const double height);
vector<vector<Point>> parse();
std::vector<std::vector<Renderer::Point>> parse();
private:
static constexpr const double eps = 1e-6;
@ -159,15 +159,15 @@ class SvgParser
const double width;
const double height;
Point convertPoint(double x, double y);
Point clampPoint(Point p);
Point convertAbsPoint(double x, double y);
Point convertRelPoint(Point pointBegin, double x, double y);
void ellipticalArcConverter(Point beginPoint, double radiusX, double radiusY, double phi, bool flagA,
bool flagS, Point endPoint,vector<vector<Point>>& lines);
vector<double> centerConverter(Point beginPoint, double radiusX, double radiusY, double phi, bool flagA, bool flagS,
Point endPoint);
double angleConverter(Point u, Point v);
Point eConverter(Point c, Point r, double cosPhi, double sinPhi, double t);
Point e2Converter(Point c, Point r, double cosPhi, double sinPhi, double t);
Renderer::Point convertPoint(double x, double y);
Renderer::Point clampPoint(Renderer::Point p);
Renderer::Point convertAbsPoint(double x, double y);
Renderer::Point convertRelPoint(Renderer::Point pointBegin, double x, double y);
void ellipticalArcConverter(Renderer::Point beginPoint, double radiusX, double radiusY, double phi, bool flagA,
bool flagS, Renderer::Point endPoint, std::vector<std::vector<Renderer::Point>>& lines);
std::vector<double> centerConverter(Renderer::Point beginPoint, double radiusX, double radiusY, double phi, bool flagA, bool flagS,
Renderer::Point endPoint);
double angleConverter(Renderer::Point u, Renderer::Point v);
Renderer::Point eConverter(Renderer::Point c, Renderer::Point r, double cosPhi, double sinPhi, double t);
Renderer::Point e2Converter(Renderer::Point c, Renderer::Point r, double cosPhi, double sinPhi, double t);
};