改用compute shader

ArchitectureColoredPainting/ArchitectureColoredPainting.vcxproj

@@ -105,6 +105,7 @@
     <None Include="Shaders\final.vert" />
     <None Include="Shaders\model.frag" />
     <None Include="Shaders\model.vert" />
+    <None Include="Shaders\painting.comp" />
     <None Include="Shaders\painting.frag" />
     <None Include="Shaders\painting.vert" />
     <None Include="Shaders\shader.frag" />

ArchitectureColoredPainting/ArchitectureColoredPainting.vcxproj.filters

@@ -92,6 +92,9 @@
     <None Include="Shaders\painting.vert">
       <Filter>Resource Files\Shaders</Filter>
     </None>
+    <None Include="Shaders\painting.comp">
+      <Filter>Resource Files\Shaders</Filter>
+    </None>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="Camera.h">

ArchitectureColoredPainting/MainWindow.qrc

@@ -9,5 +9,6 @@
         <file>container.jpg</file>
         <file>Shaders/painting.frag</file>
         <file>Shaders/painting.vert</file>
+        <file>Shaders/painting.comp</file>
     </qresource>
 </RCC>

ArchitectureColoredPainting/Model.cpp

@@ -6,6 +6,7 @@
 #include <iostream>
 #include "PaintingMesh.h"
 #include <QtMath>
+#include "BvhTree.h"
 
 Model::Model(QString path, QOpenGLContext* context, QOpenGLShaderProgram* shaderProgram)
 	: context(context)
@@ -104,7 +105,7 @@ Drawable* Model::processMesh(aiMesh* mesh, const aiScene* scene, aiMatrix4x4 mod
 
 	if (paintingProgram != nullptr && std::strcmp(str.C_Str(), "17876391417123941155.jpg") == 0)
 	{
-		qDebug() << str.C_Str();
+		qDebug() << str.C_Str() << "Replaced";
 		//  初始化网格
 		PaintingMesh* m_mesh = new PaintingMesh(glFunc, paintingProgram, model);
 		// 遍历网格的每个顶点
@@ -143,7 +144,7 @@ Drawable* Model::processMesh(aiMesh* mesh, const aiScene* scene, aiMatrix4x4 mod
 			//root
 			1,2,
 			3,4, 5,6,
-			7,0, 7,30./360* 4294967296 /*右儿子用来表示旋转角度*/, 8,0, 7,0,
+			7,0, 7,30. / 360 * 65536 + 1 * 65536 /*右儿子用来表示旋转角度和层数*/, 8,0, 7,0,
 			//elememt0
 			1,2,
 			5 + 28/*contour索引，由于contour不定长，这里需要给到contour在elementIndex中位置*/,5 + 12/*style索引，在elementData中位置*/, 3,4,
@@ -164,14 +165,36 @@ Drawable* Model::processMesh(aiMesh* mesh, const aiScene* scene, aiMatrix4x4 mod
 									//elememt1
 									QVector4D(-1,0,1,1),
 		};
+
+		BvhTree bvhTree;
+		std::vector<QVector4D> initBound;
+		for (int i = 0; i < 2000; i++)
+		{
+			float x = (float)rand() / RAND_MAX * 2 - 1;
+			float y = (float)rand() / RAND_MAX * 2 - 1;
+			float z = 0.1+x;//(float)rand() / RAND_MAX * (0.1) + x;
+			float w = 0.1+y;//(float)rand() / RAND_MAX * (0.1) + y;
+			initBound.push_back(QVector4D(x,y,z,w));
+		}
+	/*	initBound.push_back(QVector4D(-0.8, -0.8, -0.7, -0.7));
+		initBound.push_back(QVector4D(-0.8, 0.7, -0.7, 0.8));
+		initBound.push_back(QVector4D(0.7, -0.8, 0.8, -0.7));
+		initBound.push_back(QVector4D(0.7, 0.7, 0.8, 0.8));*/
+		bvhTree.buildBvhTree(initBound.data(), initBound.size());
+		std::vector<GLuint> children;
+		std::vector<QVector4D> bounds;
+		bvhTree.getBvhArray(children, bounds);
+		qDebug() << children;
+		qDebug() << bounds;
+
 		glFunc->glGenBuffers(1, &m_mesh->bvhSSBO);
 		glFunc->glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_mesh->bvhSSBO);
-		glFunc->glBufferData(GL_SHADER_STORAGE_BUFFER,sizeof(bvhChildren), bvhChildren, GL_DYNAMIC_DRAW);
+		glFunc->glBufferData(GL_SHADER_STORAGE_BUFFER, children.size()*sizeof(GLuint), children.data(), GL_DYNAMIC_DRAW);
 		glFunc->glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
 
 		glFunc->glGenBuffers(1, &m_mesh->bvhBoundSSBO);
 		glFunc->glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_mesh->bvhBoundSSBO);
-		glFunc->glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(bvhBound), bvhBound, GL_DYNAMIC_DRAW);
+		glFunc->glBufferData(GL_SHADER_STORAGE_BUFFER, bounds.size()*sizeof(QVector4D), bounds.data(), GL_DYNAMIC_DRAW);
 		glFunc->glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
 
 		GLuint elementOffset[] = {

ArchitectureColoredPainting/RendererWidget.cpp

@@ -64,6 +64,12 @@ void RendererWidget::initializeGL()
 	if (!paintingProgramPtr->link())
 		qDebug() << "ERROR:" << paintingProgramPtr->log();
 
+	paintingCompProgramPtr = new QOpenGLShaderProgram;
+	if (!paintingCompProgramPtr->addShaderFromSourceFile(QOpenGLShader::Compute, ":/Shaders/painting.comp"))
+		qDebug() << "ERROR:" << paintingCompProgramPtr->log();
+	if (!paintingCompProgramPtr->link())
+		qDebug() << "ERROR:" << paintingCompProgramPtr->log();
+
 	finalProgramPtr = new QOpenGLShaderProgram;
 	if (!finalProgramPtr->addShaderFromSourceFile(QOpenGLShader::Vertex, ":/Shaders/final.vert"))
 		qDebug() << "ERROR:" << finalProgramPtr->log();
@@ -72,11 +78,13 @@ void RendererWidget::initializeGL()
 	if (!finalProgramPtr->link())
 		qDebug() << "ERROR:" << finalProgramPtr->log();
 
+
 	finalProgramPtr->bind();
 	finalProgramPtr->setUniformValue("gBaseColor", 0);
 	finalProgramPtr->setUniformValue("gNormal", 1);
 	finalProgramPtr->setUniformValue("gPosition", 2);
 	finalProgramPtr->setUniformValue("gMetallicRoughness", 3);
+	finalProgramPtr->setUniformValue("gPainting", 4);
 	finalProgramPtr->release();
 
 	model = new Model("Models/Sponza/Sponza.gltf", context(), modelProgramPtr, paintingProgramPtr);
@@ -131,6 +139,14 @@ void RendererWidget::paintGL()
 		fboPtr->release();
 	}
 
