okooooooo/EVEngine
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
1a97146aa3ba6ce89c7fa3f196558ba43ce034ff
EVEngine/test/particles_gpu_resident.cpp
T

584 lines
22 KiB
C++
Raw Blame History

#include "zeroerr/assert.h"
#include "zeroerr/unittest.h"
#include "graphics/Graphics.h"
#include "graphics/Light.h"
#include "particles/ParticleEmitter.h"
#include "particles/ParticleRuntime.h"
#include "particles/ParticleSystem.h"
#include "particles/Particles.h"
#include "window/Window.h"
#include <algorithm>
#include <array>
#include <cstdint>
#include <cstdio>
#include <filesystem>
#include <string>
#include <vector>
using namespace eve::particles;
namespace {
double median(std::vector<double> values) {
std::sort(values.begin(), values.end());
return values[values.size() / 2];
}
eve::graphics::Mesh* makeLeftHalfDepthPlane(eve::graphics::Graphics* gfx) {
const std::array<float, 12> positions = {
-1.f, -1.f, 0.5f, 0.f, -1.f, 0.5f, 0.f, 1.f, 0.5f, -1.f, 1.f, 0.5f,
};
const std::array<float, 12> normals = {
0.f, 0.f, 1.f, 0.f, 0.f, 1.f, 0.f, 0.f, 1.f, 0.f, 0.f, 1.f,
};
const std::array<float, 8> uvs = {0.f, 0.f, 1.f, 0.f, 1.f, 1.f, 0.f, 1.f};
const std::array<std::uint32_t, 6> indices = {0, 2, 1, 0, 3, 2};
return gfx->newMeshFromArrays(positions.data(), normals.data(), uvs.data(), 4, indices.data(), 6);
}
eve::graphics::Mesh* makeFullscreenPlane(eve::graphics::Graphics* gfx) {
const std::array<float, 12> positions = {
-1.f, -1.f, 0.5f, 1.f, -1.f, 0.5f, 1.f, 1.f, 0.5f, -1.f, 1.f, 0.5f,
};
const std::array<float, 12> normals = {
0.f, 0.f, 1.f, 0.f, 0.f, 1.f, 0.f, 0.f, 1.f, 0.f, 0.f, 1.f,
};
const std::array<float, 8> uvs = {0.f, 0.f, 1.f, 0.f, 1.f, 1.f, 0.f, 1.f};
const std::array<std::uint32_t, 6> indices = {0, 2, 1, 0, 3, 2};
return gfx->newMeshFromArrays(positions.data(), normals.data(), uvs.data(), 4, indices.data(), 6);
}
float colorDistance(const Color& a, const Color& b) {
const float dr = a.r - b.r;
const float dg = a.g - b.g;
const float db = a.b - b.b;
return std::sqrt(dr * dr + dg * dg + db * db);
}
} // namespace
TEST_CASE("particles.gpu.unsupportedFeaturesFallBackToCpu") {
auto* emitter = Particles::create()->newEmitter(256);
emitter->setRandomSeed(8128);
emitter->setGpuSimulation(true);
emitter->setCollision("bounce", 2.f, 0.5f, 0.f);
emitter->setEmissionRate(120.f);
emitter->setParticleLifetime(2.f, 2.f);
emitter->start();
ParticleSimSystem::update(0.25f);
CHECK(emitter->getGpuSimulation());
CHECK(!emitter->gpuSim()->residentActive);
CHECK_EQ(emitter->gpuSim()->residentHandle, std::uint64_t(0));
REQUIRE_GT(emitter->getCount(), 0);
REQUIRE_EQ(emitter->getCount(), emitter->sim()->alive);
}
TEST_CASE("particles.gpu.residentSimulationAndIndirectRendering") {
auto* window = eve::window::Window::create();
auto* gfx = eve::graphics::Graphics::create();
REQUIRE(window != nullptr);
REQUIRE(gfx != nullptr);
eve::window::WindowSettings settings;
settings.width = 800;
settings.height = 520;
settings.centered = true;
REQUIRE(window->setWindowSettings(settings));
REQUIRE(gfx->supportsGpuParticles());
gfx->setScreenReadbackEnabled(true);
const std::uint8_t whitePixel[4] = {255, 255, 255, 255};
auto* whiteTexture = gfx->newTexture(1, 1, whitePixel);
REQUIRE(whiteTexture != nullptr);
const std::array<std::array<float, 3>, 6> colors{{
{0.2f, 0.75f, 1.f},
{0.45f, 0.25f, 1.f},
{1.f, 0.18f, 0.5f},
{1.f, 0.55f, 0.08f},
{0.3f, 1.f, 0.5f},
{0.95f, 0.95f, 0.3f},
}};
std::vector<ParticleEmitter*> emitters;
emitters.reserve(colors.size());
for (std::size_t i = 0; i < colors.size(); ++i) {
auto* emitter = Particles::create()->newEmitter(8192);
emitter->setTexture(whiteTexture);
emitter->setRandomSeed(20260826 + int(i));
emitter->setGpuSimulation(true);
emitter->setPosition(115.f + float(i) * 114.f, 400.f);
emitter->setEmissionRate(1500.f);
emitter->setMaxSpawnPerFrame(32);
emitter->setParticleLifetime(0.9f, 1.45f);
emitter->setParticleSize(9.f, 18.f);
emitter->setSizes(1.f, 0.12f);
emitter->setSpeed(95.f, 245.f);
emitter->setSpread(6.2831853f);
emitter->setGravity(0.f, 105.f);
emitter->setDamping(0.16f);
emitter->setSpin(-4.f, 4.f);
if (i % 3 == 1) {
emitter->setRenderMode("axis");
emitter->setRenderAxis(i % 2 == 0 ? 35.f : -35.f);
} else if (i % 3 == 2) {
emitter->setRenderMode("velocity", 0.075f);
}
emitter->setBlendMode("additive");
emitter->setColorStart(colors[i][0], colors[i][1], colors[i][2], 0.95f);
emitter->setColorEnd(colors[i][0] * 0.25f, colors[i][1] * 0.12f, colors[i][2] * 0.3f, 0.f);
emitter->start();
emitters.push_back(emitter);
}
gfx->setBackgroundColorRGBA(0.008f, 0.012f, 0.035f, 1.f);
constexpr float dt = 1.f / 60.f;
for (int frame = 0; frame < 150; ++frame) {
ParticleSimSystem::update(dt);
gfx->clearScreen();
gfx->drawSolidRectRGBA(24.f, 22.f, 752.f, 476.f, 0.015f, 0.025f, 0.075f, 1.f);
ParticleRenderSystem::render(gfx);
gfx->present();
}
std::uint64_t submittedFrames = 0;
std::uint32_t delayedAlive = 0;
std::uint32_t indirectInstances = 0;
int estimatedAlive = 0;
for (auto* emitter : emitters) {
auto gpu = emitter->gpuSim();
REQUIRE(gpu->residentActive);
REQUIRE(emitter->isGpuSimulationActive());
REQUIRE_NE(gpu->residentHandle, std::uint64_t(0));
REQUIRE_EQ(emitter->sim()->alive, 0);
const auto gpuStats = gfx->getGpuParticleStats(gpu->residentHandle);
submittedFrames += gpuStats.submittedFrames;
delayedAlive += gpuStats.alive;
indirectInstances += gpuStats.instances;
estimatedAlive += gpu->estimatedAlive;
}
REQUIRE_GT(submittedFrames, std::uint64_t(800));
REQUIRE_GT(delayedAlive, std::uint32_t(1000));
REQUIRE_GT(indirectInstances, std::uint32_t(1000));
REQUIRE_GT(estimatedAlive, 1000);
REQUIRE_GT(particleFrameStats().renderedParticles, 1000);
REQUIRE_EQ(particleFrameStats().gpuResidentEmitters, 6);
REQUIRE_GT(particleFrameStats().gpuResidentParticles, 1000);
const std::string output = std::string(EVENGINE_TEST_BINARY_DIR) + "/particle_gpu_resident.png";
CHECK(gfx->saveFramePng(output));
CHECK(std::filesystem::exists(output));
REQUIRE(std::filesystem::file_size(output) > std::uintmax_t(4096));
// Enabling a gameplay-coupled feature at runtime must not be silently
// ignored by a previously activated GPU emitter. It resets to CPU safely.
emitters.front()->setCollision("bounce", 2.f, 0.5f, 0.f);
ParticleSimSystem::update(dt);
CHECK(!emitters.front()->isGpuSimulationActive());
REQUIRE_GT(emitters.front()->sim()->alive, 0);
for (auto* emitter : emitters) {
emitter->setVisible(false);
emitter->setGpuSimulation(false);
}
window->close();
}
TEST_CASE("particles.gpu.multipleResidentEmittersKeepIndependentDrawState") {
auto* window = eve::window::Window::create();
auto* gfx = eve::graphics::Graphics::create();
REQUIRE(window != nullptr);
REQUIRE(gfx != nullptr);
eve::window::WindowSettings settings;
settings.width = 640;
settings.height = 360;
settings.centered = true;
REQUIRE(window->setWindowSettings(settings));
REQUIRE(gfx->supportsGpuParticles());
gfx->setScreenReadbackEnabled(true);
const std::uint8_t whitePixel[4] = {255, 255, 255, 255};
auto* texture = gfx->newTexture(1, 1, whitePixel);
REQUIRE(texture != nullptr);
const std::array<float, 3> positions{160.f, 320.f, 480.f};
const std::array<std::array<float, 3>, 3> colors{{
{1.f, 0.f, 0.f},
{0.f, 1.f, 0.f},
{0.f, 0.f, 1.f},
}};
std::array<ParticleEmitter*, 3> emitters{};
for (std::size_t i = 0; i < emitters.size(); ++i) {
auto* emitter = Particles::create()->newEmitter(8);
emitter->setTexture(texture);
emitter->setRandomSeed(7200 + int(i));
emitter->setGpuSimulation(true);
emitter->setPosition(positions[i], 180.f);
emitter->setEmissionRate(0.f);
emitter->setParticleLifetime(10.f, 10.f);
emitter->setParticleSize(64.f, 64.f);
emitter->setSpeed(0.f, 0.f);
emitter->setSpread(0.f);
emitter->setBlendMode("alpha");
emitter->setColorStart(colors[i][0], colors[i][1], colors[i][2], 1.f);
emitter->setColorEnd(colors[i][0], colors[i][1], colors[i][2], 1.f);
emitter->emit(1);
emitters[i] = emitter;
}
gfx->setBackgroundColorRGBA(0.f, 0.f, 0.f, 1.f);
for (int frame = 0; frame < 5; ++frame) {
ParticleSimSystem::update(1.f / 60.f);
gfx->clearScreen();
ParticleRenderSystem::render(gfx);
gfx->present();
}
for (std::size_t i = 0; i < emitters.size(); ++i) {
REQUIRE(emitters[i]->isGpuSimulationActive());
const auto stats = gfx->getGpuParticleStats(emitters[i]->gpuSim()->residentHandle);
REQUIRE_EQ(stats.instances, std::uint32_t(1));
}
const auto red = gfx->getPixel(160, 180);
const auto green = gfx->getPixel(320, 180);
const auto blue = gfx->getPixel(480, 180);
REQUIRE_GT(red.r, 0.8f);
REQUIRE_LT(red.g + red.b, 0.2f);
REQUIRE_GT(green.g, 0.8f);
REQUIRE_LT(green.r + green.b, 0.2f);
REQUIRE_GT(blue.b, 0.8f);
REQUIRE_LT(blue.r + blue.g, 0.2f);
const std::string output = std::string(EVENGINE_TEST_BINARY_DIR) + "/particle_gpu_multi_emitter.png";
CHECK(gfx->saveFramePng(output));
for (auto* emitter : emitters) {
emitter->setGpuSimulation(false);
emitter->release();
}
window->close();
}
TEST_CASE("particles.renderer.normalMappedLitMaterialUsesSceneLights") {
auto* window = eve::window::Window::create();
auto* gfx = eve::graphics::Graphics::create();
REQUIRE(window != nullptr);
REQUIRE(gfx != nullptr);
eve::window::WindowSettings settings;
settings.width = 480;
settings.height = 280;
settings.centered = true;
REQUIRE(window->setWindowSettings(settings));
gfx->setScreenReadbackEnabled(true);
const std::uint8_t albedoPixel[4] = {80, 80, 80, 255};
const std::uint8_t normalPixel[4] = {128, 128, 255, 255};
auto* albedo = gfx->newTexture(1, 1, albedoPixel);
auto* normal = gfx->newTexture(1, 1, normalPixel);
REQUIRE(albedo != nullptr);
REQUIRE(normal != nullptr);
auto makeEmitter = [&](float x, bool lit) {
auto* emitter = Particles::create()->newEmitter(8);
emitter->setTexture(albedo);
emitter->setNormalTexture(normal);
emitter->setMaterialMode(lit ? "lit" : "unlit");
emitter->setGpuSimulation(lit);
emitter->setPosition(x, 140.f);
emitter->setEmissionRate(0.f);
emitter->setParticleLifetime(10.f, 10.f);
emitter->setParticleSize(104.f, 104.f);
emitter->setSpeed(0.f, 0.f);
emitter->setSpread(0.f);
emitter->setBlendMode("alpha");
emitter->setColorStart(1.f, 1.f, 1.f, 1.f);
emitter->setColorEnd(1.f, 1.f, 1.f, 1.f);
emitter->emit(1);
return emitter;
};
auto* lit = makeEmitter(150.f, true);
auto* unlit = makeEmitter(330.f, false);
auto* light = eve::graphics::Light2D::createLight("point");
light->setPosition(150.f, 140.f);
light->setColor(1.f, 0.75f, 0.45f, 4.f);
light->setRadius(180.f);
light->setEnabled(true);
gfx->setBackgroundColorRGBA(0.005f, 0.007f, 0.012f, 1.f);
for (int frame = 0; frame < 4; ++frame) {
ParticleSimSystem::update(1.f / 60.f);
gfx->clearScreen();
ParticleRenderSystem::render(gfx);
gfx->present();
}
REQUIRE(!lit->isGpuSimulationActive());
const auto litPixel = gfx->getPixel(150, 140);
const auto unlitPixel = gfx->getPixel(330, 140);
REQUIRE_GT(litPixel.r, unlitPixel.r + 0.2f);
REQUIRE_GT(litPixel.r, litPixel.b + 0.1f);
const std::string output = std::string(EVENGINE_TEST_BINARY_DIR) + "/particle_lit_material.png";
CHECK(gfx->saveFramePng(output));
CHECK(std::filesystem::exists(output));
lit->release();
unlit->release();
light->setEnabled(false);
window->close();
}
TEST_CASE("particles.renderer.distortionRefractsResolvedSceneColor") {
auto* window = eve::window::Window::create();
auto* gfx = eve::graphics::Graphics::create();
REQUIRE(window != nullptr);
REQUIRE(gfx != nullptr);
eve::window::WindowSettings settings;
settings.width = 640;
settings.height = 360;
settings.centered = true;
REQUIRE(window->setWindowSettings(settings));
gfx->setScreenReadbackEnabled(true);
constexpr int width = 640;
constexpr int height = 360;
constexpr int effectX = 304;
std::vector<std::uint8_t> stripePixels(std::size_t(width) * 4u);
for (int x = 0; x < width; ++x) {
const bool cyan = (x / 32) % 2 == 0;
auto* pixel = &stripePixels[std::size_t(x) * 4u];
pixel[0] = cyan ? 12 : 218;
pixel[1] = cyan ? 188 : 18;
pixel[2] = cyan ? 218 : 184;
pixel[3] = 255;
}
auto* backgroundTexture = gfx->newTexture(width, 1, stripePixels.data());
auto* scenePlane = makeFullscreenPlane(gfx);
REQUIRE(backgroundTexture != nullptr);
REQUIRE(scenePlane != nullptr);
eve::graphics::Lighting3DPack sceneLighting;
sceneLighting.ambient = glm::vec4(1.f, 1.f, 1.f, 0.f);
gfx->setMesh3DLighting(sceneLighting);
gfx->setMesh3DMaterial(0.f, 1.f);
constexpr int fieldSize = 96;
std::vector<std::uint8_t> fieldPixels(std::size_t(fieldSize * fieldSize) * 4u);
for (int y = 0; y < fieldSize; ++y) {
for (int x = 0; x < fieldSize; ++x) {
const float nx = (float(x) + 0.5f) / float(fieldSize) * 2.f - 1.f;
const float ny = (float(y) + 0.5f) / float(fieldSize) * 2.f - 1.f;
const float feather = std::clamp((1.f - std::sqrt(nx * nx + ny * ny)) * 5.f, 0.f, 1.f);
auto* pixel = &fieldPixels[std::size_t(y * fieldSize + x) * 4u];
pixel[0] = 255;
pixel[1] = 128;
pixel[2] = 128;
pixel[3] = std::uint8_t(feather * 255.f);
}
}
auto* displacement = gfx->newTexture(fieldSize, fieldSize, fieldPixels.data());
REQUIRE(displacement != nullptr);
auto renderScene = [&] {
gfx->begin3DFrame();
gfx->drawMesh(scenePlane, glm::mat4(1.f), backgroundTexture, Color(1.f, 1.f, 1.f, 1.f));
gfx->clearScreen();
};
renderScene();
gfx->present();
CHECK(gfx->saveFramePng(std::string(EVENGINE_TEST_BINARY_DIR) + "/particle_scene_distortion_control.png"));
const Color source = gfx->getPixel(effectX, height / 2);
const Color target = gfx->getPixel(effectX + 32, height / 2);
REQUIRE_GT(colorDistance(source, target), 0.08f);
auto* emitter = Particles::create()->newEmitter(4);
emitter->setTexture(displacement);
emitter->setMaterialMode("distortion");
emitter->setDistortionStrength(32.f);
emitter->setPosition(float(effectX), float(height / 2));
emitter->setEmissionRate(0.f);
emitter->setParticleLifetime(10.f, 10.f);
emitter->setParticleSize(180.f, 180.f);
emitter->setSpeed(0.f, 0.f);
emitter->setSpread(0.f);
emitter->setColorStart(1.f, 1.f, 1.f, 1.f);
emitter->setColorEnd(1.f, 1.f, 1.f, 1.f);
emitter->emit(1);
ParticleSimSystem::update(1.f / 60.f);
renderScene();
ParticleRenderSystem::render(gfx);
gfx->present();
const Color refracted = gfx->getPixel(effectX, height / 2);
CHECK_LT(colorDistance(refracted, target), colorDistance(refracted, source));
CHECK_LT(colorDistance(refracted, target), 0.35f);
const std::string output = std::string(EVENGINE_TEST_BINARY_DIR) + "/particle_scene_distortion.png";
CHECK(gfx->saveFramePng(output));
CHECK(std::filesystem::exists(output));
REQUIRE(std::filesystem::file_size(output) > std::uintmax_t(4096));
emitter->release();
window->close();
}
TEST_CASE("particles.gpu.mainThreadCrossoverAtSixteenThousandParticles") {
auto* window = eve::window::Window::create();
auto* gfx = eve::graphics::Graphics::create();
REQUIRE(window != nullptr);
REQUIRE(gfx != nullptr);
eve::window::WindowSettings settings;
settings.width = 640;
settings.height = 360;
settings.centered = true;
REQUIRE(window->setWindowSettings(settings));
REQUIRE(gfx->supportsGpuParticles());
gfx->setVSync(false);
const std::uint8_t whitePixel[4] = {255, 255, 255, 255};
auto* whiteTexture = gfx->newTexture(1, 1, whitePixel);
REQUIRE(whiteTexture != nullptr);
auto makeEmitters = [&](bool gpuEnabled) {
std::vector<ParticleEmitter*> result;
for (int i = 0; i < 4; ++i) {
auto* emitter = Particles::create()->newEmitter(4096);
emitter->setTexture(whiteTexture);
emitter->setRandomSeed(4100 + i);
emitter->setGpuSimulation(gpuEnabled);
emitter->setPosition(150.f + 110.f * float(i), 180.f);
emitter->setEmissionRate(0.f);
emitter->setParticleLifetime(30.f, 30.f);
emitter->setParticleSize(4.f, 4.f);
emitter->setSpeed(2.f, 8.f);
emitter->setSpread(6.2831853f);
emitter->emit(4096);
result.push_back(emitter);
}
return result;
};
auto measureMainThread = [&](int warmupFrames, int measuredFrames) {
std::vector<double> samples;
for (int frame = 0; frame < warmupFrames + measuredFrames; ++frame) {
ParticleSimSystem::update(1.f / 60.f);
gfx->clearScreen();
ParticleRenderSystem::render(gfx);
if (frame >= warmupFrames) {
const auto& stats = particleFrameStats();
samples.push_back(stats.simulationMs + stats.renderMs);
}
gfx->present();
}
return median(std::move(samples));
};
auto cpuEmitters = makeEmitters(false);
const double cpuMs = measureMainThread(3, 12);
REQUIRE_EQ(particleFrameStats().particlesAfter, 16384);
for (auto* emitter : cpuEmitters) emitter->release();
auto gpuEmitters = makeEmitters(true);
const double gpuCpuMs = measureMainThread(5, 12);
REQUIRE_EQ(particleFrameStats().gpuResidentEmitters, 4);
REQUIRE_EQ(particleFrameStats().gpuResidentParticles, 16384);
std::fprintf(stdout, "[particles.perf] cpu-main=%.3fms gpu-main=%.3fms particles=16384\n", cpuMs, gpuCpuMs);
REQUIRE_LT(gpuCpuMs, cpuMs);
for (auto* emitter : gpuEmitters) {
emitter->setGpuSimulation(false);
emitter->release();
}
window->close();
}
TEST_CASE("particles.gpu.softDepthFadeUsesSceneLinearDepth") {
auto* window = eve::window::Window::create();
auto* gfx = eve::graphics::Graphics::create();
REQUIRE(window != nullptr);
REQUIRE(gfx != nullptr);
eve::window::WindowSettings settings;
settings.width = 640;
settings.height = 360;
settings.centered = true;
REQUIRE(window->setWindowSettings(settings));
REQUIRE(gfx->supportsGpuParticles());
gfx->setScreenReadbackEnabled(true);
const std::uint8_t whitePixel[4] = {255, 255, 255, 255};
const std::uint8_t darkPixel[4] = {5, 8, 14, 255};
auto* particleTex = gfx->newTexture(1, 1, whitePixel);
auto* planeTex = gfx->newTexture(1, 1, darkPixel);
auto* depthPlane = makeLeftHalfDepthPlane(gfx);
REQUIRE(particleTex != nullptr);
REQUIRE(planeTex != nullptr);
REQUIRE(depthPlane != nullptr);
auto makeEmitter = [&](float x) {
auto* emitter = Particles::create()->newEmitter(16);
emitter->setTexture(particleTex);
emitter->setRandomSeed(20260826);
emitter->setGpuSimulation(true);
emitter->setPosition(x, 180.f);
emitter->setEmissionRate(480.f);
emitter->setMaxSpawnPerFrame(8);
emitter->setParticleLifetime(10.f, 10.f);
emitter->setParticleSize(112.f, 112.f);
emitter->setSpeed(0.f, 0.f);
emitter->setSpread(0.f);
emitter->setBlendMode("alpha");
emitter->setColorStart(1.f, 0.05f, 0.75f, 1.f);
emitter->setColorEnd(1.f, 0.05f, 0.75f, 1.f);
emitter->setSoftParticles(false, 0.5f, 0.05f);
emitter->start();
return emitter;
};
auto* occluded = makeEmitter(160.f);
gfx->setBackgroundColorRGBA(0.004f, 0.006f, 0.014f, 1.f);
for (int frame = 0; frame < 8; ++frame) {
ParticleSimSystem::update(1.f / 60.f);
gfx->beginGBufferPass(640, 360);
gfx->drawMeshGBuffer(depthPlane, glm::mat4(1.f), glm::mat4(1.f), 0.1f, 100.f, planeTex);
gfx->endGBufferPass();
gfx->clearScreen();
ParticleRenderSystem::render(gfx);
gfx->present();
}
REQUIRE(occluded->isGpuSimulationActive());
const auto controlPixel = gfx->getPixel(160, 180);
const float controlMagenta = controlPixel.r + controlPixel.b - controlPixel.g;
const std::string controlOutput = std::string(EVENGINE_TEST_BINARY_DIR) + "/particle_soft_depth_control.png";
CHECK(gfx->saveFramePng(controlOutput));
CHECK(std::filesystem::exists(controlOutput));
occluded->setSoftParticles(true, 0.5f, 0.05f);
bool observedSoftDepth = false;
for (int frame = 0; frame < 4; ++frame) {
ParticleSimSystem::update(1.f / 60.f);
gfx->beginGBufferPass(640, 360);
gfx->drawMeshGBuffer(depthPlane, glm::mat4(1.f), glm::mat4(1.f), 0.1f, 100.f, planeTex);
gfx->endGBufferPass();
gfx->clearScreen();
ParticleRenderSystem::render(gfx);
observedSoftDepth = observedSoftDepth || occluded->isSoftParticlesActive();
gfx->present();
}
REQUIRE(observedSoftDepth);
const auto fadedPixel = gfx->getPixel(160, 180);
const float fadedMagenta = fadedPixel.r + fadedPixel.b - fadedPixel.g;
CHECK_GT(controlMagenta, fadedMagenta + 0.7f);
const std::string output = std::string(EVENGINE_TEST_BINARY_DIR) + "/particle_soft_depth.png";
CHECK(gfx->saveFramePng(output));
CHECK(std::filesystem::exists(output));
REQUIRE(std::filesystem::file_size(output) > std::uintmax_t(100));
occluded->setGpuSimulation(false);
occluded->release();
window->close();
}
Reference in new issue View Git Blame Copy Permalink