okooooooo/EVEngine
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
453d33387fd7f5f4b7826b209b421e1ebc1c696b
EVEngine/test/gpu_driven.cpp
T
西风逍遥游 453d33387f Merge remote-tracking branch 'origin/dev' into codex/gpu-driven-rendering 
# Conflicts:
#	AGENTS.md
#	external/VKBuilder
#	src/modules/graphics/Graphics.h
#	src/modules/graphics/RenderControl.cpp
#	src/modules/graphics/RenderSystem3D.cpp
#	src/modules/graphics/vulkan/Graphics.cpp
#	src/modules/graphics/vulkan/Graphics.h
2026-08-21 20:45:42 +08:00

598 lines
21 KiB
C++
Raw Blame History

#include "zeroerr/assert.h"
#include "zeroerr/unittest.h"
#include <SDL2/SDL.h>
#include <SDL2/SDL_vulkan.h>
#include "graphics/Graphics.h"
#include "graphics/Light.h"
#include "graphics/Material.h"
#include "graphics/Mesh.h"
#include "graphics/RenderControl.h"
#include "graphics/RenderSystem.h"
#include "graphics/RenderSystem3D.h"
#include "graphics/Texture.h"
#include "graphics/vulkan/Graphics.h"
#include "graphics/vulkan/GpuDriven.h"
#include "virtualgeometry/Builder.h"
#include "virtualgeometry/VirtualGeometryAsset.h"
#include "window/Window.h"
#include <algorithm>
#include <cmath>
#include <vector>
using namespace eve::graphics;
namespace {
void openGfxWindow(eve::window::Window *&win, Graphics *&gfx, int w = 320, int h = 240) {
win = eve::window::Window::create();
gfx = Graphics::create();
REQUIRE(win != nullptr);
REQUIRE(gfx != nullptr);
eve::window::WindowSettings s;
s.width = w;
s.height = h;
s.centered = true;
REQUIRE(win->setWindowSettings(s));
}
} // namespace
// Direct SDL Vulkan probe, independent of the engine init path. If this
// crashes, the problem is in SDL/driver state rather than Graphics::init.
TEST_CASE("GpuDriven.capsAvailable") {
eve::window::Window *win = nullptr;
Graphics *gfx = nullptr;
openGfxWindow(win, gfx);
auto *vg = dynamic_cast<eve::graphics::vulkan::Graphics *>(gfx);
REQUIRE(vg != nullptr);
CHECK(vg->gpuDrivenCaps().gpuDrivenAvailable());
win->close();
}
TEST_CASE("GpuDriven.bindlessTextureRegistration") {
eve::window::Window *win = nullptr;
Graphics *gfx = nullptr;
openGfxWindow(win, gfx);
auto *vg = dynamic_cast<eve::graphics::vulkan::Graphics *>(gfx);
REQUIRE(vg != nullptr);
if (!vg->gpuDrivenCaps().gpuDrivenAvailable()) {
win->close();
return; // environment without 1.2 features: nothing to validate
}
const uint8_t red[4] = {255, 0, 0, 255};
const uint8_t green[4] = {0, 255, 0, 255};
Texture *a = gfx->newTexture(1, 1, red);
Texture *b = gfx->newTexture(1, 1, green);
const uint32_t sa = vg->debugBindlessIndex(a);
const uint32_t sb = vg->debugBindlessIndex(b);
CHECK(sa != eve::graphics::vulkan::kInvalidBindlessSlot);
CHECK(sb != eve::graphics::vulkan::kInvalidBindlessSlot);
CHECK(sa != sb); // distinct slots
const std::vector<uint8_t> cubePx(6 * 4, 128);
Texture *cube = gfx->newCubemap(1, cubePx.data());
auto *gpuCube = static_cast<eve::graphics::vulkan::GpuTexture *>(cube->gpuHandle);
CHECK(gpuCube->bindlessIndexCube != eve::graphics::vulkan::kInvalidBindlessSlot);
win->close();
}
TEST_CASE("GpuDriven.meshTableRegistration") {
eve::window::Window *win = nullptr;
Graphics *gfx = nullptr;
openGfxWindow(win, gfx);
auto *vg = dynamic_cast<eve::graphics::vulkan::Graphics *>(gfx);
REQUIRE(vg != nullptr);
if (!vg->gpuDrivenCaps().gpuDrivenAvailable()) {
win->close();
return;
}
Mesh *m = gfx->newMeshSphere(8, 4);
REQUIRE(m != nullptr);
const uint32_t idx = vg->debugMeshRecordIndex(m);
CHECK(idx != eve::graphics::vulkan::kInvalidBindlessSlot);
auto *gpu = static_cast<eve::graphics::vulkan::GpuMesh *>(m->gpuHandle);
CHECK(gpu->record.vertexCount > 0);
CHECK(gpu->record.indexCount > 0);
CHECK(gpu->record.boundsCenterRadius.w > 0.f); // bounds computed at upload
win->close();
}
namespace {
float gdLuma(const Color &c) { return (c.r + c.g + c.b) / 3.f; }
void gdWarmPresent(Graphics *gfx) {
for (int i = 0; i < 4; ++i) {
RenderSystem3D::render(*gfx);
RenderSystem::render(*gfx);
}
}
/** @brief UV sphere (radius r) with positions + normals + triangle indices. */
void gdSphere(float r, int slices, int stacks, std::vector<float> &pos,
std::vector<float> &nrm, std::vector<uint32_t> &idx) {
pos.clear();
nrm.clear();
idx.clear();
for (int s = 0; s <= slices; ++s) {
const float u = float(s) / float(slices);
for (int t = 0; t <= stacks; ++t) {
const float v = float(t) / float(stacks);
const float theta = u * 6.2831853f;
const float phi = v * 3.14159265f;
const float x = std::sin(phi) * std::cos(theta);
const float y = std::cos(phi);
const float z = std::sin(phi) * std::sin(theta);
pos.push_back(x * r);
pos.push_back(y * r);
pos.push_back(z * r);
nrm.push_back(x);
nrm.push_back(y);
nrm.push_back(z);
}
}
const int stride = stacks + 1;
for (int s = 0; s < slices; ++s) {
for (int t = 0; t < stacks; ++t) {
const uint32_t i0 = uint32_t(s * stride + t);
const uint32_t i1 = uint32_t(s * stride + t + 1);
const uint32_t i2 = uint32_t((s + 1) * stride + t);
const uint32_t i3 = uint32_t((s + 1) * stride + t + 1);
idx.push_back(i0);
idx.push_back(i2);
idx.push_back(i1);
idx.push_back(i1);
idx.push_back(i2);
idx.push_back(i3);
}
}
}
/** @brief Pack CPU VgCluster into the GPU GpuVgCluster layout (4 x uvec4). */
void gdPackVgClusters(const eve::virtualgeometry::VirtualGeometryAsset &asset,
std::vector<eve::graphics::GpuVgCluster> &out) {
out.resize(asset.clusters.size());
auto fb = [](float f) {
union {
float f;
uint32_t u;
} x;
x.f = f;
return x.u;
};
for (size_t i = 0; i < asset.clusters.size(); ++i) {
const auto &c = asset.clusters[i];
GpuVgCluster &g = out[i];
g.u0[0] = fb(c.cx);
g.u0[1] = fb(c.cy);
g.u0[2] = fb(c.cz);
g.u0[3] = fb(c.r);
g.u1[0] = c.triStart;
g.u1[1] = c.triCount;
g.u1[2] = c.lodLevel;
g.u1[3] = c.parent;
g.u2[0] = fb(c.errorR);
g.u2[1] = fb(c.errorRScreen);
g.u2[2] = c.childCount;
g.u2[3] = 0;
for (int k = 0; k < 4; ++k) g.u3[k] = c.children[k];
}
}
std::vector<float> gdCaptureLuma(Graphics *gfx) {
const int w = gfx->getWidth();
const int h = gfx->getHeight();
std::vector<float> out(size_t(w) * size_t(h), 0.f);
for (int y = 0; y < h; y += 4) {
for (int x = 0; x < w; x += 4) {
out[size_t(y * w + x)] = gdLuma(gfx->getPixel(x, y));
}
}
return out;
}
Texture *gdSolid(Graphics *gfx, uint8_t r, uint8_t g, uint8_t b) {
const uint8_t px[4] = {r, g, b, 255};
return gfx->newTexture(1, 1, px);
}
} // namespace
/**
* @brief The opaque forward pass must produce the same image with the legacy
* per-draw path and the GPU-driven (indirect + bindless) path.
*/
TEST_CASE("GpuDriven.opaqueForwardParity") {
eve::window::Window *win = nullptr;
Graphics *gfx = nullptr;
openGfxWindow(win, gfx, 320, 240);
auto *vg = dynamic_cast<eve::graphics::vulkan::Graphics *>(gfx);
REQUIRE(vg != nullptr);
if (!vg->gpuDrivenCaps().gpuDrivenAvailable()) {
win->close();
return;
}
auto *cam = Camera3D::createCamera();
cam->setEye(0.f, 3.5f, 5.5f);
cam->setTarget(0.f, 0.f, 0.f);
cam->setAmbient(0.08f, 0.08f, 0.10f);
Material *ballMat = gfx->newMaterial();
ballMat->setAlbedoTexture(gdSolid(gfx, 205, 70, 60)); // single texture -> slot 0
ballMat->setNormalTexture(nullptr);
ballMat->setRoughness(0.5f);
ballMat->setMetallic(0.1f);
auto *ball = Renderable3D::create();
ball->setMesh(gfx->newMeshSphere(24, 16));
ball->setMaterial(ballMat);
ball->setPosition(0.f, 0.35f, 0.f);
ball->setScale(0.55f, 0.55f, 0.55f);
auto *sun = Light3D::createLight("dir");
sun->setDirection(0.55f, 1.f, 0.35f);
sun->setColor(1.f, 1.f, 1.f, 2.5f);
sun->setCastShadow(false); // isolate the direct-light path first
gfx->setScreenReadbackEnabled(true);
RenderControl *rc = gfx->getRenderControl();
rc->disable("gpuDriven");
gdWarmPresent(gfx);
const auto legacy = gdCaptureLuma(gfx);
rc->enable("gpuDriven");
gdWarmPresent(gfx);
const auto gpuDriven = gdCaptureLuma(gfx);
// Same shading source, different emission path: allow small float noise.
float maxDelta = 0.f;
const int w = gfx->getWidth();
const int h = gfx->getHeight();
for (int y = 0; y < h; y += 4) {
for (int x = 0; x < w; x += 4) {
const size_t i = size_t(y * w + x);
const float d = std::fabs(legacy[i] - gpuDriven[i]);
maxDelta = std::max(maxDelta, d);
}
}
rc->disable("gpuDriven");
CHECK(maxDelta < 0.03f);
win->close();
}
/**
* @brief Multi-texture parity: two spheres with distinct bindless slots
* (albedo slot 0 and slot 1) must produce the same image on the legacy path
* and the GPU-driven path. Regression test for descriptor-array dynamic
* indexing at element > 0.
*/
TEST_CASE("GpuDriven.opaqueForwardParityMultiTexture") {
eve::window::Window *win = nullptr;
Graphics *gfx = nullptr;
openGfxWindow(win, gfx, 320, 240);
auto *vg = dynamic_cast<eve::graphics::vulkan::Graphics *>(gfx);
REQUIRE(vg != nullptr);
if (!vg->gpuDrivenCaps().gpuDrivenAvailable()) {
win->close();
return;
}
auto *cam = Camera3D::createCamera();
cam->setEye(0.f, 3.5f, 5.5f);
cam->setTarget(0.f, 0.f, 0.f);
cam->setAmbient(0.08f, 0.08f, 0.10f);
auto makeBall = [&](Mesh *mesh, Texture *albedo, float x) {
Material *mat = gfx->newMaterial();
mat->setAlbedoTexture(albedo);
mat->setNormalTexture(nullptr);
mat->setRoughness(0.5f);
mat->setMetallic(0.1f);
auto *obj = Renderable3D::create();
obj->setMesh(mesh);
obj->setMaterial(mat);
obj->setPosition(x, 0.35f, 0.f);
obj->setScale(0.55f, 0.55f, 0.55f);
return obj;
};
Mesh *shared = gfx->newMeshSphere(24, 16);
Texture *red = gdSolid(gfx, 205, 70, 60); // bindless slot 0
Texture *green = gdSolid(gfx, 60, 205, 90); // bindless slot 1
makeBall(shared, red, -1.2f); // material 0 -> slot 0
makeBall(shared, green, 1.2f); // material 1 -> slot 1
auto *sun = Light3D::createLight("dir");
sun->setDirection(0.55f, 1.f, 0.35f);
sun->setColor(1.f, 1.f, 1.f, 2.5f);
sun->setCastShadow(false);
gfx->setScreenReadbackEnabled(true);
RenderControl *rc = gfx->getRenderControl();
rc->disable("gpuDriven");
gdWarmPresent(gfx);
const auto legacy = gdCaptureLuma(gfx);
rc->enable("gpuDriven");
gdWarmPresent(gfx);
CHECK(vg->debugLastGpuDrivenDrawCount() > 0); // both spheres went through the path
const auto gpuDriven = gdCaptureLuma(gfx);
float maxDelta = 0.f;
const int w = gfx->getWidth();
const int h = gfx->getHeight();
for (int y = 0; y < h; y += 4) {
for (int x = 0; x < w; x += 4) {
const size_t i = size_t(y * w + x);
const float d = std::fabs(legacy[i] - gpuDriven[i]);
maxDelta = std::max(maxDelta, d);
}
}
rc->disable("gpuDriven");
CHECK(maxDelta < 0.03f);
win->close();
}
/**
* @brief Stage 2 cull parity: instances outside the frustum (behind the camera
* or far outside the sides) must be culled by the GPU chain while the final
* image stays pixel-identical to the legacy path (GPU-clipped geometry never
* contributed pixels anyway).
*/
TEST_CASE("GpuDriven.opaqueForwardCullParity") {
eve::window::Window *win = nullptr;
Graphics *gfx = nullptr;
openGfxWindow(win, gfx, 320, 240);
auto *vg = dynamic_cast<eve::graphics::vulkan::Graphics *>(gfx);
REQUIRE(vg != nullptr);
if (!vg->gpuDrivenCaps().gpuDrivenAvailable()) {
win->close();
return;
}
auto *cam = Camera3D::createCamera();
cam->setEye(0.f, 3.5f, 5.5f);
cam->setTarget(0.f, 0.f, 0.f);
cam->setAmbient(0.08f, 0.08f, 0.10f);
auto makeBall = [&](Mesh *mesh, Texture *albedo, float x, float z) {
Material *mat = gfx->newMaterial();
mat->setAlbedoTexture(albedo);
mat->setNormalTexture(nullptr);
mat->setRoughness(0.5f);
mat->setMetallic(0.1f);
auto *obj = Renderable3D::create();
obj->setMesh(mesh);
obj->setMaterial(mat);
obj->setPosition(x, 0.35f, z);
obj->setScale(0.55f, 0.55f, 0.55f);
return obj;
};
Mesh *shared = gfx->newMeshSphere(24, 16);
Texture *albedo = gdSolid(gfx, 120, 140, 160);
makeBall(shared, albedo, -1.2f, 0.f); // visible
makeBall(shared, albedo, 0.f, 0.f); // visible
makeBall(shared, albedo, 1.2f, 0.f); // visible
makeBall(shared, albedo, 0.f, 9.f); // behind the camera -> culled
makeBall(shared, albedo, -40.f, 0.f); // outside the left frustum -> culled
auto *sun = Light3D::createLight("dir");
sun->setDirection(0.55f, 1.f, 0.35f);
sun->setColor(1.f, 1.f, 1.f, 2.5f);
sun->setCastShadow(false);
gfx->setScreenReadbackEnabled(true);
RenderControl *rc = gfx->getRenderControl();
rc->disable("gpuDriven");
gdWarmPresent(gfx);
const auto legacy = gdCaptureLuma(gfx);
rc->enable("gpuDriven");
gdWarmPresent(gfx);
const auto gpuDriven = gdCaptureLuma(gfx);
vg->waitForSharedGpuResources();
CHECK(vg->debugGpuDrivenVisibleCount() == 3); // 2 of 5 instances culled
CHECK(vg->debugGpuDrivenCulledDrawCount() == 3);
float maxDelta = 0.f;
const int w = gfx->getWidth();
const int h = gfx->getHeight();
for (int y = 0; y < h; y += 4) {
for (int x = 0; x < w; x += 4) {
const size_t i = size_t(y * w + x);
const float d = std::fabs(legacy[i] - gpuDriven[i]);
maxDelta = std::max(maxDelta, d);
}
}
rc->disable("gpuDriven");
CHECK(maxDelta < 0.03f);
win->close();
}
/**
* @brief Stage 3 parity: the visibility-buffer path (GBuffer writes visID/
* visBary, scene color pass runs a fullscreen resolve) must produce the same
* image as the stage-2 forward shading, with the same GPU culling active.
* Requires the 1x scene pass (resolve path gates on MSAA off).
*/
TEST_CASE("GpuDriven.visResolveParity") {
eve::window::Window *win = nullptr;
Graphics *gfx = nullptr;
openGfxWindow(win, gfx, 320, 240);
auto *vg = dynamic_cast<eve::graphics::vulkan::Graphics *>(gfx);
REQUIRE(vg != nullptr);
if (!vg->gpuDrivenCaps().gpuDrivenAvailable()) {
win->close();
return;
}
auto *cam = Camera3D::createCamera();
cam->setEye(0.f, 3.5f, 5.5f);
cam->setTarget(0.f, 0.f, 0.f);
cam->setAmbient(0.08f, 0.08f, 0.10f);
auto makeBall = [&](Mesh *mesh, Texture *albedo, float x, float z) {
Material *mat = gfx->newMaterial();
mat->setAlbedoTexture(albedo);
mat->setNormalTexture(nullptr);
mat->setRoughness(0.5f);
mat->setMetallic(0.1f);
auto *obj = Renderable3D::create();
obj->setMesh(mesh);
obj->setMaterial(mat);
obj->setPosition(x, 0.35f, z);
obj->setScale(0.55f, 0.55f, 0.55f);
return obj;
};
Mesh *shared = gfx->newMeshSphere(24, 16);
Texture *albedo = gdSolid(gfx, 120, 140, 160);
makeBall(shared, albedo, -1.2f, 0.f); // visible
makeBall(shared, albedo, 0.f, 0.f); // visible
makeBall(shared, albedo, 1.2f, 0.f); // visible
makeBall(shared, albedo, 0.f, 9.f); // behind the camera -> culled
makeBall(shared, albedo, -40.f, 0.f); // outside the left frustum -> culled
auto *sun = Light3D::createLight("dir");
sun->setDirection(0.55f, 1.f, 0.35f);
sun->setColor(1.f, 1.f, 1.f, 2.5f);
sun->setCastShadow(false);
gfx->setScreenReadbackEnabled(true);
RenderControl *rc = gfx->getRenderControl();
rc->disable("msaa"); // resolve path requires the 1x scene pass
rc->disable("gpuDriven");
gdWarmPresent(gfx);
gdCaptureLuma(gfx); // warm the 1x scene pass; legacy reference not needed
rc->enable("gpuDriven");
gdWarmPresent(gfx);
const auto fwdGpu = gdCaptureLuma(gfx);
rc->enable("visResolve");
gdWarmPresent(gfx);
const auto resolved = gdCaptureLuma(gfx);
vg->waitForSharedGpuResources();
CHECK(vg->debugGpuDrivenVisibleCount() == 3); // same cull as forward
float maxDelta = 0.f;
const int w = gfx->getWidth();
const int h = gfx->getHeight();
for (int y = 0; y < h; y += 4) {
for (int x = 0; x < w; x += 4) {
const size_t i = size_t(y * w + x);
const float d = std::fabs(fwdGpu[i] - resolved[i]);
maxDelta = std::max(maxDelta, d);
}
}
rc->disable("gpuDriven");
rc->disable("visResolve");
std::printf("GpuDriven.visResolveParity maxDelta=%f\n", maxDelta);
CHECK(maxDelta < 0.06f);
win->close();
}
/**
* @brief Stage 3 VG: a mesh with an attached virtual-geometry asset is culled
* (frustum + HZB) and hardware-rasterized into the vis buffer, then resolved
* with flat material-tint shading. Verifies visible clusters and the resulting
* pixels, plus frustum culling when the object moves behind the camera.
*/
TEST_CASE("GpuDriven.vgVisResolve") {
eve::window::Window *win = nullptr;
Graphics *gfx = nullptr;
openGfxWindow(win, gfx, 320, 240);
auto *vg = dynamic_cast<eve::graphics::vulkan::Graphics *>(gfx);
REQUIRE(vg != nullptr);
if (!vg->gpuDrivenCaps().gpuDrivenAvailable() ||
!vg->gpuDrivenCaps().drawIndirectCount) {
win->close();
return;
}
// Shared geometry: UV sphere -> regular Mesh + VG cluster DAG.
std::vector<float> pos, nrm;
std::vector<uint32_t> idx;
gdSphere(0.9f, 24, 12, pos, nrm, idx);
eve::virtualgeometry::VirtualGeometryBuilder builder;
eve::virtualgeometry::VirtualGeometryAsset asset;
eve::virtualgeometry::VirtualGeometryBuilder::MeshInput in{
int(pos.size() / 3), pos.data(), nrm.data(), idx.data(), int(idx.size())};
REQUIRE(builder.build(in, eve::virtualgeometry::VirtualGeometryBuilder::Options{}, asset));
REQUIRE(!asset.clusters.empty());
REQUIRE(asset.totalTriangles() > 0);
std::vector<eve::graphics::GpuVgCluster> packed;
gdPackVgClusters(asset, packed);
eve::graphics::GpuVgAssetUpload up{};
up.positions = asset.positions.data();
up.vertexCount = asset.vertexCount;
up.normals = asset.normals.empty() ? nullptr : asset.normals.data();
up.triangles = asset.triangles.data();
up.triangleCount = int(asset.triangles.size());
up.clusters = packed.data();
up.clusterCount = int(packed.size());
const uint32_t vgAssetId = vg->gpuDrivenVgUpload(up);
REQUIRE(vgAssetId != eve::graphics::kInvalidGpuDrivenSlot);
Mesh *mesh = gfx->newMeshFromArrays(pos.data(), nrm.data(), nullptr, int(pos.size() / 3),
idx.data(), int(idx.size()));
REQUIRE(mesh != nullptr);
REQUIRE(vg->gpuDrivenVgAttachToMesh(mesh, vgAssetId));
CHECK(vg->gpuDrivenVgAssetId(mesh) == vgAssetId);
Material *mat = gfx->newMaterial();
mat->setTint(0.9f, 0.2f, 0.1f);
auto *obj = Renderable3D::create();
obj->setMesh(mesh);
obj->setMaterial(mat);
obj->setPosition(0.f, 0.f, 0.f);
obj->setScale(1.15f, 1.15f, 1.15f);
auto *cam = Camera3D::createCamera();
cam->setEye(0.f, 0.f, 3.2f);
cam->setTarget(0.f, 0.f, 0.f);
cam->setAmbient(0.15f, 0.15f, 0.17f);
auto *sun = Light3D::createLight("dir");
sun->setDirection(0.4f, 1.f, 0.3f);
sun->setColor(1.f, 1.f, 1.f, 2.2f);
sun->setCastShadow(false);
gfx->setScreenReadbackEnabled(true);
RenderControl *rc = gfx->getRenderControl();
rc->disable("msaa");
rc->enable("gpuDriven");
rc->enable("visResolve");
gdWarmPresent(gfx);
vg->waitForSharedGpuResources();
std::printf("vgVisResolve: resolveWanted=%d cullEnabled=%d drawCount=%u\n",
int(vg->gpuDrivenResolveWanted()), int(vg->gpuDrivenCullEnabled()),
vg->debugLastGpuDrivenDrawCount());
std::printf("vgVisResolve: rc== %d visResolve=%d msaa=%d gpuDriven=%d\n",
int(rc == gfx->getRenderControl()), int(rc->isEnabled("visResolve")),
int(rc->isEnabled("msaa")), int(rc->isEnabled("gpuDriven")));
const uint32_t visCount = vg->debugGpuDrivenVgVisibleCount();
std::printf("vgVisResolve: visible clusters=%u\n", visCount);
CHECK(visCount > 0);
const int w = gfx->getWidth();
const int h = gfx->getHeight();
const Color center = gfx->getPixel(w / 2, h / 2);
std::printf("vgVisResolve: center=(%.3f %.3f %.3f)\n", center.r, center.g, center.b);
// Flat tint shading: the lit sphere center must be clearly reddish.
CHECK(center.r > center.b + 0.05f);
// Frustum cull: move the object behind the camera -> no visible clusters.
obj->setPosition(0.f, 0.f, 40.f);
gdWarmPresent(gfx);
vg->waitForSharedGpuResources();
CHECK(vg->debugGpuDrivenVgVisibleCount() == 0);
rc->disable("gpuDriven");
rc->disable("visResolve");
win->close();
}
Reference in new issue View Git Blame Copy Permalink