+	paintingCompProgramPtr->bind();
+	glActiveTexture(GL_TEXTURE4);
+	glBindTexture(GL_TEXTURE_2D, gbuffers[4]);
+	glBindImageTexture(0, gbuffers[0], 0, GL_FALSE, 0, GL_READ_WRITE, GL_RGBA8);
+	glBindImageTexture(1, gbuffers[3], 0, GL_FALSE, 0, GL_READ_WRITE, GL_RG16);
+	glBindImageTexture(2, gbuffers[4], 0, GL_FALSE, 0, GL_READ_WRITE, GL_RGBA32F);
+	glDispatchCompute(ceil(frameWidth / 8.), ceil(frameHeight / 8.), 1);
+
 
 	//QOpenGLFramebufferObject::blitFramebuffer(nullptr, QRect(0, 0, 2*width(), 2*height()), fboPtr, QRect(0, 0, 1156, 756));
 	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
@@ -142,7 +158,7 @@ void RendererWidget::paintGL()
 	finalProgramPtr->setUniformValueArray("lightPositions", lightPositions, 4);
 	finalProgramPtr->setUniformValueArray("lightColors", lightColors, 4);
 
-	QVector<GLuint> gbuffers = fboPtr->textures();
+
 	glActiveTexture(GL_TEXTURE0);
 	glBindTexture(GL_TEXTURE_2D, gbuffers[0]);
 	glActiveTexture(GL_TEXTURE1);
@@ -151,6 +167,8 @@ void RendererWidget::paintGL()
 	glBindTexture(GL_TEXTURE_2D, gbuffers[2]);
 	glActiveTexture(GL_TEXTURE3);
 	glBindTexture(GL_TEXTURE_2D, gbuffers[3]);
