Merge branch 'main' into dev-LayerStyle

# Conflicts: # ArchitectureColoredPainting/src/Editor/GraphicElement.cpp
修改了LayerStyle
2023-03-14 18:01:22 +08:00 · 2023-03-14 17:59:46 +08:00 · 2023-03-14 17:57:58 +08:00 · 2023-03-14 15:36:19 +08:00 · 2023-03-14 15:14:28 +08:00 · 2023-03-14 15:14:25 +08:00
27 changed files with 596 additions and 140 deletions
--- a/ArchitectureColoredPainting/ArchitectureColoredPainting.vcxproj
+++ b/ArchitectureColoredPainting/ArchitectureColoredPainting.vcxproj
@ -104,6 +104,7 @@
    </Link>
  </ItemDefinitionGroup>
  <ItemGroup>
+    <ClCompile Include="src\Editor\EditorWidgetComponent\ColorPicker.cpp" />
    <ClCompile Include="src\Editor\EditorWidgetComponent\LayerCreateWidget.cpp" />
    <ClCompile Include="src\Editor\EditorWidgetComponent\LayerStyleDialog.cpp" />
    <ClCompile Include="src\Editor\EditorWidget.cpp" />
@ -145,12 +146,14 @@
    <ClCompile Include="src\Renderer\Painting\MaterialStyleStroke.cpp" />
    <ClCompile Include="src\Renderer\Painting\Painting.cpp" />
    <ClCompile Include="src\Renderer\PaintingMesh.cpp" />
+    <ClCompile Include="src\Renderer\Preview\ElementRenderer.cpp" />
    <ClCompile Include="src\Renderer\RendererGLWidget.cpp" />
    <ClCompile Include="src\Renderer\RendererWidget.cpp" />
    <ClCompile Include="src\Renderer\Painting\ShortCutTree.cpp" />
    <ClCompile Include="src\Renderer\Painting\StraightLine.cpp" />
    <ClCompile Include="src\Renderer\VirtualTextureManager.cpp" />
    <ClCompile Include="src\SvgParser.cpp" />
+    <ClCompile Include="src\Editor\EditorWidgetComponent\StrokeStyleListView.cpp" />
    <QtUic Include="EditorWidget.ui" />
    <QtUic Include="EditorWidgetItem.ui" />
    <QtUic Include="MainWindow.ui" />
@ -186,12 +189,14 @@
    <None Include="res\Shaders\ssgi.comp" />
  </ItemGroup>
  <ItemGroup>
+    <QtMoc Include="src\Editor\EditorWidgetComponent\StrokeStyleListView.h" />
    <QtMoc Include="src\Editor\RightBar\LayerTreeWidget.h" />
    <QtMoc Include="src\Editor\RightBar\InfoDisplayWidget.h" />
    <QtMoc Include="src\MainWindow.h" />
    <QtMoc Include="src\Editor\EditorWidget.h" />
    <QtMoc Include="src\Editor\EditorWidgetComponent\LayerCreateWidget.h" />
    <QtMoc Include="src\Editor\EditorWidgetComponent\LayerStyleDialog.h" />
+    <QtMoc Include="src\Editor\EditorWidgetComponent\ColorPicker.h" />
    <ClInclude Include="src\Editor\ElementManager.h" />
    <QtMoc Include="src\Editor\ElementPoolWidget.h" />
    <ClInclude Include="src\Editor\GraphicElement.h" />
--- a/ArchitectureColoredPainting/ArchitectureColoredPainting.vcxproj.filters
+++ b/ArchitectureColoredPainting/ArchitectureColoredPainting.vcxproj.filters
@ -59,9 +59,18 @@
    <Filter Include="Source Files\Editor\util">
      <UniqueIdentifier>{96f98afe-4250-44cb-a505-682a1d5932c3}</UniqueIdentifier>
    </Filter>
+    <Filter Include="Source Files\Renderer\Preview">
+      <UniqueIdentifier>{2a8e109f-7791-46ad-8c86-fe22a651cbe7}</UniqueIdentifier>
+    </Filter>
    <Filter Include="Header Files\Renderer\Preview">
      <UniqueIdentifier>{7ead1a66-586a-4584-ae80-9e7a4e667364}</UniqueIdentifier>
    </Filter>
+    <Filter Include="Header Files\Editor\Style">
+      <UniqueIdentifier>{be3f4585-c8ba-410f-8619-2adcd4349f02}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Source Files\Editor\Style">
+      <UniqueIdentifier>{b9732a33-aa2e-4f8d-886f-1b1730c66519}</UniqueIdentifier>
+    </Filter>
  </ItemGroup>
  <ItemGroup>
    <QtUic Include="MainWindow.ui">
@ -108,9 +117,6 @@
    <ClCompile Include="src\Renderer\RendererWidget.cpp">
      <Filter>Source Files\Renderer</Filter>
    </ClCompile>
-    <ClCompile Include="src\NavigationBarWidget.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
    <ClCompile Include="src\Renderer\Painting\BvhTree.cpp">
      <Filter>Source Files\Renderer\Painting</Filter>
    </ClCompile>
@ -153,12 +159,6 @@
    <ClCompile Include="src\Renderer\Painting\CubicBezierSignedDistance.cpp">
      <Filter>Source Files\Renderer\Painting</Filter>
    </ClCompile>
-    <ClCompile Include="src\Editor\RightBar\LayerTreeWidget.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="src\Editor\RightBar\InfoDisplayWidget.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
    <ClCompile Include="src\Renderer\Painting\ElementStyle.cpp">
      <Filter>Source Files\Renderer\Painting</Filter>
    </ClCompile>
@ -183,8 +183,8 @@
    <ClCompile Include="src\Editor\util\PainterPathUtil.cpp">
      <Filter>Source Files\Editor\util</Filter>
    </ClCompile>
-    <ClCompile Include="src\Editor\LayerStyle.cpp">
-      <Filter>Source Files</Filter>
+    <ClCompile Include="src\Renderer\Preview\ElementRenderer.cpp">
+      <Filter>Source Files\Renderer\Preview</Filter>
    </ClCompile>
    <ClCompile Include="src\Renderer\IblUtils.cpp">
      <Filter>Source Files\Renderer</Filter>
@ -210,11 +210,29 @@
    <ClCompile Include="src\Editor\util\PaintingUtil.cpp">
      <Filter>Source Files\Editor\util</Filter>
    </ClCompile>
-    <ClCompile Include="src\Editor\EditorWidgetComponent\LayerCreateWidget.cpp">
-      <Filter>Source Files</Filter>
+    <ClCompile Include="src\Editor\LayerStyle.cpp">
+      <Filter>Source Files\Editor\Style</Filter>
    </ClCompile>
    <ClCompile Include="src\Editor\EditorWidgetComponent\LayerStyleDialog.cpp">
-      <Filter>Source Files</Filter>
+      <Filter>Source Files\Editor\Style</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Editor\EditorWidgetComponent\StrokeStyleListView.cpp">
+      <Filter>Source Files\Editor\Style</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Editor\RightBar\InfoDisplayWidget.cpp">
+      <Filter>Source Files\Editor</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Editor\EditorWidgetComponent\LayerCreateWidget.cpp">
+      <Filter>Source Files\Editor</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Editor\RightBar\LayerTreeWidget.cpp">
+      <Filter>Source Files\Editor</Filter>
+    </ClCompile>
+    <ClCompile Include="src\NavigationBarWidget.cpp">
+      <Filter>Source Files\Editor</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Editor\EditorWidgetComponent\ColorPicker.cpp">
+      <Filter>Source Files\Editor</Filter>
    </ClCompile>
  </ItemGroup>
  <ItemGroup>
@ -227,35 +245,41 @@
    <QtMoc Include="src\Renderer\RendererWidget.h">
      <Filter>Header Files\Renderer</Filter>
    </QtMoc>
-    <QtMoc Include="src\NavigationBarWidget.h">
-      <Filter>Header Files</Filter>
-    </QtMoc>
-    <QtMoc Include="src\MainWindow.h">
-      <Filter>Header Files</Filter>
-    </QtMoc>
    <QtMoc Include="src\Editor\PreviewWindow.h">
      <Filter>Header Files\Editor</Filter>
    </QtMoc>