+	glActiveTexture(GL_TEXTURE4);
+	glBindTexture(GL_TEXTURE_2D, gbuffers[4]);
 	glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
 	finalProgramPtr->release();
 }
@@ -165,12 +183,18 @@ void RendererWidget::resizeGL(int width, int height)
 	if (fboPtr != nullptr)
 		delete fboPtr;
 	fboPtr = new QOpenGLFramebufferObject(frameWidth, frameHeight, QOpenGLFramebufferObject::Depth, GL_TEXTURE_2D);
-	fboPtr->bind();
+	if (fboPtr->bind())
+	{
 		fboPtr->addColorAttachment(frameWidth, frameHeight, GL_RGB16F);
 		fboPtr->addColorAttachment(frameWidth, frameHeight, GL_RGB16F);
-	fboPtr->addColorAttachment(frameWidth, frameHeight, GL_RG);
+		fboPtr->addColorAttachment(frameWidth, frameHeight, GL_RG16);
-	GLenum attachments[] = { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2, GL_COLOR_ATTACHMENT3 };
+		fboPtr->addColorAttachment(frameWidth, frameHeight, GL_RGBA32F);
-	glDrawBuffers(4, attachments);
+		GLenum attachments[] = { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2, GL_COLOR_ATTACHMENT3,  GL_COLOR_ATTACHMENT4 };
+		glDrawBuffers(5, attachments);
+		gbuffers = fboPtr->textures();
+	
+		fboPtr->release();
+	}
 
 
 	std::cout << "\033[?25l";

ArchitectureColoredPainting/RendererWidget.h

@@ -36,8 +36,10 @@ private:
     float deltaTime;
     QOpenGLShaderProgram* modelProgramPtr = nullptr;
     QOpenGLShaderProgram* paintingProgramPtr = nullptr;
+    QOpenGLShaderProgram* paintingCompProgramPtr = nullptr;
     QOpenGLShaderProgram* finalProgramPtr = nullptr;
     QOpenGLFramebufferObject* fboPtr = nullptr;
+    QVector<GLuint> gbuffers;
     QOpenGLBuffer quadVBO;
     QOpenGLVertexArrayObject quadVAO;
     Model* model;

ArchitectureColoredPainting/Shaders/final.frag

@@ -8,7 +8,7 @@ uniform sampler2D gBaseColor;
 uniform sampler2D gNormal;
 uniform sampler2D gPosition;
 uniform sampler2D gMetallicRoughness;
-
+uniform sampler2D gPainting;
 // lights
 uniform vec3 lightPositions[4];
 uniform vec3 lightColors[4];
@@ -108,4 +108,6 @@ void main()
     color = pow(color, vec3(1.0/2.2));  
 
     FragColor = vec4(color, 1.0);
+    //FragColor = vec4(texture(gPainting, TexCoords).rgb, 1.0);
+
 }

ArchitectureColoredPainting/Shaders/model.frag

@@ -9,6 +9,7 @@ layout (location = 0) out vec4 gBaseColor;
 layout (location = 1) out vec3 gNormal;
 layout (location = 2) out vec3 gPosition;
 layout (location = 3) out vec2 gMetallicRoughness;
+layout(location = 4) out vec3 gPainting;
 
 in vec2 TexCoords;
 in vec3 WorldPos;
@@ -42,6 +43,6 @@ void main()
     gPosition = WorldPos;
     gNormal = getNormalFromMap();
     gMetallicRoughness = texture(texture_metallic_roughness, TexCoords).bg;
-
+    gPainting = vec3(0);
 
 }

ArchitectureColoredPainting/Shaders/painting.comp

@@ -0,0 +1,149 @@
+#version 450 core
+
+layout (local_size_x = 8, local_size_y = 8) in;
+
+layout(rgba8, binding = 0) uniform image2D gBaseColor;
+layout(rg16, binding = 1) uniform image2D gMetallicRoughness;
+layout(rgba32f, binding = 2) uniform image2D gPainting;
+
+
+
+layout(std430, binding = 1) buffer bvhBuffer
+{
+    uint bvhLength;
+    uvec2 bvhChildren[];
+};
+layout(std430, binding = 2) buffer bvhBoundBuffer
+{
+    vec4 bvhBound[];
+};
+layout(std430, binding = 3) buffer elementOffsetBuffer
+{
+    /**********************
+    ** @x elementBvhRoot
+    ** @y elementBvhLength
+    ** @z pointsOffset
+    ** @w linesOffset
+    **********************/
+    uvec4 elementOffset[];
+};
+layout(std430, binding = 4) buffer elementIndexBuffer
+{
+    uint elementIndexs[]; //线和面
+};
+layout(std430, binding = 5) buffer elementDataBuffer
+{
+    float elementData[]; //点和Style
+};
+
+const float PI = 3.14159265358979;
+
+
+const uint STACK_SIZE = 30;
+
+struct Stack
+{
+    uint top;
+    uint data[STACK_SIZE];
+
+    bool empty()
+    {
+        return top == 0;
+    }
+    bool full()
+    {
+        return top == STACK_SIZE;
+    }
+    bool getTop(out uint x)
+    {
+        if (empty())
+            return false;
+        x = data[top - 1];
+        return true;
+    }
+    bool pop()
+    {
+        if (empty())
+            return false;
+        top--;
+        return true;
+    }
+    bool push(in uint x)
+    {
+        if (full())
+            return false;
+        data[top] = x;
+        top++;
+        return true;
+    }
+} stack, elementStack;
+
+
+
+void main()
+{
+    ivec2 pixelLocation = ivec2(gl_GlobalInvocationID.xy);
+    if(imageLoad(gPainting, pixelLocation).r==0)
+        return;
+
+    imageStore(gMetallicRoughness, pixelLocation, vec4(0 /*金属度*/, 0.8 /*粗糙度*/, 0, 1));
+
+    vec2 uv = imageLoad(gPainting, pixelLocation).gb;
+
+    vec3 debugBVH = vec3(0);
+    bool debugHit = false;
+    stack.top = 0;
+    uint index = 0, visitTime = 0;
+    while (index < bvhLength || !stack.empty())
+    {
+        while (index < bvhLength)
+        {
+            visitTime++;
+            vec4 bound = bvhBound[index];
+            uint leftChild = bvhChildren[index].x;
+            if (leftChild >= bvhLength)
+            {
+                uint zIndex = bvhChildren[index].y / 65535;
+                float angle = (bvhChildren[index].y / 65535. - zIndex) * 2 * PI;
+
+                mat2 rotation = {{cos(angle), -sin(angle)}, {sin(angle), cos(angle)}};
+                vec2 localUV = uv - (bound.xy + bound.zw) / 2;
+                localUV = rotation * localUV;
+                localUV /= (bound.zw - bound.xy) / 2;
+                if (all(lessThan(vec2(-1), localUV)) && all(lessThan(localUV, vec2(1))))
+                {
+                    if (zIndex == 1)
+                        debugBVH = vec3(1, 0, 1);
+                    uint elementIndex = leftChild - bvhLength;
+                     debugBVH.bg += 0.5 * (localUV + vec2(1));
+                    // debugBVH = vec3(0);
+         
+                    //debugHit = drawElement(leftChild - bvhLength, localUV, debugBVH) == vec3(1);
+                
+                }
+
+                index = bvhLength;
+            }
+            else if (all(lessThan(bound.xy, uv)) && all(lessThan(uv, bound.zw)))
+            {
+                debugBVH.r += 0.2;
+                stack.push(index);
+                index = leftChild;
+            }
+            else
+                index = bvhLength;
+        }
+        if (!stack.empty())
+        {
+            stack.getTop(index);
+            stack.pop();
+            index = bvhChildren[index].y;
+        }
+    }
+
+    if (debugHit)
+        imageStore(gBaseColor, pixelLocation, vec4(vec3(1, 1, 0),1));    
+    else
+        imageStore(gBaseColor, pixelLocation, vec4(debugBVH,1));
+
+}

ArchitectureColoredPainting/Shaders/painting.frag

@@ -4,6 +4,7 @@ layout(location = 0) out vec4 gBaseColor;
 layout(location = 1) out vec3 gNormal;
 layout(location = 2) out vec3 gPosition;
 layout(location = 3) out vec2 gMetallicRoughness;
+layout(location = 4) out vec3 gPainting;
 
 in vec2 TexCoords;
 in vec3 WorldPos;
@@ -493,7 +494,7 @@ void mainImage(out vec3 fragColor, in vec2 fragCoord)
 }
 ///////////////////////////////
 