-    <QtMoc Include="src\Editor\RightBar\LayerTreeWidget.h">
-      <Filter>Header Files</Filter>
-    </QtMoc>
-    <QtMoc Include="src\Editor\RightBar\InfoDisplayWidget.h">
-      <Filter>Header Files</Filter>
-    </QtMoc>
-    <QtMoc Include="src\Editor\EditorWidget.h">
-      <Filter>Header Files</Filter>
-    </QtMoc>
    <QtMoc Include="src\Editor\ElementPoolWidget.h">
      <Filter>Header Files\Editor</Filter>
    </QtMoc>
    <QtMoc Include="src\FluentMenu.h">
      <Filter>Header Files</Filter>
    </QtMoc>
-    <QtMoc Include="src\Editor\EditorWidgetComponent\LayerCreateWidget.h">
-      <Filter>Header Files</Filter>
+    <QtMoc Include="src\Editor\EditorWidgetComponent\StrokeStyleListView.h">
+      <Filter>Header Files\Editor\Style</Filter>
    </QtMoc>
    <QtMoc Include="src\Editor\EditorWidgetComponent\LayerStyleDialog.h">
-      <Filter>Header Files</Filter>
+      <Filter>Header Files\Editor\Style</Filter>
+    </QtMoc>
+    <QtMoc Include="src\Editor\RightBar\InfoDisplayWidget.h">
+      <Filter>Header Files\Editor</Filter>
+    </QtMoc>
+    <QtMoc Include="src\Editor\EditorWidgetComponent\LayerCreateWidget.h">
+      <Filter>Header Files\Editor</Filter>
+    </QtMoc>
+    <QtMoc Include="src\Editor\EditorWidget.h">
+      <Filter>Header Files\Editor</Filter>
+    </QtMoc>
+    <QtMoc Include="src\Editor\RightBar\LayerTreeWidget.h">
+      <Filter>Header Files\Editor</Filter>
+    </QtMoc>
+    <QtMoc Include="src\MainWindow.h">
+      <Filter>Header Files\Editor</Filter>
+    </QtMoc>
+    <QtMoc Include="src\NavigationBarWidget.h">
+      <Filter>Header Files\Editor</Filter>
+    </QtMoc>
+    <QtMoc Include="src\Editor\EditorWidgetComponent\ColorPicker.h">
+      <Filter>Header Files\Editor</Filter>
    </QtMoc>
  </ItemGroup>
  <ItemGroup>
@ -451,7 +475,7 @@
      <Filter>Header Files\Editor\util</Filter>
    </ClInclude>
    <ClInclude Include="src\Editor\LayerStyle.h">
-      <Filter>Header Files\Editor</Filter>
+      <Filter>Header Files\Editor\Style</Filter>
    </ClInclude>
  </ItemGroup>
  <ItemGroup>
--- a/ArchitectureColoredPainting/EditorWidgetItem.ui
+++ b/ArchitectureColoredPainting/EditorWidgetItem.ui
@ -6,8 +6,8 @@
   <rect>
    <x>0</x>
    <y>0</y>
-    <width>1124</width>
-    <height>1010</height>
+    <width>1473</width>
+    <height>1103</height>
   </rect>
  </property>
  <property name="minimumSize">
@ -56,7 +56,20 @@
         <widget class="QWidget" name="LeftBar" native="true"/>
        </item>
        <item>
-         <widget class="PreviewWindow" name="Preview"/>
+         <widget class="PreviewWindow" name="Preview">
+          <property name="minimumSize">
+           <size>
+            <width>1080</width>
+            <height>1080</height>
+           </size>
+          </property>
+          <property name="maximumSize">
+           <size>
+            <width>1080</width>
+            <height>1080</height>
+           </size>
+          </property>
+         </widget>
        </item>
        <item>
         <widget class="QWidget" name="RightBar" native="true">
--- a/ArchitectureColoredPainting/res/Shaders/painting.comp
+++ b/ArchitectureColoredPainting/res/Shaders/painting.comp
@ -1190,7 +1190,7 @@ void main()
 	//imageStore(gBaseColor, pixelLocation, vec4(uv,1,1));
 	//imageStore(gMetallicRoughness, pixelLocation, vec4(uv,1,1));
 	//return;
-	uv = vec2(1)-uv*2;
+	uv = uv*2-vec2(1);
 	//vec2 uv = imageLoad(gPaintingTexCoord, pixelLocation).rg;

 	vec3 debugBVH = vec3(0);