-const uint STACK_SIZE = 10;
+const uint STACK_SIZE = 40;
 
 struct Stack
 {
@@ -532,36 +533,9 @@ struct Stack
     }
 } stack, elementStack;
 
-void main()
+vec3 drawElement(uint elementIndex, vec2 localUV, inout vec3 debugBVH = vec3(0))
 {
-	// gBaseColor = vec4(TexCoords,1,1);
+    vec4 elementColor = vec4(0);
-	// gBaseColor = vec4(240./255, 220./255,157./255,1);
-	// gBaseColor = vec4(bvh[0].bound==vec4(0,0,1,1));
-
-	vec2 uv = vec2(1., 1.) - TexCoords * 2;
-	vec3 debugBVH = vec3(0);
-	bool debugHit = false;
-	stack.top = 0;
-	uint index = 0;
-	while (index < bvhLength || !stack.empty())
-	{
-		while (index < bvhLength)
-		{
-			vec4 bound = bvhBound[index];
-			uint leftChild = bvhChildren[index].x;
-			if (leftChild >= bvhLength)
-			{
-				float angle = float(bvhChildren[index].y) / 4294967296. * 2 * PI;
-				mat2 rotation = {{cos(angle), -sin(angle)}, {sin(angle), cos(angle)}};
-				vec2 localUV = uv - (bound.xy + bound.zw) / 2;
-				localUV = rotation * localUV;
-				localUV /= (bound.zw - bound.xy) / 2;
-				if (all(lessThan(vec2(-1), localUV)) && all(lessThan(localUV, vec2(1))))
-				{
-					uint elementIndex = leftChild - bvhLength;
-					//debugBVH.bg += 0.5 * (localUV + vec2(1));
-					debugBVH = vec3(0);
-					////////////////////////////ͼԪÄÚBVH/////////////////////////////////
 
     uvec4 currentOffset = elementOffset[elementIndex];
     uint elementBvhRoot = currentOffset.x;
@@ -585,15 +559,16 @@ void main()
                 {
                     debugBVH.g += 0.5;
 
-
                     uint styleIndex = bvhChildren[elementBvhRoot + elementBvhIndex].y - elementBvhLength;
-							
+                    // for(int i = 0; i<200;i++)
                     if (elementData[styleIndex] == 0.) //Ãæ
                     {
 
                         uint lineCount = elementIndexs[leftChild - elementBvhLength];
                         uint num_its = 0;
-										for(uint contourIterator = leftChild-elementBvhLength+1; contourIterator<=leftChild-elementBvhLength+lineCount; contourIterator++  )
+
+                        for (uint contourIterator = leftChild - elementBvhLength + 1;
+                             contourIterator <= leftChild - elementBvhLength + lineCount; contourIterator++)
                         {
                             uint lineIndex = elementIndexs[contourIterator];
                             uint p0Index = elementIndexs[linesOffset + 4 * lineIndex];
@@ -601,12 +576,14 @@ void main()
                             uint p2Index = elementIndexs[linesOffset + 4 * lineIndex + 2];
                             uint p3Index = elementIndexs[linesOffset + 4 * lineIndex + 3];
 
-											vec2 p0 = vec2(elementData[pointsOffset+2*p0Index], elementData[pointsOffset+2*p0Index+1]);
+                            vec2 p0 = vec2(elementData[pointsOffset + 2 * p0Index],
-											vec2 p1 = vec2(elementData[pointsOffset+2*p1Index], elementData[pointsOffset+2*p1Index+1]);
+                                           elementData[pointsOffset + 2 * p0Index + 1]);
-											vec2 p2 = vec2(elementData[pointsOffset+2*p2Index], elementData[pointsOffset+2*p2Index+1]);
+                            vec2 p1 = vec2(elementData[pointsOffset + 2 * p1Index],
-											vec2 p3 = vec2(elementData[pointsOffset+2*p3Index], elementData[pointsOffset+2*p3Index+1]);
+                                           elementData[pointsOffset + 2 * p1Index + 1]);
-
+                            vec2 p2 = vec2(elementData[pointsOffset + 2 * p2Index],
-											
+                                           elementData[pointsOffset + 2 * p2Index + 1]);
+                            vec2 p3 = vec2(elementData[pointsOffset + 2 * p3Index],
+                                           elementData[pointsOffset + 2 * p3Index + 1]);
 
                             if (p0 == p1 && p2 == p3)
                             {
@@ -617,20 +594,14 @@ void main()
                                 num_its += cubic_bezier_int_test(localUV, p0, p1, p2, p3);
                         }
 
-
-								
-
                         if (num_its % 2 == 1)
                         {
-											debugHit = true;
+                            elementColor = vec4(1);
+                            //debugHit = true;
                         }
-									
-										 
-										
                     }
                     else if (elementData[styleIndex] == 1) //Ïß
                     {
-									
                     }
 
                     elementBvhIndex = elementBvhLength;
@@ -641,7 +612,6 @@ void main()
                     elementStack.push(elementBvhIndex);
                     elementBvhIndex = leftChild;
                 }
-							  
             }
             else
                 elementBvhIndex = elementBvhLength;
@@ -653,7 +623,57 @@ void main()
             elementBvhIndex = bvhChildren[elementBvhRoot + elementBvhIndex].y;
         }
     }
-					//////////////////////////////////////////////
+    return elementColor.xyz;
+}
+
+
+
+void main()
+{
+
+    gBaseColor = vec4( vec3(1,0,0),1 );
+    // mainImage(gBaseColor, vec2(1.,1.)-TexCoords);
+    gPosition = WorldPos;
+    gNormal = normalize(Normal);
+    // gMetallicRoughness = vec2(1, 46./255);
+    gMetallicRoughness = vec2(0 /*½ðÊô¶È*/, 0.8 /*´Ö²Ú¶È*/);
+    gPainting = vec3(1, vec2(1., 1.) - TexCoords * 2);
+    return;
+    // gBaseColor = vec4(TexCoords,1,1);
+    // gBaseColor = vec4(240./255, 220./255,157./255,1);
+    // gBaseColor = vec4(bvh[0].bound==vec4(0,0,1,1));
+
+    //vec2 uv = vec2(1., 1.) - TexCoords * 2;
+    vec2 uv = vec2(0., -0.7) ;
+    vec3 debugBVH = vec3(0);
+    bool debugHit = false;
+    stack.top = 0;
+    uint index = 0, visitTime = 0;
+    while (index < bvhLength || !stack.empty())
+    {
+        while (index < bvhLength)
+        {
+            visitTime++;
+            vec4 bound = bvhBound[index];
+            uint leftChild = bvhChildren[index].x;
+            if (leftChild >= bvhLength)
+            {
+                uint zIndex = bvhChildren[index].y / 65535;
+                float angle = (bvhChildren[index].y / 65535. - zIndex) * 2 * PI;
+
+                mat2 rotation = {{cos(angle), -sin(angle)}, {sin(angle), cos(angle)}};
+                vec2 localUV = uv - (bound.xy + bound.zw) / 2;
+                localUV = rotation * localUV;
+                localUV /= (bound.zw - bound.xy) / 2;
+                if (all(lessThan(vec2(-1), localUV)) && all(lessThan(localUV, vec2(1))))
+                {
+                    if (zIndex == 1)
+                        debugBVH = vec3(1, 0, 1);
+                    uint elementIndex = leftChild - bvhLength;
+                     debugBVH.bg += 0.5 * (localUV + vec2(1));
+                    // debugBVH = vec3(0);
+         
+                    //debugHit = drawElement(leftChild - bvhLength, localUV, debugBVH) == vec3(1);
                 
 
                     // mainImage(debugBVH,localUV);
@@ -702,14 +722,10 @@ void main()
             index = bvhChildren[index].y;
         }
     }
+
     if (debugHit)
         gBaseColor = vec4(vec3(1, 1, 0), 1);
     else
-		gBaseColor = vec4(debugBVH, 1);
+        gBaseColor = vec4(vec3(int(visitTime)-9), 1);
-	// gBaseColor = vec4( vec3(elementData[6]<0.5),1 );
+
-	// mainImage(gBaseColor, vec2(1.,1.)-TexCoords);
-	gPosition = WorldPos;
-	gNormal = normalize(Normal);
-	// gMetallicRoughness = vec2(1, 46./255);
-	gMetallicRoughness = vec2(0 /*½ðÊô¶È*/, 0.8 /*´Ö²Ú¶È*/);
 }

ArchitectureColoredPainting/main.cpp

@@ -1,5 +1,6 @@
 #include "MainWindow.h"
 #include <QtWidgets/QApplication>
+#include <QGuiApplication>
 
 extern "C" {
     _declspec(dllexport) unsigned long NvOptimusEnablement = 0x00000001;