--- a/ArchitectureColoredPainting/src/Editor/EditorWidgetComponent/ColorPicker.cpp
+++ b/ArchitectureColoredPainting/src/Editor/EditorWidgetComponent/ColorPicker.cpp
@ -0,0 +1,38 @@
+#include "ColorPicker.h"
+#include <QColorDialog>
+
+QString getStyleSheet(const QColor& color)
+{
+	return 
+		"QPushButton#colorPicker {"
+		"	border-style: solid;"
+		"	border-width: 1px;"
+		"	border-color: black;"
+		"	background-color: " + color.name() + ";"
+		"}";
+}
+
+ColorPicker::ColorPicker(const QColor& color, QWidget* parent) : QPushButton(parent), color(color)
+{
+	this->setObjectName("colorPicker");
+	this->setStyleSheet(getStyleSheet(color));
+	connect(this, &QPushButton::clicked, this, &ColorPicker::onClicked);
+}
+
+QColor ColorPicker::getColor() const
+{
+	return color;
+}
+
+void ColorPicker::onClicked()
+{
+	QColorDialog dialog(this->color, this);
+	dialog.exec();
+	QColor newColor = dialog.selectedColor();
+	if (newColor.isValid() && this->color != newColor)
+	{
+		this->color = newColor;
+		this->setStyleSheet(getStyleSheet(newColor));
+		emit colorChanged(newColor);
+	}
+}
--- a/ArchitectureColoredPainting/src/Editor/EditorWidgetComponent/ColorPicker.h
+++ b/ArchitectureColoredPainting/src/Editor/EditorWidgetComponent/ColorPicker.h
@ -0,0 +1,16 @@
+#pragma once
+#include <QPushButton>
+class ColorPicker : public QPushButton
+{
+	Q_OBJECT
+private:
+	QColor color;
+public:
+	ColorPicker(const QColor& color, QWidget* parent = nullptr);
+	QColor getColor() const;
+public slots:
+	void onClicked();
+signals:
+	void colorChanged(QColor newColor);
+};
+
--- a/ArchitectureColoredPainting/src/Editor/EditorWidgetComponent/LayerStyleDialog.cpp
+++ b/ArchitectureColoredPainting/src/Editor/EditorWidgetComponent/LayerStyleDialog.cpp
@ -18,7 +18,7 @@ LayerStyleDialog::LayerStyleDialog(

 	if (existedStyle) 
 	{
-		this->modifyingStyle = existedStyle->clonePtr();
+		this->modifyingStyle = existedStyle->clone();

 		this->styleContainer = nullptr;
 		this->styleWidget = modifyingStyle->getInputWidget();
--- a/ArchitectureColoredPainting/src/Editor/EditorWidgetComponent/StrokeStyleListView.cpp
+++ b/ArchitectureColoredPainting/src/Editor/EditorWidgetComponent/StrokeStyleListView.cpp
@ -0,0 +1,95 @@
+#include "StrokeStyleListView.h"
+#include "ColorPicker.h"
+
+constexpr int COLUMN_WIDTH = 0;
+constexpr int COLUMN_COLOR = 1;
+constexpr int COLUMN_METALLIC = 2;
+constexpr int COLUMN_ROUGHNESS = 3;
+
+StrokeStyleListView::StrokeStyleListView(
+	std::shared_ptr<Renderer::StrokeRadialGradient> stroke,
+	QWidget* parent
+) : QTableWidget(parent), stroke(stroke)
+{
+	this->setSizeAdjustPolicy(QAbstractScrollArea::AdjustToContentsOnFirstShow);
+	this->setColumnCount(4);
+	this->setRowCount(stroke->materialMap.size());
+	QStringList headers;
+	headers.append(QStringLiteral("×ÜÏß¿íÕ¼±È"));
+	headers.append(QStringLiteral("ÑÕÉ«"));
+	headers.append(QStringLiteral("½ðÊô¶È"));
+	headers.append(QStringLiteral("´Ö²Ú¶È"));
+	this->setHorizontalHeaderLabels(headers);
+	for (int row = 0; auto& strokePair : stroke->materialMap)
+	{
+		QTableWidgetItem* widthItem = new QTableWidgetItem;
+		widthItem->setData(Qt::EditRole, strokePair.first);
+		this->setItem(row, COLUMN_WIDTH, widthItem);
+
+		QColor* colorPtr = &(strokePair.second.color);
+		QTableWidgetItem* colorItem = new QTableWidgetItem;
+		colorItem->setData(Qt::DisplayRole, *colorPtr);
+		this->setItem(row, COLUMN_COLOR, colorItem);
+		ColorPicker* colorPicker = new ColorPicker(*colorPtr, this);
+		this->setCellWidget(row, COLUMN_COLOR, colorPicker);
+		connect(colorPicker, &ColorPicker::colorChanged, [this, colorPtr](QColor color) {
+			*colorPtr = color;
+			this->update();
+			});
+
+		QTableWidgetItem* metallicItem = new QTableWidgetItem;
+		metallicItem->setData(Qt::EditRole, strokePair.second.metallic);
+		this->setItem(row, COLUMN_METALLIC, metallicItem);
+
+		QTableWidgetItem* roughnessItem = new QTableWidgetItem;
+		roughnessItem->setData(Qt::EditRole, strokePair.second.roughness);
+		this->setItem(row, COLUMN_ROUGHNESS, roughnessItem);
+
+		row++;
+	}
+	connect(this, &StrokeStyleListView::currentItemChanged, this, &StrokeStyleListView::onCurrentItemChanged);
+	connect(this, &StrokeStyleListView::cellChanged, this, &StrokeStyleListView::onCellChanged);
+	this->adjustSize();
+}
+
+void StrokeStyleListView::onCurrentItemChanged(QTableWidgetItem* current, QTableWidgetItem* previous)
+{
+	int column = current->column();
+	if (column != COLUMN_COLOR)
+	{
+		this->currentItemValue = current->text();
+	}
+}
+
+void StrokeStyleListView::onCellChanged(int row, int column)
+{
+	auto changedItem = this->item(row, column);
+	auto changedItemValue = changedItem->text().toFloat();
+	if (changedItemValue < 0 || 1 < changedItemValue)
+	{
+		changedItem->setData(Qt::EditRole, this->currentItemValue.toFloat());
+		return;
+	}
+	auto changedWidth = this->item(row, COLUMN_WIDTH)->text().toFloat();
+	switch (row)
+	{
+	case COLUMN_WIDTH:
+	{
+		float oldWidth = this->currentItemValue.toFloat();
+		auto node = stroke->materialMap.extract(oldWidth);
+		node.key() = changedWidth;
+		stroke->materialMap.insert(std::move(node));
+		break;
+	}
+	case COLUMN_METALLIC:
+	{
+		stroke->materialMap[changedWidth].metallic = changedItemValue;
+		break;
+	}
+	case COLUMN_ROUGHNESS:
+	{
+		stroke->materialMap[changedWidth].roughness = changedItemValue;
+		break;
+	}
+	}
+}
--- a/ArchitectureColoredPainting/src/Editor/EditorWidgetComponent/StrokeStyleListView.h
+++ b/ArchitectureColoredPainting/src/Editor/EditorWidgetComponent/StrokeStyleListView.h
@ -0,0 +1,21 @@
+#pragma once
+#include "LayerStyle.h"
+#include "../Renderer/Painting/MaterialStyleStroke.h"
+#include <QListView>
+#include <QListWidget>
+#include <QTableWidget>
+class StrokeStyleListView : public QTableWidget
+{
+	Q_OBJECT
+private:
+	QString currentItemValue;
+
+public:
+	StrokeStyleListView(std::shared_ptr<Renderer::StrokeRadialGradient> stroke, QWidget* parent = nullptr);
+	std::shared_ptr<Renderer::StrokeRadialGradient> stroke;
+
+protected slots:
+	void onCurrentItemChanged(QTableWidgetItem* current, QTableWidgetItem* previous);
+	void onCellChanged(int row, int column);
+};
+
--- a/ArchitectureColoredPainting/src/Editor/EditorWidgetItem.cpp
+++ b/ArchitectureColoredPainting/src/Editor/EditorWidgetItem.cpp
@ -14,6 +14,8 @@ EditorWidgetItem::EditorWidgetItem(QString filePath,QWidget *parent) : QWidget(p
    elementInfoDisplayWidget = dynamic_cast<ElementPoolWidget *>(tabWidget->widget(1));
    qDebug() << layerInfoDisplayWidget;
    qDebug() << elementInfoDisplayWidget;
+	connect(previewWindow, &PreviewWindow::layerInfoChanged, layerInfoDisplayWidget, &InfoDisplayWidget::triggerSelfRefresh);
+	connect(treeWidget, &LayerTreeWidget::displayLayerChange, previewWindow, &PreviewWindow::currentLayerChanged);
 	connect(treeWidget, &LayerTreeWidget::requireRefreshElementWidget, elementInfoDisplayWidget, &ElementPoolWidget::refresh);
    connect(layerInfoDisplayWidget, &InfoDisplayWidget::requireRefreshElementWidget, elementInfoDisplayWidget, &ElementPoolWidget::refresh);
    connect(treeWidget, &LayerTreeWidget::displayLayerChange, this, &EditorWidgetItem::onLayerChange);
@ -57,7 +59,11 @@ EditorWidgetItem::~EditorWidgetItem()

 void EditorWidgetItem::paintEvent(QPaintEvent *event)
 {
+    QPainter painter(this);

+    // 设置画刷的颜色为灰色，并填充整个窗口区域
+    painter.setBrush(Qt::gray);
+    painter.drawRect(this->rect());
 }

 void EditorWidgetItem::onLayerChange(LayerWrapper *layer)
--- a/ArchitectureColoredPainting/src/Editor/GraphicElement.cpp
+++ b/ArchitectureColoredPainting/src/Editor/GraphicElement.cpp
@ -11,7 +11,7 @@ PixelPath SimpleElement::getPaintObject() const

 void SimpleElement::loadSvgFile(const QString& filePath)
 {
-	// TODO 样式问题
+	// TODO <EFBFBD><EFBFBD>ʽ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>
 	SvgFileLoader loader;
 	loader.loadSvgFile(filePath, painterPath);
 	qDebug() << "load svg file success " << painterPath.elementCount();
@ -21,7 +21,7 @@ SimpleElement::SimpleElement(QJsonObject jsonSource) : jsonSource(jsonSource)
 {
 	painterPath.clear();
 	//loadSvgFile("D:\\Projects\\BigC\\svg\\3.svg");
-	loadSvgFile("../"/*TODO: 改成json文件所在文件夹路径*/ + jsonSource.value("data").toObject().value("include").toString());
+	loadSvgFile("../"/*TODO: <EFBFBD>ĳ<EFBFBD>json<EFBFBD>ļ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><EFBFBD><EFBFBD>·<EFBFBD><EFBFBD>*/ + jsonSource.value("data").toObject().value("include").toString());
 }

 GroupElement::GroupElement(FolderLayerWrapper* sourceLayer)
@ -47,16 +47,19 @@ PixelPath SimpleElement::getPaintObject(std::vector<std::shared_ptr<LayerStyle>>
 	PixelPath result;
 	//Renderer::ElementStyleStrokeDemo demo(2);
 	std::shared_ptr<Renderer::ElementStyle> style;
-	if ((*styles).empty()) 
+	if ((*styles).empty())
 	{
 		style = std::make_shared<Renderer::ElementStyleStrokeDemo>(2);
 	}
 	else
 	{
 		style = (*styles)[0];
-		qDebug() << std::dynamic_pointer_cast<Renderer::StrokePlain>(
+		/*qDebug() << std::dynamic_pointer_cast<Renderer::StrokePlain>(
 			std::dynamic_pointer_cast<StrokeElementLayerStyle>(style)->materialStyles[0]->materialStroke
-			)->material.color.name();
+			)->material.color.name();*/
+		/*qDebug() << std::dynamic_pointer_cast<Renderer::StrokeRadialGradient>(
+			std::dynamic_pointer_cast<StrokeElementLayerStyle>(style)->materialStyles[0]->materialStroke
+			)->materialMap[1.0].color;*/
 	}
 	auto [img, mov] = renderer->drawElement(painterPath, *style, 1.0);
 	//qDebug() << img << " ------";
@ -88,10 +91,34 @@ PixelPath GroupElement::getPaintObject(std::vector<std::shared_ptr<LayerStyle>>*
 //		rawPath.addPath(path);
 //	}
 //}
-//TODO : 添加细节
+//TODO : <EFBFBD><EFBFBD><EFBFBD>ϸ<EFBFBD><EFBFBD>
 QJsonObject GraphicElement::toJson() const
 {
 	QJsonObject result;
 	result.insert("name", name);
 	return result;
+}
+
+void SimpleElement::paint(QPainter* painter, QTransform transform, vector<std::shared_ptr<LayerStyle>> styles)
+{
+	painter->save();
+	painter->setTransform(transform);
+	if (styles.empty())
+	{
+		painter->drawPath(painterPath);
+	}
+	else
+	{
+		// TODO:Ӧ<><D3A6>style
+		Renderer::ElementStyleStrokeDemo demo(2);
+		auto [img, mov] = renderer->drawElement(painterPath, demo, 1.0);
+		painter->drawImage(mov, img);
+	}
+
+	painter->restore();
+}
+
+void GroupElement::paint(QPainter* painter, QTransform transform, vector<std::shared_ptr<LayerStyle>> styles)
+{
+	sourceLayer->paint(painter, transform);
 }
--- a/ArchitectureColoredPainting/src/Editor/GraphicElement.h
+++ b/ArchitectureColoredPainting/src/Editor/GraphicElement.h
@ -28,6 +28,7 @@ public:
 	virtual QJsonObject toJson() const;
    virtual PixelPath getPaintObject() const = 0;
    virtual PixelPath getPaintObject(std::vector<std::shared_ptr<LayerStyle>>*) const = 0;
+    virtual void paint(QPainter* painter, QTransform transform, std::vector<std::shared_ptr<LayerStyle>> styles) = 0;
 };

 class SimpleElement : public GraphicElement
@ -44,6 +45,7 @@ public:
    ~SimpleElement() = default;
    PixelPath getPaintObject() const override;
    PixelPath getPaintObject(std::vector<std::shared_ptr<LayerStyle>>*) const override;
+    void paint(QPainter* painter, QTransform transform, std::vector<std::shared_ptr<LayerStyle>> styles) override;
 };

 class GroupElement : public GraphicElement
@ -58,6 +60,7 @@ public:
    PixelPath getPaintObject() const override;
    PixelPath getPaintObject(std::vector<std::shared_ptr<LayerStyle>>*) const override;
    void setSourceLayer(FolderLayerWrapper* sourceLayer);
+    void paint(QPainter* painter, QTransform transform, std::vector<std::shared_ptr<LayerStyle>> styles) override;
 };

 //********************************  BitmapPath  ********************************//
--- a/ArchitectureColoredPainting/src/Editor/LayerManager.cpp
+++ b/ArchitectureColoredPainting/src/Editor/LayerManager.cpp
@ -11,10 +11,10 @@ LayerWrapper *LayerManager::getRoot() const
 {
    return root;
 }
-void LayerManager::paint(QPainter *painter, QSize size) const
+void LayerManager::paint(QPainter *painter, QSize size,LayerWrapper* selecetedLayer) const
 {
-    auto p = root->getCache().resizedPixel(size);
-	painter->drawPixmap(0, 0, p);
+    root->getCache();
+    root->paint(painter);
 }
 bool LayerManager::singleSelectedCheck() const
 {
--- a/ArchitectureColoredPainting/src/Editor/LayerManager.h
+++ b/ArchitectureColoredPainting/src/Editor/LayerManager.h
@ -32,7 +32,7 @@ class LayerManager
    LayerManager() = default;
 	LayerManager(QJsonObject source, ElementManager* elementManager);
 	QJsonObject toJson() const;
-    void paint(QPainter *painter, QSize size) const;
+    void paint(QPainter *painter, QSize size, LayerWrapper* selecetedLayer=nullptr) const;
    bool rename(QString newName) const;
    bool combine() const;
    // bool seperate() const;
--- a/ArchitectureColoredPainting/src/Editor/LayerStyle.cpp
+++ b/ArchitectureColoredPainting/src/Editor/LayerStyle.cpp
@ -1,10 +1,13 @@
 #include "LayerStyle.h"
+#include "./EditorWidgetComponent/StrokeStyleListView.h"
+#include <qtmaterialcheckbox.h>
 #include <QHBoxLayout>
 #include <QDialogButtonBox>
 #include <QPushButton>
 #include <QLabel>
 #include <QLineEdit>
 #include <QObject>
+#include <QDebug>

 const std::vector<std::pair<QString, std::function<std::unique_ptr<LayerStyle>()>>> LayerStyle::types = {
    {
@ -20,10 +23,24 @@ const std::vector<std::pair<QString, std::function<std::unique_ptr<LayerStyle>()
 std::vector<Renderer::BaseStyle> StrokeElementLayerStyle::toBaseStyles() const
 {
    std::vector<Renderer::BaseStyle> baseStyles;
-    for (auto materialStyle : materialStyles)
+    /*for (auto materialStyle : materialStyles)
    {
        baseStyles.push_back(Renderer::BaseStyle(std::make_shared<Renderer::TransformStyle>(),
            materialStyle));
+    }*/
+    if (enableEachSideIndependent)
+    {
+        baseStyles.push_back(Renderer::BaseStyle(std::make_shared<Renderer::TransformStyle>(),
+            strokePair.first));
+        baseStyles.push_back(Renderer::BaseStyle(std::make_shared<Renderer::TransformStyle>(),
+            strokePair.second));
+    }
+    else
+    {
+        strokePair.first->strokeType = Renderer::StrokeType::kBothSides;
+        baseStyles.push_back(Renderer::BaseStyle(std::make_shared<Renderer::TransformStyle>(),
+            strokePair.first));
+        strokePair.first->strokeType = Renderer::StrokeType::kLeftSide;
    }
    return baseStyles;
 }
@ -35,34 +52,61 @@ QString StrokeElementLayerStyle::getStyleName() const

 QWidget* StrokeElementLayerStyle::getInputWidget()
 {
-    // TODO
-    if (this->materialStyles.empty())
+    if (this->strokePair.first == nullptr)
    {
-        /*auto materialMap = std::map<float, Renderer::Material>();
-        materialMap[1.0] = Renderer::Material{ QColor(0,255,255), 1.0f, 1.0f };
-        this->materialStyles.push_back(std::shared_ptr<Renderer::MaterialStyleStroke>(new Renderer::MaterialStyleStroke(
-            0, 
-            Renderer::StrokeType::kBothSides, Renderer::StrokeEndType::kFlat, 
+        auto materialMap = std::map<float, Renderer::Material>();
+        materialMap[0.3] = Renderer::Material{ QColor(0,255,255), 0.f, .8f };
+        materialMap[1.0] = Renderer::Material{ QColor(80,25,255), 0.f, .8f };
+        this->strokePair.first = std::shared_ptr<Renderer::MaterialStyleStroke>(new Renderer::MaterialStyleStroke(
+			15,
+			Renderer::StrokeType::kLeftSide, Renderer::StrokeEndType::kFlat,
+            std::shared_ptr<Renderer::MaterialStroke>(new Renderer::StrokeRadialGradient(
+				materialMap, false
+			))
+		));
+    }
+    if (this->strokePair.second == nullptr)
+    {
+        auto materialMap = std::map<float, Renderer::Material>();
+        materialMap[0.3] = Renderer::Material{ QColor(0,255,255), 0.f, .8f };
+        materialMap[1.0] = Renderer::Material{ QColor(80,25,255), 0.f, .8f };
+        this->strokePair.second = std::shared_ptr<Renderer::MaterialStyleStroke>(new Renderer::MaterialStyleStroke(
+            15,
+            Renderer::StrokeType::kRightSide, Renderer::StrokeEndType::kFlat,
            std::shared_ptr<Renderer::MaterialStroke>(new Renderer::StrokeRadialGradient(
                materialMap, false
            ))
-            )));*/
-        this->materialStyles.push_back(std::make_shared<Renderer::MaterialStyleStroke>(
-            0,
-            Renderer::StrokeType::kBothSides, Renderer::StrokeEndType::kFlat,
-            std::make_shared<Renderer::StrokePlain>(QColor::fromRgb(50, 50, 50), 0, 0.8)
-            ));
+        ));
    }
    QWidget* w = new QWidget;
+    QListView* materialList = new QListView;
+
    QVBoxLayout* layout = new QVBoxLayout(w);
    layout->setMargin(0);
-    QLineEdit* r = new QLineEdit(w), * g = new QLineEdit(w), * b = new QLineEdit(w);
-    layout->addWidget(r);
-    layout->addWidget(g);
-    layout->addWidget(b);
+
+    StrokeStyleListView* leftStrokeView = new StrokeStyleListView(
+        std::dynamic_pointer_cast<Renderer::StrokeRadialGradient>(this->strokePair.first->materialStroke), w
+    );
+    layout->addWidget(leftStrokeView);
+
+    QtMaterialCheckBox* checkEachSideIndependent = new QtMaterialCheckBox(w);
+    checkEachSideIndependent->setText(QStringLiteral("ÆôÓÃÁ½²à¶ÀÁ¢Ãè±ß"));
+    checkEachSideIndependent->setChecked(enableEachSideIndependent);
+    layout->addWidget(checkEachSideIndependent);
+
+    StrokeStyleListView* rightStrokeView = new StrokeStyleListView(
+        std::dynamic_pointer_cast<Renderer::StrokeRadialGradient>(this->strokePair.second->materialStroke), w
+    );
+    layout->addWidget(rightStrokeView);
+    rightStrokeView->setDisabled(!this->enableEachSideIndependent);
+
+    QObject::connect(checkEachSideIndependent, &QtMaterialCheckBox::toggled, [this, rightStrokeView](bool toggled) {
+        this->enableEachSideIndependent = toggled;
+        rightStrokeView->setDisabled(!toggled);
+        });
    //auto stroke = std::dynamic_pointer_cast<Renderer::StrokeRadialGradient>(this->materialStyles[0]->materialStroke);
    //QColor* color = &(stroke->materialMap[1.0].color);
-    auto stroke = std::dynamic_pointer_cast<Renderer::StrokePlain>(this->materialStyles[0]->materialStroke);
+    /*auto stroke = std::dynamic_pointer_cast<Renderer::StrokePlain>(this->materialStyles[0]->materialStroke);
    QColor* color = &(stroke->material.color);
    r->setText(QString::number(color->red()));
    g->setText(QString::number(color->green()));
@ -84,7 +128,7 @@ QWidget* StrokeElementLayerStyle::getInputWidget()
        {
            color->setBlue(content.toInt());
        }
-        });
+        });*/
    return w;
 }

@ -101,16 +145,16 @@ QWidget* StrokeElementLayerStyle::getListDisplayWidget() const

 StrokeElementLayerStyle::StrokeElementLayerStyle(const StrokeElementLayerStyle& other)
 {
-    materialStyles = std::vector<std::shared_ptr<Renderer::MaterialStyleStroke>>(other.materialStyles.size());
-    for (size_t i = 0; i < other.materialStyles.size(); i++)
-    {
-        materialStyles[i] = std::dynamic_pointer_cast<Renderer::MaterialStyleStroke>(
-                std::shared_ptr<Renderer::MaterialStyle>(std::move(other.materialStyles[i]->clone()))
-            );
-    }
+    strokePair.first = std::dynamic_pointer_cast<MaterialStyleStroke>(
+        std::shared_ptr<Renderer::MaterialStyle>(std::move(other.strokePair.first->clone()))
+        );
+    strokePair.second = std::dynamic_pointer_cast<MaterialStyleStroke>(
+        std::shared_ptr<Renderer::MaterialStyle>(std::move(other.strokePair.second->clone()))
+        );
+    enableEachSideIndependent = other.enableEachSideIndependent;
 }

-std::unique_ptr<LayerStyle> StrokeElementLayerStyle::clonePtr() const
+std::unique_ptr<LayerStyle> StrokeElementLayerStyle::clone() const
 {
    return std::make_unique<StrokeElementLayerStyle>(StrokeElementLayerStyle(*this));
 }
@ -153,7 +197,7 @@ FillElementLayerStyle::FillElementLayerStyle(const FillElementLayerStyle& other)
    }
 }

-std::unique_ptr<LayerStyle> FillElementLayerStyle::clonePtr() const
+std::unique_ptr<LayerStyle> FillElementLayerStyle::clone() const
 {
    return std::make_unique<FillElementLayerStyle>(FillElementLayerStyle(*this));
 }
--- a/ArchitectureColoredPainting/src/Editor/LayerStyle.h
+++ b/ArchitectureColoredPainting/src/Editor/LayerStyle.h
@ -9,6 +9,8 @@
 #include "../Renderer/Painting/MaterialStyleStroke.h"
 #include "../Renderer/Painting/MaterialStyleFill.h"

+using Renderer::MaterialStyleStroke;
+
 /**
 * 在进行Style的添加时，首先创建空对象，然后直接调用getInputWidget()方法
 * 在进行Style的修改时，直接调用getInputWidget()方法
@ -24,11 +26,14 @@ public:
    virtual QWidget* getInputWidget() = 0;
    virtual QWidget* getListDisplayWidget() const = 0;
    virtual ~LayerStyle() {};
-    virtual std::unique_ptr<LayerStyle> clonePtr() const = 0;
+    virtual std::unique_ptr<LayerStyle> clone() const = 0;
 };

 class StrokeElementLayerStyle : public LayerStyle
 {
+private:
+    std::pair<std::shared_ptr<MaterialStyleStroke>, std::shared_ptr<MaterialStyleStroke>> strokePair;
+
 public:
    std::vector<Renderer::BaseStyle> toBaseStyles() const override;
    QString getStyleName() const override;
@ -37,8 +42,9 @@ public:
    StrokeElementLayerStyle() = default;
    StrokeElementLayerStyle(const StrokeElementLayerStyle& other);
    ~StrokeElementLayerStyle() = default;
-    std::vector<std::shared_ptr<Renderer::MaterialStyleStroke>> materialStyles;
-    std::unique_ptr<LayerStyle> clonePtr() const override;
+    std::unique_ptr<LayerStyle> clone() const override;
+
+    bool enableEachSideIndependent = false;
 };

 class FillElementLayerStyle : public LayerStyle
@ -52,5 +58,5 @@ public:
    FillElementLayerStyle(const FillElementLayerStyle& other);
    ~FillElementLayerStyle() = default;
    std::vector<std::shared_ptr<Renderer::MaterialStyleFill>> materialStyles;
-    std::unique_ptr<LayerStyle> clonePtr() const override;
+    std::unique_ptr<LayerStyle> clone() const override;
 };
--- a/ArchitectureColoredPainting/src/Editor/LayerWrapper.cpp
+++ b/ArchitectureColoredPainting/src/Editor/LayerWrapper.cpp
@ -23,9 +23,13 @@ FolderLayerWrapper*LayerWrapper::getParent() const
    return this == nullptr ? nullptr : this->parent;
 }

-PixelPath LayerWrapper::getCache()
+PixelPath LayerWrapper::getCache(LayerWrapper* selectedLayer)
 {
-    this->refresh();
+    this->refresh(selectedLayer);
+    if (selectedLayer == this)
+    {
+        this->cache.highLight();
+    }
    return cache;
 }

@ -42,6 +46,7 @@ LayerWrapper::LayerWrapper(QJsonObject json, FolderLayerWrapper*parent, ElementM
    property.scale = {transformJson.value("scale").toObject().value("x").toDouble(),
                      transformJson.value("scale").toObject().value("y").toDouble()};
    property.rotation = {transformJson.value("rotation").toDouble()};
+    selected = false;
 }

 FolderLayerWrapper::FolderLayerWrapper(QJsonObject json, ElementManager *elementManager, FolderLayerWrapper*parent)
@ -75,35 +80,52 @@ LeafLayerWrapper::LeafLayerWrapper(QJsonObject json, ElementManager *elementMana
    int elementIndex = json.value("element").toInt();
    wrappedElement = elementManager->getElementById(elementIndex);
 }
-void LayerWrapper::SimpleProperty::apply(PixelPath&cache) const
+
+void LayerWrapper::SimpleProperty::apply(PixelPath&cache)
+{
+    transform.reset();
+    double centerX = cache.getBoundingRect().center().x();
+    double centerY = cache.getBoundingRect().center().y();
+    //qDebug() << name << "  " << cache.boundingRect().center();
+    //qDebug() << name << " " << cache.boundingRect();
+    transform.translate(centerX, centerY);
+    transform.translate(offset.x(), offset.y());
+    transform.rotate(rotation);
+    transform.scale(scale.x(), scale.y());
+    transform.translate(-centerX, -centerY);
+    cache = cache.trans(transform);
+}
+
+QTransform LayerWrapper::getTransform()
 {
    QTransform trans;
    double centerX = cache.getBoundingRect().center().x();
    double centerY = cache.getBoundingRect().center().y();
    //qDebug() << name << "  " << cache.boundingRect().center();
    //qDebug() << name << " " << cache.boundingRect();
-    trans.translate(offset.x(), offset.y());
-    trans.translate(-centerX, -centerY);
-    trans.rotate(rotation);
-    trans.scale(scale.x(), scale.y());
    trans.translate(centerX, centerY);
-    cache = cache.trans(trans);
+    trans.translate(property.offset.x(), property.offset.y());
+    trans.rotate(property.rotation);
+    trans.scale(property.scale.x(), property.scale.y());
+    trans.translate(-centerX, -centerY);
+    return trans;
 }
-void LayerWrapper::refresh()
+
+void LayerWrapper::refresh(LayerWrapper* layer)
 {
    property.apply(cache);
 }

-void FolderLayerWrapper::refresh()
+void FolderLayerWrapper::refresh(LayerWrapper* layer)
 {
    cache.clear();
    for (auto& child : children) {
-        cache.addPath(child.get()->getCache());
+        cache.addPath(child.get()->getCache(layer));
    }
    LayerWrapper::refresh();
 }

-void LeafLayerWrapper::refresh()
+void LeafLayerWrapper::refresh(LayerWrapper* layer)
 {
    cache.clear();
    if (wrappedElement != nullptr)
@ -227,4 +249,37 @@ int FolderLayerWrapper::getReferencedBy()const
 		return this->elementManager->getLayerReferencedBy(this);
 	else
 		return -1;
+}
+
+void LayerWrapper::paint(QPainter* painter, QTransform transform)
+{
+    if (this->selected)
+    {
+        painter->save();
+		painter->setTransform(transform);
+		painter->setPen(QPen(Qt::gray, 2));
+        painter->setPen(Qt::DashLine);
+		painter->drawRect(cache.getBoundingRect());
+		painter->restore();
+    }
+}
+
+void FolderLayerWrapper::paint(QPainter* painter, QTransform transform)
+{
+    LayerWrapper::paint(painter, transform);
+    transform = property.transform * transform;
+    qDebug() << transform;
+	for (auto& child : children)
+		child->paint(painter, transform);
+}
+
+void LeafLayerWrapper::paint(QPainter* painter, QTransform transform)
+{
+    LayerWrapper::paint(painter, transform);
+    transform = property.transform * transform;
+    qDebug() << transform;
+	if (wrappedElement != nullptr)
+	{
+		wrappedElement->paint(painter, transform, styles);
+	}
 }
--- a/ArchitectureColoredPainting/src/Editor/LayerWrapper.h
+++ b/ArchitectureColoredPainting/src/Editor/LayerWrapper.h
@ -35,6 +35,7 @@ class LayerWrapper

  public:
 	QTreeWidgetItem* qTreeWidgetItem;
+    bool selected;
    struct SimpleProperty
    {
        QString name = "";
@ -43,17 +44,20 @@ class LayerWrapper
        double rotation = 0;
        bool flipHorizontally = 0;
        bool flipVertically = 0;
+        QTransform transform;
        // TODO: 将QPainterPath改为BitmapPath
-        void apply(PixelPath&cache) const;
+        void apply(PixelPath&cache);
    } property;
    virtual void setParent(FolderLayerWrapper*newParent);
-    virtual void refresh();
+    virtual void refresh(LayerWrapper* layer = nullptr);
    virtual QTreeWidgetItem* getQTreeItem();
    // TODO: 将QPainterPath改为BitmapPath/QImage，或者直接将其删除，绘制时直接使用BitmapPath的paint方法
-    virtual PixelPath getCache();
+    virtual PixelPath getCache(LayerWrapper* selectedLayer=nullptr);
+    QTransform getTransform();
    FolderLayerWrapper*getParent() const; // invoke by manager, then invoke parent's applyStyles
    LayerWrapper(QJsonObject json, FolderLayerWrapper*parent, ElementManager* elementManager=nullptr);
    LayerWrapper() = default;
+    virtual void paint(QPainter* painter, QTransform transform=QTransform());
    // TODO : export Function
    // virtual LayerWrapper *addChild() = 0;  // Leaf Child Only
    // virtual LayerWrapper *addParent() = 0; // Folder Parent Only
@ -75,7 +79,7 @@ class FolderLayerWrapper : public LayerWrapper
  public:

      ~FolderLayerWrapper() = default;
-    void refresh() override;
+    void refresh(LayerWrapper* layer=nullptr) override;
    FolderLayerWrapper() = default;
    FolderLayerWrapper(QJsonObject json, ElementManager *elementManager, FolderLayerWrapper*parent);
    void addChild(shared_ptr<LayerWrapper> child);
@ -86,6 +90,7 @@ class FolderLayerWrapper : public LayerWrapper
 	QTreeWidgetItem* getQTreeItem() override;
 	QJsonObject toJson() const override;
    int getReferencedBy()const;
+	void paint(QPainter* painter, QTransform transform = QTransform()) override;
 };

 class LeafLayerWrapper : public LayerWrapper
@ -97,10 +102,11 @@ class LeafLayerWrapper : public LayerWrapper

  public:
 	  ~LeafLayerWrapper() = default;
-    void refresh() override;
+    void refresh(LayerWrapper* layer = nullptr) override;
    LeafLayerWrapper() = default;
    LeafLayerWrapper(QJsonObject json, ElementManager *elementManager, FolderLayerWrapper*parent);
    QJsonObject toJson() const override;
+	void paint(QPainter* painter, QTransform transform = QTransform()) override;
 };

 Q_DECLARE_METATYPE(LayerWrapper *)
--- a/ArchitectureColoredPainting/src/Editor/PixelPath.cpp
+++ b/ArchitectureColoredPainting/src/Editor/PixelPath.cpp
@ -102,4 +102,19 @@ QPixmap PixelPath::getDetail()const
 	qDebug() << rect;
 	result = pixmap.copy(rect);
 	return result;
+}
+
+void PixelPath::highLight()
+{
+	// 创建一个QPainter对象，关联到QPixmap对象
+	QPainter painter(&pixmap);
+
+	// 设置画笔的颜色、宽度和样式
+	painter.setPen(QPen(Qt::black, 1, Qt::DashLine));
+
+	// 绘制一个矩形，指定左上角和右下角的坐标
+	painter.drawRect(boundingRect);
+
+	// 结束绘制
+	painter.end();
 }
--- a/ArchitectureColoredPainting/src/Editor/PixelPath.h
+++ b/ArchitectureColoredPainting/src/Editor/PixelPath.h
@ -26,4 +26,5 @@ public:
 	PixelPath trans(QTransform& mat)const;
 	QPixmap resizedPixel(QSize size)const;
 	QPixmap getDetail()const;
+	void highLight();
 };
--- a/ArchitectureColoredPainting/src/Editor/PreviewWindow.cpp
+++ b/ArchitectureColoredPainting/src/Editor/PreviewWindow.cpp
@ -2,6 +2,7 @@

 PreviewWindow::PreviewWindow(QWidget *parent) : QOpenGLWidget(parent)
 {
+    this->setFixedSize(QSize(1080, 1080));
    this->renderer = Renderer::ElementRenderer::instance();
    QSurfaceFormat surfaceFormat;
    surfaceFormat.setSamples(16);
@ -10,6 +11,7 @@ PreviewWindow::PreviewWindow(QWidget *parent) : QOpenGLWidget(parent)
    painter->setRenderHint(QPainter::SmoothPixmapTransform);
    painter->setRenderHint(QPainter::HighQualityAntialiasing);
    layerManager = nullptr;
+    currentLayer = nullptr;
 }

 void PreviewWindow::initialize(LayerManager *layerManager,QSize windowSize)
@ -46,7 +48,7 @@ void PreviewWindow::paintGL()
    painter->begin(this);
    painter->setRenderHint(QPainter::Antialiasing);
    painter->setRenderHint(QPainter::HighQualityAntialiasing);
-    layerManager->paint(painter,this->size());
+    layerManager->paint(painter,this->size(),currentLayer);
    painter->end();
 }

@ -56,4 +58,48 @@ void PreviewWindow::resizeGL(int w, int h)

 Renderer::ElementRenderer* const PreviewWindow::getRenderer()const {
    return this->renderer;
+}
+
+void PreviewWindow::currentLayerChanged(LayerWrapper* layer)
+{
+    this->currentLayer = layer;
+}
+
+void PreviewWindow::refresh()
+{
+    this->repaint();
+}
+
+void PreviewWindow::mousePressEvent(QMouseEvent* event)
+{
+    // 当鼠标按下时，记录当前的位置
+    m_lastPos = event->pos();
+}
+
+void PreviewWindow::mouseMoveEvent(QMouseEvent* event)
+{
+    // 当鼠标移动时，计算移动的距离，并根据需要更新图形的状态
+    int dx = event->x() - m_lastPos.x();
+    int dy = event->y() - m_lastPos.y();
+    if (currentLayer != nullptr) {
+        if (event->buttons() & Qt::LeftButton) {
+            // 如果按下的是左键，那么平移图形
+			currentLayer->property.offset.setX(currentLayer->property.offset.x() + dx);
+			currentLayer->property.offset.setY(currentLayer->property.offset.y() + dy);
+            qDebug() << dx << "----" << dy;
+        }
+		else if (event->buttons() & Qt::RightButton) {
+            // 如果按下的是右键，那么旋转图形
+            qreal angle = dx;
+			currentLayer->property.rotation += angle;
+        }
+    }
+    // 更新上一次的位置
+    m_lastPos = event->pos();
+    this->repaint();
+}
+
+void PreviewWindow::mouseReleaseEvent(QMouseEvent* event)
+{
+	emit layerInfoChanged();
 }
--- a/ArchitectureColoredPainting/src/Editor/PreviewWindow.h
+++ b/ArchitectureColoredPainting/src/Editor/PreviewWindow.h
@ -7,6 +7,7 @@
 #include <QJsonObject>
 #include <QJsonValue>
 #include <QOpenGLFunctions>
+#include <QMouseEvent>
 #include <QOpenGLWidget>
 #include "../Renderer/Preview/ElementRenderer.h"

@ -19,7 +20,13 @@ class PreviewWindow : public QOpenGLWidget, protected QOpenGLFunctions
    LayerManager *layerManager;
 	Renderer::ElementRenderer* renderer;
    QSize logicalSize;
-
+	QRectF viewportRect;
+    LayerWrapper* currentLayer;
+    QPointF m_lastPos;
+    void mousePressEvent(QMouseEvent* event) override;
+	void mouseMoveEvent(QMouseEvent* event) override;
+	void mouseReleaseEvent(QMouseEvent* event) override;
+    
  public:
    PreviewWindow(QWidget *parent = nullptr);
    void initialize(LayerManager *layerManager, QSize windowSize = QSize(1920, 1080));
@ -28,4 +35,11 @@ class PreviewWindow : public QOpenGLWidget, protected QOpenGLFunctions
    void paintGL() override;
    void resizeGL(int w, int h) override;
    Renderer::ElementRenderer* const getRenderer()const;
+
+  public slots:
+    void currentLayerChanged(LayerWrapper*);
+    void refresh();
+
+  signals:
+    void layerInfoChanged();
 };
--- a/ArchitectureColoredPainting/src/Editor/RightBar/LayerTreeWidget.cpp
+++ b/ArchitectureColoredPainting/src/Editor/RightBar/LayerTreeWidget.cpp
@ -12,11 +12,19 @@ LayerTreeWidget::LayerTreeWidget(QWidget *parent)
    this->setHeaderLabel("Layer Content");
    connect(this, &QTreeWidget::customContextMenuRequested, this, &LayerTreeWidget::popMenu);
    connect(this, &QTreeWidget::currentItemChanged, [=](QTreeWidgetItem *currentItem) {
+        if (this->selectedItem != nullptr) {
+            this->selectedItem->data(0, Qt::UserRole).value<LayerWrapper*>()->selected = false;
+        }
        this->selectedItem = currentItem;
-		if(this->selectedItem !=nullptr)
-            emit displayLayerChange(this->selectedItem->data(0, Qt::UserRole).value<LayerWrapper *>());
-        else
-			emit displayLayerChange(nullptr);
+        if (this->selectedItem != nullptr) {
+            auto layer = this->selectedItem->data(0, Qt::UserRole).value<LayerWrapper*>();
+            layer->selected = true;
+            emit displayLayerChange(layer);
+        }    
+        else {
+            emit displayLayerChange(nullptr);
+        }
+        emit requireRefreshPreview();
    });
    // connect(this, &QTreeWidget::itemDoubleClicked, this, &LayerTreeWidget::onItemDoubleClicked);
 }
--- a/ArchitectureColoredPainting/src/Editor/RightBar/LayerTreeWidget.h
+++ b/ArchitectureColoredPainting/src/Editor/RightBar/LayerTreeWidget.h
@ -20,7 +20,7 @@ class LayerTreeWidget : public QTreeWidget
    // void mouseDoubleClickEvent(QMouseEvent *event) override;
    // void onItemDoubleClicked(QTreeWidgetItem *item, int column = 0);

-  signals:
+signals:
    void displayLayerChange(LayerWrapper *);
    void requireRefreshPreview();
 	void requireRefreshElementWidget();
--- a/ArchitectureColoredPainting/src/Renderer/Mesh.h
+++ b/ArchitectureColoredPainting/src/Renderer/Mesh.h
@ -2,23 +2,22 @@
 #include <QOpenGLFunctions_4_5_Core>
 #include <QString>
 #include <vector>
-#include <QVector2D>
-#include <QVector3D>
 #include <QOpenGLShaderProgram>
 #include <QOpenGLBuffer>
 #include <QOpenGLVertexArrayObject>
 #include <QOpenGLTexture>
 #include <QOpenGLWidget>
 #include <assimp/vector3.h>
+#include <glm/glm.hpp>
 #include "Drawable.h"

 namespace Renderer
 {
 	struct Vertex
 	{
-		QVector3D Position;
-		QVector3D Normal;
-		QVector2D TexCoords;
+		glm::vec3 Position;
+		glm::vec3 Normal;
+		glm::vec2 TexCoords;
 		Vertex(const aiVector3D& position, const aiVector3D& Normal, const aiVector3D& TexCoords);
 	};

--- a/ArchitectureColoredPainting/src/Renderer/Model.cpp
+++ b/ArchitectureColoredPainting/src/Renderer/Model.cpp
@ -50,7 +50,7 @@ void Renderer::Model::loadModel(QString path)
 	directory = modelFile.dir();

 	Assimp::Importer importer;
-	const aiScene* scene = importer.ReadFile(modelFile.absoluteFilePath().toUtf8(), aiProcess_Triangulate | aiProcess_FlipUVs);
+	const aiScene* scene = importer.ReadFile(modelFile.absoluteFilePath().toUtf8(), aiProcess_Triangulate /*| aiProcess_FlipUVs*/);
 	if (!scene || scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode)
 	{
 		qCritical() << "ERROR::ASSIMP::" << importer.GetErrorString() << endl;
@ -117,12 +117,8 @@ void Model::processNode(aiNode* node, const aiScene* scene, aiMatrix4x4 mat4)

 std::unique_ptr<Drawable> Model::processMesh(aiMesh* mesh, const aiScene* scene, aiMatrix4x4 model)
 {
-	aiMaterial* material = scene->mMaterials[mesh->mMaterialIndex];
 	QMatrix4x4 modelQ((float*)&model);

-	aiString str;
-	material->GetTexture(aiTextureType_BASE_COLOR, 0, &str);
-
 	std::vector<Vertex> vertices;
 	for (unsigned int i = 0; i < mesh->mNumVertices; i++)
 	{
@ -139,45 +135,59 @@ std::unique_ptr<Drawable> Model::processMesh(aiMesh* mesh, const aiScene* scene,
 			maxZ = std::max(maxZ, worldPos.z);
 		}
 	}
+
 	std::vector<unsigned int> indices;
 	for (auto face = mesh->mFaces; face < mesh->mFaces + mesh->mNumFaces; face++)
 		indices.insert(indices.end(), face->mIndices, face->mIndices + face->mNumIndices);
-	

-	if (auto iter = paintingMap.find(std::string(str.C_Str())); paintingProgram != nullptr && iter != paintingMap.end())
+	aiMaterial* material = scene->mMaterials[mesh->mMaterialIndex];
+
+	if (auto iter = paintingMap.find([&] {
+		aiString str;
+		material->GetTexture(aiTextureType_BASE_COLOR, 0, &str);
+		return std::string(str.C_Str());
+	}()); paintingProgram != nullptr && iter != paintingMap.end())
 	{
+		qDebug() << iter->first.c_str() << "Replaced";
+
+		auto mesh = std::make_unique<PaintingMesh>(glFunc, paintingProgram, shadowProgram, modelQ);
+
 		auto& [paintingPath, leftBottom, rightTop] = iter->second;
-		qDebug() << str.C_Str() << "Replaced";

-		auto m_mesh = std::make_unique<PaintingMesh>(glFunc, paintingProgram, shadowProgram, modelQ);
-		m_mesh->vertices = vertices;
-		m_mesh->indices = indices;
-
-		m_mesh->paintingId = loadPainting(paintingPath);
-		auto& handle = vtManager->getPaintingHandle(m_mesh->paintingId);
-		m_mesh->textureBasecolor = handle.baseColor;
-		m_mesh->textureMetallicRoughness = handle.metallicRoughness;
-		m_mesh->setupMesh();
-		return m_mesh;
+		for (auto& v : vertices)
+		{
+			//qDebug() << v.TexCoords.x << v.TexCoords.y;
+			v.TexCoords = (v.TexCoords - leftBottom) / (rightTop - leftBottom);
+			qDebug() << v.TexCoords.x << v.TexCoords.y;
+		}
+			
+		mesh->vertices = vertices;
+		mesh->indices = indices;
+	
+		mesh->paintingId = loadPainting(paintingPath);
+		auto& handle = vtManager->getPaintingHandle(mesh->paintingId);
+		mesh->textureBasecolor = handle.baseColor;
+		mesh->textureMetallicRoughness = handle.metallicRoughness;
+		mesh->setupMesh();
+		return mesh;
 	}
 	else
 	{
-		auto m_mesh = std::make_unique<Mesh>(glFunc, shaderProgram, shadowProgram, modelQ);
-		m_mesh->vertices = vertices;
-		m_mesh->indices = indices;
+		auto mesh = std::make_unique<Mesh>(glFunc, shaderProgram, shadowProgram, modelQ);
+		mesh->vertices = vertices;
+		mesh->indices = indices;

-		// ´¦Àí²ÄÖÊ
-		if (!(m_mesh->textureBasecolor = loadMaterialTextures(material, aiTextureType_BASE_COLOR)))
+		if (!(mesh->textureBasecolor = loadMaterialTextures(material, aiTextureType_BASE_COLOR)))
 			qWarning() << "Basecolor Texture Loading Failed!";
-		if (!(m_mesh->textureMetallicRoughness = loadMaterialTextures(material, aiTextureType_METALNESS)))
+		if (!(mesh->textureMetallicRoughness = loadMaterialTextures(material, aiTextureType_METALNESS)))
 			qWarning() << "MetallicRoughness Texture Loading Failed!";
-		if (!(m_mesh->textureNormal = loadMaterialTextures(material, aiTextureType_NORMALS)))
+		if (!(mesh->textureNormal = loadMaterialTextures(material, aiTextureType_NORMALS)))
 			qWarning() << "Normal Texture Loading Failed!";

-		if (m_mesh->textureBasecolor && m_mesh->textureMetallicRoughness && m_mesh->textureNormal)
+		if (mesh->textureBasecolor && mesh->textureMetallicRoughness && mesh->textureNormal)
 		{
-			m_mesh->setupMesh();
-			return m_mesh;
+			mesh->setupMesh();
+			return mesh;
 		}
 		else
 			return nullptr;
@ -208,7 +218,7 @@ GLuint Model::loadMaterialTextures(aiMaterial* mat, aiTextureType type)
 	texture.setWrapMode(QOpenGLTexture::DirectionS, QOpenGLTexture::Repeat);
 	texture.setWrapMode(QOpenGLTexture::DirectionT, QOpenGLTexture::Repeat);
 	texture.setMinMagFilters(QOpenGLTexture::LinearMipMapLinear, QOpenGLTexture::Linear);
-	texture.setData(data);
+	texture.setData(data.mirrored());
 	return texture.textureId();
 }

--- a/ArchitectureColoredPainting/src/Renderer/Model.h
+++ b/ArchitectureColoredPainting/src/Renderer/Model.h
@ -24,7 +24,11 @@ namespace Renderer
 		QOpenGLShaderProgram* shadowProgram = nullptr;
 		VirtualTextureManager* vtManager = nullptr;

-		std::unordered_map<std::string, std::tuple<std::string, glm::vec2, glm::vec2>> paintingMap;
+		/**
+		 * @param key BaseColor路径
+		 * @param value json路径, 纹理坐标
+		 */
+		std::unordered_map<std::string, std::tuple<std::string, glm::vec2, glm::vec2>> paintingMap; 
 		std::unordered_map<std::string, GLuint> paintingLoaded;
 		std::unordered_map<std::string, QOpenGLTexture> texturesLoaded;
 		std::vector<std::unique_ptr<Drawable>> meshes;
Author	SHA1	Message	Date
ArgonarioD	7ff8fd90c0	Merge branch 'main' into dev-LayerStyle # Conflicts: # ArchitectureColoredPainting/src/Editor/GraphicElement.cpp	2023-03-14 18:01:22 +08:00
ArgonarioD	1b926b2054	修改了LayerStyle 将clonePtr重命名为了clone 将StrokeElementLayerStyle的存储style方式改为了通过pair存储两侧	2023-03-14 17:59:46 +08:00
ArgonarioD	28df3d47c5	新增了ColorPicker类和StrokeStyleListView类	2023-03-14 17:57:58 +08:00
karlis	97097fcc3a	修改旋转判定，添加style渲染接口	2023-03-14 15:36:19 +08:00
karlis	f2ceca724a	Merge branch 'main' of http://101.34.228.45:3000/BigC/ArchitectureColoredPainting	2023-03-14 15:14:28 +08:00
karlis	eab8d7aeec	Merge branch 'main' of http://101.34.228.45:3000/BigC/ArchitectureColoredPainting	2023-03-14 15:14:25 +08:00
karlis	dc7a793d3a	Merge branch 'main' of http://101.34.228.45:3000/BigC/ArchitectureColoredPainting	2023-03-14 15:03:03 +08:00
karlis	684c28dafd	bug fix	2023-03-14 15:02:49 +08:00
karlis	72f0f78e64	bug fix	2023-03-14 14:53:36 +08:00
karlis	3f1421a1bd	bug:黑屏	2023-03-14 00:20:31 +08:00
karlis	4c9fe168a9	bug: pixmap溢出	2023-03-13 23:36:31 +08:00
karlis	de9d7143b6	添加【可能存在问题的】拖拽和旋转	2023-03-13 21:06:05 +08:00
karlis	ed4c3c0064	实现【位置错误的】LayerBounding虚线框	2023-03-13 20:47:35 +08:00
wuyize	0d42af9200	实现彩绘纹理部分替换	2023-03-13 13:48:20 +08:00