#include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace mbgl { namespace { constexpr auto ShaderName = "ParticleGpuValidationShader"; constexpr Size MaskSize{16, 16}; constexpr float EarthCircumferenceMeters = 40075016.68557849f; // This is a validation visual clock, not a multiplier on canonical U/V. At // 60 Hz it advances 20 simulation seconds per frame: a typical 5 m/s wind // moves about 100 m (roughly 0.65 px at z9), while a 30 m/s sample remains // below a four-pixel segment at that zoom. constexpr float VisualSimulationSecondsPerRealSecond = 1200.0f; constexpr float VisualSimulationReferenceZoom = 9.0f; constexpr float MinVisualSimulationSecondsPerRealSecond = 300.0f; constexpr float MaxVisualSimulationSecondsPerRealSecond = 153600.0f; constexpr float MaxSimulationDeltaSeconds = 2400.0f; constexpr float ParticleLifecycleRealSeconds = 12.0f; constexpr float TrailFadeReferenceFramesPerSecond = 60.0f; constexpr auto TrailCameraStableDelay = std::chrono::milliseconds(150); constexpr float ViewportRespawnMargin = 0.15f; constexpr float MinimumRespawnBoundsExtent = 0.000001f; std::atomic_uint64_t nextGpuGeneration{0}; std::atomic_uint64_t nextMaskGeneration{0}; std::atomic_uint64_t nextFieldGeneration{0}; std::atomic_uint64_t nextRenderLayerInstanceId{0}; struct ParticleSettings { bool active; uint8_t maskMode; uint8_t fixtureMode; bool usesFormalSource; float timeMix; uint32_t particleCount; float lineWidth; float particleLength; float particleOpacity; float trailOpacity; float trailFade; float advectionScale; bool speedColorEnabled; std::array particleColor; std::array trailColor; }; ParticleSettings particleSettings(const Immutable& value) { if (value->getTypeInfo() == style::RasterParticleLayer::Impl::staticTypeInfo()) { const auto& layer = static_cast(*value); return {layer.active, layer.maskMode, 0, true, layer.timeMix, layer.particleCount, layer.lineWidth, layer.particleLength, layer.particleOpacity, layer.trailOpacity, layer.trailFade, layer.advectionScale, layer.speedColorEnabled, layer.particleColor, layer.trailColor}; } assert(value->getTypeInfo() == style::ParticleValidationLayer::Impl::staticTypeInfo()); const auto& layer = static_cast(*value); return {layer.active, layer.maskMode, layer.fixtureMode, false, 0.0f, 256, 2.0f, 0.018f, 1.0f, 1.0f, 0.965f, 1.0f, false, {0.08f, 0.55f, 1.0f, 1.0f}, {1.0f, 1.0f, 1.0f, 1.0f}}; } enum class ValidationPass : uint8_t { State = 0, Trail = 1, Composite = 2, FrozenComposite = 3, TrailParticles = 4, TrailParticleCoverage = 6, }; const char* slotName(const uint8_t slot) { return slot == 0 ? "A" : "B"; } const char* textureDataTypeName(const gfx::TextureChannelDataType type) { switch (type) { case gfx::TextureChannelDataType::UnsignedByte: return "UnsignedByte"; case gfx::TextureChannelDataType::HalfFloat: return "HalfFloat"; case gfx::TextureChannelDataType::Float: return "Float"; } return "Unknown"; } Size validViewportSize(const Size size) { return {std::max(1, size.width), std::max(1, size.height)}; } Size particleStateSize(const uint32_t particleCount) { const auto side = static_cast(std::ceil(std::sqrt(static_cast(particleCount)))); return {side, side}; } const char* fixtureID(const uint8_t mode) { switch (mode) { case 0: return "uniform-east"; case 1: return "uniform-north"; default: return "vortex"; } } std::shared_ptr makeVelocityFieldImage(const particle::ParticleFieldSnapshot& field) { float scale = 1.0f; for (size_t index = 0; index < field.valid.size(); ++index) { if (!field.valid[index]) continue; scale = std::max(scale, std::abs(field.vector[index * 2])); scale = std::max(scale, std::abs(field.vector[index * 2 + 1])); } auto image = std::make_shared(Size{field.width, field.height}); for (uint32_t y = 0; y < field.height; ++y) { for (uint32_t x = 0; x < field.width; ++x) { const auto cell = (static_cast(y) * field.width + x) * 2; const auto pixel = (static_cast(y) * field.width + x) * PremultipliedImage::channels; image->data[pixel + 0] = static_cast( std::clamp(field.vector[cell] / scale * 0.5f + 0.5f, 0.0f, 1.0f) * 255.0f); image->data[pixel + 1] = static_cast( std::clamp(field.vector[cell + 1] / scale * 0.5f + 0.5f, 0.0f, 1.0f) * 255.0f); image->data[pixel + 2] = 0; image->data[pixel + 3] = field.valid[y * field.width + x] ? 255 : 0; } } return image; } float fieldVelocityScale(const particle::ParticleFieldSnapshot& field) { float scale = 1.0f; for (size_t index = 0; index < field.valid.size(); ++index) { if (!field.valid[index]) continue; scale = std::max(scale, std::abs(field.vector[index * 2])); scale = std::max(scale, std::abs(field.vector[index * 2 + 1])); } return scale; } double mercatorY(const double latitude) { const auto radians = latitude * M_PI / 180.0; return (1.0 - std::log(std::tan(radians) + 1.0 / std::cos(radians)) / M_PI) * 0.5; } std::array fieldBounds(const particle::ParticleFieldSnapshot& field) { return {static_cast((field.west + 180.0) / 360.0), static_cast(mercatorY(field.north)), static_cast((field.east + 180.0) / 360.0), static_cast(mercatorY(field.south))}; } struct RespawnDomain { std::array bounds; bool fallback = true; }; bool validMercatorBounds(const std::array& bounds) { return std::isfinite(bounds[0]) && std::isfinite(bounds[1]) && std::isfinite(bounds[2]) && std::isfinite(bounds[3]) && bounds[2] - bounds[0] >= MinimumRespawnBoundsExtent && bounds[3] - bounds[1] >= MinimumRespawnBoundsExtent; } RespawnDomain viewportRespawnDomain(const TransformState& transformState, const Size viewport, const particle::ParticleFieldSnapshot& field) { const auto fullFieldBounds = fieldBounds(field); if (!validMercatorBounds(fullFieldBounds)) { return {fullFieldBounds, true}; } const std::array corners = { ScreenCoordinate{0.0, 0.0}, ScreenCoordinate{static_cast(viewport.width), 0.0}, ScreenCoordinate{0.0, static_cast(viewport.height)}, ScreenCoordinate{static_cast(viewport.width), static_cast(viewport.height)}, }; float minX = std::numeric_limits::infinity(); float minY = std::numeric_limits::infinity(); float maxX = -std::numeric_limits::infinity(); float maxY = -std::numeric_limits::infinity(); for (const auto& corner : corners) { const auto latLng = transformState.screenCoordinateToLatLng(corner, LatLng::Unwrapped); const auto x = static_cast((latLng.longitude() + 180.0) / 360.0); const auto y = static_cast(mercatorY(latLng.latitude())); minX = std::min(minX, x); minY = std::min(minY, y); maxX = std::max(maxX, x); maxY = std::max(maxY, y); } const auto width = maxX - minX; const auto height = maxY - minY; if (!std::isfinite(width) || !std::isfinite(height) || width < MinimumRespawnBoundsExtent || height < MinimumRespawnBoundsExtent) { return {fullFieldBounds, true}; } minX -= width * ViewportRespawnMargin; maxX += width * ViewportRespawnMargin; minY -= height * ViewportRespawnMargin; maxY += height * ViewportRespawnMargin; const std::array intersection = { std::max(fullFieldBounds[0], minX), std::max(fullFieldBounds[1], minY), std::min(fullFieldBounds[2], maxX), std::min(fullFieldBounds[3], maxY), }; return validMercatorBounds(intersection) ? RespawnDomain{intersection, false} : RespawnDomain{fullFieldBounds, true}; } // VALIDATION ONLY: deterministic global fixture with a diagonal coast. Alpha // 255 means OCEAN, alpha 0 means LAND. It is intentionally tiny and is not a // production coastline source. std::shared_ptr makeCoastalMaskFixture() { auto image = std::make_shared(MaskSize); for (uint32_t y = 0; y < MaskSize.height; ++y) { for (uint32_t x = 0; x < MaskSize.width; ++x) { const bool ocean = x > (y / 2 + 3) && !(x > 11 && y < 4); const auto offset = (y * MaskSize.width + x) * PremultipliedImage::channels; image->data[offset + 0] = ocean ? 36 : 90; image->data[offset + 1] = ocean ? 128 : 66; image->data[offset + 2] = ocean ? 188 : 42; image->data[offset + 3] = ocean ? 255 : 0; } } return image; } int16_t wrapForLongitude(const double longitude) { return static_cast(std::floor((longitude + 180.0) / 360.0)); } void removeTargets(const std::vector& targets, UniqueChangeRequestVec& changes) { for (const auto& target : targets) { if (target) { changes.emplace_back(std::make_unique(target)); } } } template void removeTargets(const std::array& targets, UniqueChangeRequestVec& changes) { for (const auto& target : targets) { if (target) { changes.emplace_back(std::make_unique(target)); } } } } // namespace class ParticleGpuResources { public: uint64_t renderLayerInstanceId = 0; uint64_t generation = 0; uint64_t committedFrame = 0; uint8_t stateRead = 0; uint8_t trailRead = 0; bool stateSeeded = false; bool trailSeeded = false; bool pending = false; bool bootstrapPending = false; bool contextDestroyed = false; bool lifecycleModeKnown = false; bool lifecycleActive = false; bool formalDisplay = false; bool displayModeLogged = false; bool staticFreezeLogged = false; bool cameraDrawLogged = false; bool worldWrapLogged = false; bool antimeridianLogged = false; bool trailCameraKnown = false; bool trailCameraInvalidated = false; bool viewportDensityActive = false; bool viewportDensityLogged = false; uint64_t lastCameraLogFrame = 0; std::chrono::steady_clock::time_point lastPlaybackHeartbeat{}; std::chrono::steady_clock::time_point lastSimulationTick{}; std::chrono::steady_clock::time_point lastMotionLog{}; std::chrono::steady_clock::time_point lastLifecycleLog{}; std::chrono::steady_clock::time_point lastTrailCameraChange{}; uint64_t maskGeneration = 0; uint64_t fieldGeneration = 0; uint64_t gpuFieldGeneration = 0; uint64_t nextFieldGeneration = 0; uint64_t gpuNextFieldGeneration = 0; float fieldScale = 1.0f; float nextFieldScale = 1.0f; uint64_t fieldUploadCount = 0; uint64_t resetCount = 0; float timeMix = 0.0f; uint32_t particleCount = 0; float lineWidth = 2.0f; float particleLength = 0.018f; float particleOpacity = 1.0f; float trailOpacity = 1.0f; float trailFade = 0.92f; float advectionScale = 1.0f; // Match the formal layer default so a newly allocated resource cannot emit // one speed-colored frame before evaluated visual properties synchronize. bool speedColorEnabled = false; std::array particleColor{0.08f, 0.55f, 1.0f, 1.0f}; std::array trailColor{1.0f, 1.0f, 1.0f, 1.0f}; uint8_t fixtureMode = 255; uint8_t loggedMaskMode = 255; Size trailSize{}; Size stateSize{}; double trailCameraLatitude = 0.0; double trailCameraLongitude = 0.0; double trailCameraZoom = 0.0; double trailCameraBearing = 0.0; double trailCameraPitch = 0.0; std::array respawnBounds{}; std::array stateTargets; std::array trailTargets; std::vector registeredTargets; gfx::ShaderProgramBasePtr shader; gfx::Texture2DPtr maskTexture; gfx::Texture2DPtr fieldTexture; gfx::Texture2DPtr nextFieldTexture; gfx::Texture2DPtr stateTexture; particle::ParticleFieldSnapshot field; particle::ParticleFieldSnapshot nextField; std::shared_ptr timeline; std::shared_ptr fieldImage; std::shared_ptr nextFieldImage; std::shared_ptr maskFixture; std::shared_ptr> vertices; std::shared_ptr> particleVertices; std::shared_ptr> particleCoverageVertices; gfx::IndexVectorBasePtr particleIndices; gfx::IndexVectorBasePtr particleCoverageIndices; SegmentVector segments; SegmentVector particleSegments; SegmentVector particleCoverageSegments; uint8_t stateWrite() const { return static_cast(1 - stateRead); } uint8_t trailWrite() const { return static_cast(1 - trailRead); } void resetSequence(const char* reason) { ++resetCount; Log::Info(Event::Render, "ParticleGPU: event=SIMULATION_RESET reason=" + std::string(reason) + " renderLayerInstanceId=" + std::to_string(renderLayerInstanceId) + " resourceGeneration=" + std::to_string(generation) + " resetCount=" + std::to_string(resetCount)); committedFrame = 0; stateRead = 0; trailRead = 0; stateSeeded = false; trailSeeded = false; pending = false; bootstrapPending = false; staticFreezeLogged = false; lastSimulationTick = {}; for (const auto& target : stateTargets) { if (target && target->getLayerGroup(0)) { target->getLayerGroup(0)->clearDrawables(); } } for (const auto& target : trailTargets) { if (target && target->getLayerGroup(0)) { target->getLayerGroup(0)->clearDrawables(); } } } void commit() { if (!pending) { return; } stateRead = stateWrite(); trailRead = trailWrite(); stateSeeded = true; trailSeeded = true; if (!bootstrapPending) { ++committedFrame; } bootstrapPending = false; pending = false; } }; namespace { constexpr uint32_t MaxParticleVerticesPerSegment = std::numeric_limits::max() + 1u; void rebuildParticleDrawResources(const std::shared_ptr& resources) { auto vertices = std::make_shared>(); auto coverageVertices = std::make_shared>(); vertices->reserve(resources->particleCount * 2); coverageVertices->reserve(resources->particleCount * 4); for (uint32_t particleIndex = 0; particleIndex < resources->particleCount; ++particleIndex) { const auto x = static_cast(particleIndex % resources->stateSize.width); const auto y = static_cast(particleIndex / resources->stateSize.width); // Formal line path: x*2 + endpoint (0=previous, 1=current). vertices->emplace_back(HeatmapBucket::textureVertex({static_cast(x * 2), y})); vertices->emplace_back(HeatmapBucket::textureVertex({static_cast(x * 2 + 1), y})); // Metal coverage path: x*4 + corner (0..3). The shader projects the // true current State position, then applies only a 0.5-pixel clip-space // corner offset. Simulation/world coordinates are never modified. for (int16_t corner = 0; corner < 4; ++corner) { coverageVertices->emplace_back( HeatmapBucket::textureVertex({static_cast(x * 4 + corner), y})); } } auto indices = std::make_shared(); indices->reserve(MaxParticleVerticesPerSegment); for (uint32_t index = 0; index < MaxParticleVerticesPerSegment; ++index) { indices->extend(1, static_cast(index)); } constexpr uint32_t MaxCoverageVerticesPerSegment = MaxParticleVerticesPerSegment - (MaxParticleVerticesPerSegment % 4u); constexpr uint32_t MaxCoverageParticlesPerSegment = MaxCoverageVerticesPerSegment / 4u; auto coverageIndices = std::make_shared(); coverageIndices->reserve(MaxCoverageParticlesPerSegment * 6u); for (uint32_t particle = 0; particle < MaxCoverageParticlesPerSegment; ++particle) { const auto base = static_cast(particle * 4u); coverageIndices->extend(1, base + 0u); coverageIndices->extend(1, base + 1u); coverageIndices->extend(1, base + 2u); coverageIndices->extend(1, base + 2u); coverageIndices->extend(1, base + 1u); coverageIndices->extend(1, base + 3u); } SegmentVector segments; const auto lineVertexCount = resources->particleCount * 2u; for (uint32_t offset = 0; offset < lineVertexCount; offset += MaxParticleVerticesPerSegment) { const auto count = std::min(lineVertexCount - offset, MaxParticleVerticesPerSegment); segments.emplace_back(offset, 0, count, count); } SegmentVector coverageSegments; const auto coverageVertexCount = resources->particleCount * 4u; for (uint32_t offset = 0; offset < coverageVertexCount; offset += MaxCoverageVerticesPerSegment) { const auto vertexCount = std::min(coverageVertexCount - offset, MaxCoverageVerticesPerSegment); const auto particleCount = vertexCount / 4u; coverageSegments.emplace_back(offset, 0, vertexCount, particleCount * 6u); } resources->particleVertices = std::move(vertices); resources->particleCoverageVertices = std::move(coverageVertices); resources->particleIndices = std::move(indices); resources->particleCoverageIndices = std::move(coverageIndices); resources->particleSegments = std::move(segments); resources->particleCoverageSegments = std::move(coverageSegments); } class ParticleGpuValidationTweaker final : public gfx::DrawableTweaker { public: ParticleGpuValidationTweaker(std::shared_ptr state_, ValidationPass pass_, uint8_t readSlot_, uint8_t writeSlot_, gfx::Texture2DPtr source_, gfx::Texture2DPtr target_, gfx::Texture2DPtr mask_, gfx::Texture2DPtr stateTexture_, float simulationStep_, float wallDeltaSeconds_, float effectiveVisualSpeedScale_, int16_t worldWrap_, uint8_t maskMode_) : state(std::move(state_)), pass(pass_), readSlot(readSlot_), writeSlot(writeSlot_), source(std::move(source_)), target(std::move(target_)), mask(std::move(mask_)), stateTexture(std::move(stateTexture_)), simulationStep(simulationStep_), wallDeltaSeconds(wallDeltaSeconds_), effectiveVisualSpeedScale(effectiveVisualSpeedScale_), worldWrap(worldWrap_), maskMode(maskMode_) {} void init(gfx::Drawable&) override {} void execute(gfx::Drawable& drawable, PaintParameters& parameters) override { auto resources = state.lock(); if (parameters.pass != RenderPass::Translucent || !resources || !source) { return; } if (pass == ValidationPass::State) { const auto now = std::chrono::steady_clock::now(); if (now - resources->lastMotionLog >= std::chrono::seconds(1)) { resources->lastMotionLog = now; const auto valid = std::find(resources->field.valid.begin(), resources->field.valid.end(), uint8_t{1}); if (valid != resources->field.valid.end()) { const auto cell = static_cast(std::distance(resources->field.valid.begin(), valid)); const auto row = cell / resources->field.width; const auto latitude = resources->field.north + (resources->field.south - resources->field.north) * (static_cast(row) / std::max(1u, resources->field.height - 1)); const auto u = resources->field.vector[cell * 2]; const auto v = resources->field.vector[cell * 2 + 1]; const auto cosLatitude = std::max(0.01f, std::cos(static_cast(latitude * M_PI / 180.0))); const auto dx = u * simulationStep / EarthCircumferenceMeters; const auto dy = -v * simulationStep / (EarthCircumferenceMeters * cosLatitude); Log::Info(Event::Render, "ParticleMotion: fieldId=" + resources->field.fieldID + " sampleU=" + std::to_string(u) + " sampleV=" + std::to_string(v) + " zoom=" + std::to_string(parameters.state.getZoom()) + " referenceZoom=" + std::to_string(VisualSimulationReferenceZoom) + " effectiveVisualSpeedScale=" + std::to_string(effectiveVisualSpeedScale) + " wallDeltaSeconds=" + std::to_string(wallDeltaSeconds) + " simulationDeltaSeconds=" + std::to_string(simulationStep) + " estimatedStateDeltaWorld=" + std::to_string(dx) + "," + std::to_string(dy) + " estimatedPixelDelta=" + std::to_string(std::sqrt(dx * dx + dy * dy) * 512.0f * std::exp2(static_cast(parameters.state.getZoom()))) + " simulationFrame=" + std::to_string(resources->committedFrame)); } } if (resources->formalDisplay && now - resources->lastLifecycleLog >= std::chrono::seconds(1)) { resources->lastLifecycleLog = now; Log::Info(Event::Render, "ParticleLifecycle: configuredSlots=" + std::to_string(resources->particleCount) + " initialAge=HASH_STAGGERED maxAge=HASH_JITTERED_0.75_1.25 " "lifecycleBaseRealSeconds=" + std::to_string(ParticleLifecycleRealSeconds) + " respawn=GPU_HASH_ON_INVALID_OR_AGE_EXPIRED" " fieldId=" + resources->field.fieldID + " simulationFrame=" + std::to_string(resources->committedFrame) + " readback=disabled"); } } drawable.setTexture(source, shaders::idParticleGpuValidationPreviousTexture); if (mask) { drawable.setTexture(mask, shaders::idParticleGpuValidationMaskTexture); } if (resources->fieldTexture) { drawable.setTexture(resources->fieldTexture, shaders::idParticleGpuValidationFieldTexture); } if (resources->nextFieldTexture) { drawable.setTexture(resources->nextFieldTexture, shaders::idParticleGpuValidationNextFieldTexture); } if (stateTexture) { drawable.setTexture(stateTexture, shaders::idParticleGpuValidationStateTexture); } const float frame = simulationStep; const float markerX = resources->timeMix; // RenderTarget clear is opaque black. State initialization must therefore // be an explicit lifecycle signal, never inferred from sampled alpha. const bool seedState = pass == ValidationPass::State && !resources->stateSeeded; const shaders::ParticleGpuValidationUBO ubo = { .pass = {static_cast(pass), frame, maskMode == 0 ? 0.0f : 1.0f, resources->formalDisplay ? wallDeltaSeconds : static_cast(maskMode)}, .marker = {markerX, resources->speedColorEnabled ? 1.0f : 0.0f, resources->formalDisplay ? ParticleLifecycleRealSeconds : 0.035f, resources->formalDisplay ? TrailFadeReferenceFramesPerSecond : 0.965f}, .mask = {static_cast(resources->stateSize.width), static_cast(resources->stateSize.height), resources->formalDisplay ? 1.0f : 0.0f, seedState ? 1.0f : 0.0f}, .visual = {resources->particleOpacity, resources->particleLength, resources->trailOpacity, resources->formalDisplay ? resources->trailFade : 0.965f}, .fieldBounds = fieldBounds(resources->field), .respawnBounds = resources->respawnBounds, .fieldScale = {resources->fieldScale, resources->nextFieldScale, resources->viewportDensityActive ? 1.0f : 0.0f, static_cast(resources->trailSize.width)}, .advection = {resources->field.vectorSemantics == particle::VectorSemantics::Direction ? 1.0f : 0.0f, resources->advectionScale, 0.00001f, static_cast(resources->trailSize.height)}, .particleColor = resources->particleColor, .trailColor = resources->trailColor, .weatherStops = {}, .weatherColors = {}, .weatherRamp = {}, .matrix = util::cast(parameters.matrixForTile({worldWrap, {0, 0, 0}})), }; drawable.mutableUniformBuffers().createOrUpdate(shaders::idParticleGpuValidationUBO, &ubo, parameters.context); if (pass == ValidationPass::Composite || pass == ValidationPass::FrozenComposite) { const auto center = parameters.state.getLatLng(LatLng::Unwrapped); const bool primaryWorldCopy = resources->formalDisplay ? worldWrap == 0 : worldWrap == wrapForLongitude(center.longitude()); if (primaryWorldCopy && !resources->displayModeLogged) { Log::Info(Event::Render, "ParticleRender: displayMode=" + std::string(resources->formalDisplay ? "FORMAL_PARTICLE" : "VALIDATION") + " generation=" + std::to_string(resources->generation) + " compositeTrailRead=" + slotName(readSlot)); resources->displayModeLogged = true; } if (primaryWorldCopy && !resources->cameraDrawLogged) { std::ostringstream message; message << "ParticleValidation30_03: first camera-locked draw maskGeneration=" << resources->maskGeneration << " maskMode=" << static_cast(maskMode) << " center=" << center.latitude() << ',' << center.longitude() << " worldCopy=" << worldWrap << " zoom=" << parameters.state.getZoom() << " bearing=" << parameters.state.getBearing() << " pitch=" << parameters.state.getPitch() << " pixelRatio=" << parameters.pixelRatio; Log::Info(Event::Render, message.str()); resources->cameraDrawLogged = true; } if (primaryWorldCopy && parameters.frameCount >= resources->lastCameraLogFrame + 30) { Log::Info(Event::Render, "ParticleValidation30_03: camera frame=" + std::to_string(parameters.frameCount) + " center=" + std::to_string(center.latitude()) + ',' + std::to_string(center.longitude()) + " zoom=" + std::to_string(parameters.state.getZoom()) + " bearing=" + std::to_string(parameters.state.getBearing()) + " pitch=" + std::to_string(parameters.state.getPitch()) + " viewport=" + std::to_string(parameters.state.getSize().width) + 'x' + std::to_string(parameters.state.getSize().height)); resources->lastCameraLogFrame = parameters.frameCount; } if (primaryWorldCopy && worldWrap != 0 && !resources->worldWrapLogged) { Log::Info(Event::Render, "ParticleValidation30_03: world wrap draw canonical=0/0/0 wrap=" + std::to_string(worldWrap)); resources->worldWrapLogged = true; } if (primaryWorldCopy && std::abs(center.longitude()) >= 170.0 && !resources->antimeridianLogged) { Log::Info(Event::Render, "ParticleValidation30_03: antimeridian camera centerLon=" + std::to_string(center.longitude()) + " canonicalMask=[-180,180]"); resources->antimeridianLogged = true; } if (pass == ValidationPass::FrozenComposite) { if (!resources->staticFreezeLogged) { const auto size = parameters.state.getSize(); std::ostringstream message; message << "ParticleValidation30_02: STATIC frozen composite generation=" << resources->generation << " frame=" << resources->committedFrame << " stateRead=" << slotName(resources->stateRead) << " trailRead=" << slotName(resources->trailRead) << " offscreenPasses=0 swap=false viewport=" << size.width << 'x' << size.height << " zoom=" << parameters.state.getZoom() << " bearing=" << parameters.state.getBearing() << " pitch=" << parameters.state.getPitch(); Log::Info(Event::Render, message.str()); resources->staticFreezeLogged = true; } return; } // The same canonical quad is drawn for adjacent MapLibre world // copies. Only the center copy owns the 30-02 slot commit; copies // are draw-only and must never advance simulation a second time. if (!primaryWorldCopy) { return; } const auto beforeState = resources->stateRead; const auto beforeTrail = resources->trailRead; resources->commit(); if (resources->committedFrame <= 3 || resources->committedFrame % 60 == 0) { const auto size = parameters.state.getSize(); std::ostringstream message; message << "ParticleValidation30_02: commit generation=" << resources->generation << " frame=" << resources->committedFrame << " state=" << slotName(beforeState) << "->" << slotName(resources->stateRead) << " trail=" << slotName(beforeTrail) << "->" << slotName(resources->trailRead) << " order=State,Trail,Composite hazard=SAFE viewport=" << size.width << 'x' << size.height << " zoom=" << parameters.state.getZoom() << " bearing=" << parameters.state.getBearing() << " pitch=" << parameters.state.getPitch(); Log::Info(Event::Render, message.str()); } return; } if (source == target) { Log::Error(Event::Render, "ParticleValidation30_02: HAZARD source equals target generation=" + std::to_string(resources->generation)); return; } if (resources->committedFrame < 3 || (resources->committedFrame + 1) % 60 == 0) { const auto passName = pass == ValidationPass::State ? "State" : "Trail"; Log::Info(Event::Render, "ParticleValidation30_02: pass=" + std::string(passName) + " generation=" + std::to_string(resources->generation) + " frame=" + std::to_string(resources->committedFrame + 1) + " read=" + slotName(readSlot) + " write=" + slotName(writeSlot) + " distinct=true"); } if (pass == ValidationPass::State && (!resources->stateSeeded || resources->committedFrame < 3 || (resources->committedFrame + 1) % 60 == 0)) { Log::Info(Event::Render, "ParticleRender: stateSeed=" + std::string(seedState ? "INITIALIZE" : "CONTINUE") + " generation=" + std::to_string(resources->generation) + " state=" + slotName(readSlot) + "->" + slotName(writeSlot) + " field=" + resources->field.fieldID); } } private: std::weak_ptr state; ValidationPass pass; uint8_t readSlot; uint8_t writeSlot; gfx::Texture2DPtr source; gfx::Texture2DPtr target; gfx::Texture2DPtr mask; gfx::Texture2DPtr stateTexture; float simulationStep; float wallDeltaSeconds; float effectiveVisualSpeedScale; int16_t worldWrap; uint8_t maskMode; }; RenderTargetPtr createValidationTarget(gfx::Context& context, const Size size, const std::string& name, const gfx::TextureFilterType filter, const gfx::TextureChannelDataType type, const char* targetKind) { try { auto target = context.createRenderTarget(size, type); if (!target || !target->isRenderable() || !target->getTexture()) { Log::Error(Event::Render, "ParticleStateTarget: event=CREATE_FAILED kind=" + std::string(targetKind) + " dataType=" + textureDataTypeName(type) + " name=" + name + " stage=validation"); return {}; } target->getTexture()->setSamplerConfiguration( {.filter = filter, .wrapU = gfx::TextureWrapType::Clamp, .wrapV = gfx::TextureWrapType::Clamp}); auto group = context.createLayerGroup(0, 1, name); if (!group || !target->addLayerGroup(std::move(group), true)) { Log::Error(Event::Render, "ParticleStateTarget: event=CREATE_FAILED kind=" + std::string(targetKind) + " dataType=" + textureDataTypeName(type) + " name=" + name + " reason=LAYER_GROUP"); return {}; } Log::Info(Event::Render, "ParticleStateTarget: event=CREATE_SUCCESS kind=" + std::string(targetKind) + " dataType=" + textureDataTypeName(type) + " name=" + name + " size=" + std::to_string(size.width) + "x" + std::to_string(size.height)); return target; } catch (const std::exception& error) { Log::Error(Event::Render, "ParticleStateTarget: event=CREATE_FAILED kind=" + std::string(targetKind) + " dataType=" + textureDataTypeName(type) + " name=" + name + " stage=exception error=" + error.what()); return {}; } catch (...) { Log::Error(Event::Render, "ParticleStateTarget: event=CREATE_FAILED kind=" + std::string(targetKind) + " dataType=" + textureDataTypeName(type) + " name=" + name + " stage=unknown_exception"); return {}; } } bool buildQuad(gfx::Context& context, const std::shared_ptr& resources, LayerGroup& group, const std::string& name, const gfx::Texture2DPtr& source, const gfx::Texture2DPtr& target, const gfx::Texture2DPtr& mask, const gfx::Texture2DPtr& stateTexture, const float simulationStep, const ValidationPass pass, const uint8_t readSlot, const uint8_t writeSlot, const int16_t worldWrap, const uint8_t maskMode, const bool clearGroup, const float wallDeltaSeconds = 0.0f, const float effectiveVisualSpeedScale = VisualSimulationSecondsPerRealSecond) { if (clearGroup) { group.clearDrawables(); } auto attributes = context.createVertexAttributeArray(); if (const auto& attribute = attributes->set(shaders::idParticleGpuValidationPosVertexAttribute)) { attribute->setSharedRawData(resources->vertices, offsetof(HeatmapTextureLayoutVertex, a1), 0, sizeof(HeatmapTextureLayoutVertex), gfx::AttributeDataType::Short2); } auto builder = context.createDrawableBuilder(name); builder->setShader(resources->shader); builder->setRenderPass(RenderPass::Translucent); builder->setEnableDepth(false); builder->setColorMode(pass == ValidationPass::Composite || pass == ValidationPass::FrozenComposite ? gfx::ColorMode::alphaBlended() : gfx::ColorMode::unblended()); builder->setCullFaceMode(gfx::CullFaceMode::disabled()); builder->setVertexAttributes(std::move(attributes)); builder->setRawVertices({}, resources->vertices->elements(), gfx::AttributeDataType::Short2); builder->setSegments(gfx::Triangles(), RenderStaticData::quadTriangleIndices().vector(), resources->segments.data(), resources->segments.size()); builder->setTexture(source, shaders::idParticleGpuValidationPreviousTexture); if (mask) { builder->setTexture(mask, shaders::idParticleGpuValidationMaskTexture); } if (resources->fieldTexture) { builder->setTexture(resources->fieldTexture, shaders::idParticleGpuValidationFieldTexture); } if (resources->nextFieldTexture) { builder->setTexture(resources->nextFieldTexture, shaders::idParticleGpuValidationNextFieldTexture); } if (stateTexture) { builder->setTexture(stateTexture, shaders::idParticleGpuValidationStateTexture); } builder->addTweaker(std::make_shared(resources, pass, readSlot, writeSlot, source, target, mask, stateTexture, simulationStep, wallDeltaSeconds, effectiveVisualSpeedScale, worldWrap, maskMode)); // DrawableBuilder owns the current drawable until flush finalizes it. builder->flush(context); auto drawables = builder->clearDrawables(); if (drawables.size() != 1 || !drawables.front()) { Log::Error(Event::Render, "ParticleValidation30_02: failed to finalize drawable name=" + name); return false; } group.addDrawable(std::move(drawables.front())); return true; } bool buildParticlePoints(gfx::Context& context, const std::shared_ptr& resources, LayerGroup& group, const std::string& name, const gfx::Texture2DPtr& previousStateTexture, const gfx::Texture2DPtr& currentStateTexture, const gfx::Texture2DPtr& target, const uint8_t stateSlot, const uint8_t trailSlot) { if (!resources->particleVertices || !resources->particleIndices || resources->particleSegments.empty() || !previousStateTexture || !currentStateTexture || !target) { Log::Error(Event::Render, "ParticleGPU: event=PARTICLE_DRAW_REJECTED reason=MISSING_DRAW_RESOURCES"); return false; } auto attributes = context.createVertexAttributeArray(); if (const auto& attribute = attributes->set(shaders::idParticleGpuValidationPosVertexAttribute)) { attribute->setSharedRawData(resources->particleVertices, offsetof(HeatmapTextureLayoutVertex, a1), 0, sizeof(HeatmapTextureLayoutVertex), gfx::AttributeDataType::Short2); } auto builder = context.createDrawableBuilder(name); builder->setShader(resources->shader); builder->setRenderPass(RenderPass::Translucent); builder->setEnableDepth(false); builder->setColorMode(gfx::ColorMode::unblended()); builder->setCullFaceMode(gfx::CullFaceMode::disabled()); builder->setVertexAttributes(std::move(attributes)); builder->setRawVertices({}, resources->particleVertices->elements(), gfx::AttributeDataType::Short2); builder->setSegments(gfx::Lines(resources->lineWidth), resources->particleIndices, resources->particleSegments.data(), resources->particleSegments.size()); builder->setTexture(previousStateTexture, shaders::idParticleGpuValidationPreviousTexture); builder->setTexture(currentStateTexture, shaders::idParticleGpuValidationStateTexture); builder->addTweaker(std::make_shared(resources, ValidationPass::TrailParticles, stateSlot, trailSlot, previousStateTexture, target, resources->maskTexture, currentStateTexture, 0.0f, 0.0f, VisualSimulationSecondsPerRealSecond, 0, 0)); builder->flush(context); auto drawables = builder->clearDrawables(); if (drawables.size() != 1 || !drawables.front()) { Log::Error(Event::Render, "ParticleGPU: event=PARTICLE_DRAW_REJECTED reason=DRAWABLE_FINALIZE_FAILED"); return false; } group.addDrawable(std::move(drawables.front())); return true; } #if MLN_RENDER_BACKEND_METAL bool buildParticleEndpointCoverage(gfx::Context& context, const std::shared_ptr& resources, LayerGroup& group, const std::string& name, const gfx::Texture2DPtr& previousStateTexture, const gfx::Texture2DPtr& currentStateTexture, const gfx::Texture2DPtr& target, const uint8_t stateSlot, const uint8_t trailSlot) { if (!resources->particleCoverageVertices || !resources->particleCoverageIndices || resources->particleCoverageSegments.empty() || !previousStateTexture || !currentStateTexture || !target) { Log::Error(Event::Render, "ParticleGPU: event=PARTICLE_COVERAGE_REJECTED reason=MISSING_DRAW_RESOURCES"); return false; } auto attributes = context.createVertexAttributeArray(); if (const auto& attribute = attributes->set(shaders::idParticleGpuValidationPosVertexAttribute)) { attribute->setSharedRawData(resources->particleCoverageVertices, offsetof(HeatmapTextureLayoutVertex, a1), 0, sizeof(HeatmapTextureLayoutVertex), gfx::AttributeDataType::Short2); } auto builder = context.createDrawableBuilder(name); builder->setShader(resources->shader); builder->setRenderPass(RenderPass::Translucent); builder->setEnableDepth(false); builder->setColorMode(gfx::ColorMode::unblended()); builder->setCullFaceMode(gfx::CullFaceMode::disabled()); builder->setVertexAttributes(std::move(attributes)); builder->setRawVertices({}, resources->particleCoverageVertices->elements(), gfx::AttributeDataType::Short2); builder->setSegments(gfx::Triangles(), resources->particleCoverageIndices, resources->particleCoverageSegments.data(), resources->particleCoverageSegments.size()); builder->setTexture(previousStateTexture, shaders::idParticleGpuValidationPreviousTexture); builder->setTexture(currentStateTexture, shaders::idParticleGpuValidationStateTexture); builder->addTweaker(std::make_shared(resources, ValidationPass::TrailParticleCoverage, stateSlot, trailSlot, previousStateTexture, target, resources->maskTexture, currentStateTexture, 0.0f, 0.0f, VisualSimulationSecondsPerRealSecond, 0, 0)); builder->flush(context); auto drawables = builder->clearDrawables(); if (drawables.size() != 1 || !drawables.front()) { Log::Error(Event::Render, "ParticleGPU: event=PARTICLE_COVERAGE_REJECTED reason=DRAWABLE_FINALIZE_FAILED"); return false; } group.addDrawable(std::move(drawables.front())); return true; } #endif } // namespace RenderRasterParticleLayer::RenderRasterParticleLayer(Immutable impl_) : RenderLayer([&] { const auto settings = particleSettings(impl_); return makeMutable(std::move(impl_), settings.active, settings.maskMode, settings.fixtureMode, settings.timeMix, settings.particleCount, settings.lineWidth, settings.particleLength, settings.particleOpacity, settings.trailOpacity, settings.trailFade, settings.advectionScale, settings.speedColorEnabled, settings.particleColor, settings.trailColor); }()) { renderLayerInstanceId = ++nextRenderLayerInstanceId; formalSource = baseImpl->getTypeInfo() == style::RasterParticleLayer::Impl::staticTypeInfo(); Log::Info(Event::Render, "ParticleGPU: event=LAYER_CREATE layerId=" + getID() + " renderLayerInstanceId=" + std::to_string(renderLayerInstanceId) + " source=" + (formalSource ? baseImpl->source : std::string("validation-only"))); } RenderRasterParticleLayer::~RenderRasterParticleLayer() { if (gpuResources) { Log::Info(Event::Render, "ParticleGPU: event=LAYER_DESTROY layerId=" + getID() + " renderLayerInstanceId=" + std::to_string(renderLayerInstanceId) + " resourceGeneration=" + std::to_string(gpuResources->generation) + " contextDestroyed=" + (gpuResources->contextDestroyed ? "true" : "false")); } Log::Info(Event::Render, "ParticleValidation: RenderLayer destroy id=" + getID()); } void RenderRasterParticleLayer::evaluate(const PropertyEvaluationParameters&) { Log::Info(Event::Render, "ParticleGPU: event=LAYER_CHANGED layerId=" + getID() + " renderLayerInstanceId=" + std::to_string(renderLayerInstanceId)); const auto settings = particleSettings(baseImpl); auto properties = makeMutable(baseImpl, settings.active, settings.maskMode, settings.fixtureMode, settings.timeMix, settings.particleCount, settings.lineWidth, settings.particleLength, settings.particleOpacity, settings.trailOpacity, settings.trailFade, settings.advectionScale, settings.speedColorEnabled, settings.particleColor, settings.trailColor); passes = RenderPass::Translucent; properties->renderPasses = mbgl::underlying_type(passes); evaluatedProperties = std::move(properties); Log::Info(Event::Render, "ParticleRender: state=" + std::string(settings.active ? "ACTIVE" : "STATIC") + " maskMode=" + std::to_string(settings.maskMode) + " id=" + getID() + " fixture=" + (formalSource && sourceField ? sourceField->fieldID : fixtureID(settings.fixtureMode)) + " layerIndex=" + std::to_string(getLayerIndex()) + " timeMix=" + std::to_string(settings.timeMix) + " particleCount=" + std::to_string(settings.particleCount) + " lineWidth=" + std::to_string(settings.lineWidth) + " streakLength=" + std::to_string(settings.particleLength) + " particleOpacity=" + std::to_string(settings.particleOpacity) + " trailOpacity=" + std::to_string(settings.trailOpacity) + " trailFade=" + std::to_string(settings.trailFade) + " advectionScale=" + std::to_string(settings.advectionScale) + " speedColor=" + (settings.speedColorEnabled ? "true" : "false") + " stage=40-05"); } bool RenderRasterParticleLayer::needsRepaint() const { const auto& properties = static_cast(*evaluatedProperties); if (!properties.active || (formalSource && (!sourceField || !sourceNextField)) || baseImpl->visibility == style::VisibilityType::None) return false; return !formalSource || !sourceTimeline || sourceTimeline->cadenceDue(std::chrono::steady_clock::now()); } bool RenderRasterParticleLayer::needsHiddenLayerSourceCleanup(const RenderSource& renderSource) const { if (!formalSource || !gpuResources || renderSource.baseImpl->type != style::SourceType::RasterArray) return false; const auto& source = static_cast(renderSource); const auto& impl = source.impl(); return impl.hostFieldSubmission && !impl.field && !impl.nextField && !impl.timeline; } void RenderRasterParticleLayer::markLayerRenderable(bool willRender, UniqueChangeRequestVec& changes) { // RenderOrchestrator calls this while visiting each source. In a style with more // than one source, false can therefore be a transient per-source result, not a // durable particle disable. Persistent State/Trail resources are invalidated // only by their real lifecycle events (field, viewport, context, or layer removal). RenderLayer::markLayerRenderable(willRender, changes); } void RenderRasterParticleLayer::layerRemoved(UniqueChangeRequestVec& changes) { if (gpuResources) { Log::Info(Event::Render, "ParticleGPU: event=PARTICLE_RESOURCES_RELEASE reason=LAYER_REMOVED particleCount=" + std::to_string(gpuResources->particleCount) + " resourceGeneration=" + std::to_string(gpuResources->generation)); Log::Info(Event::Render, "ParticleGPU: event=PARTICLE_DRAW_RESOURCES_RELEASE reason=LAYER_REMOVED streakVertexCount=" + std::to_string(gpuResources->particleVertices ? gpuResources->particleVertices->elements() : 0) + " fullParticleDraw=true resourceGeneration=" + std::to_string(gpuResources->generation)); removeTargets(gpuResources->registeredTargets, changes); gpuResources->registeredTargets.clear(); } RenderLayer::layerRemoved(changes); } void RenderRasterParticleLayer::markContextDestroyed() { if (gpuResources) { gpuResources->contextDestroyed = true; Log::Info(Event::Render, "ParticleGPU: event=PARTICLE_RESOURCES_RELEASE reason=CONTEXT_DESTROYED particleCount=" + std::to_string(gpuResources->particleCount) + " resourceGeneration=" + std::to_string(gpuResources->generation)); Log::Info(Event::Render, "ParticleGPU: event=PARTICLE_DRAW_RESOURCES_RELEASE reason=CONTEXT_DESTROYED streakVertexCount=" + std::to_string(gpuResources->particleVertices ? gpuResources->particleVertices->elements() : 0) + " fullParticleDraw=true resourceGeneration=" + std::to_string(gpuResources->generation)); Log::Info( Event::Render, "ParticleValidation30_02: context lost discard generation=" + std::to_string(gpuResources->generation) + " stateRead=" + slotName(gpuResources->stateRead) + " trailRead=" + slotName(gpuResources->trailRead)); } } void RenderRasterParticleLayer::prepare(const LayerPrepareParameters& parameters) { if (!formalSource || !parameters.source || parameters.source->baseImpl->type != style::SourceType::RasterArray) { return; } const auto& source = static_cast(*parameters.source); sourceUsesV4Projection = false; sourceProjectionMix = 0.0f; if (source.impl().v4RendererState.particle) { const auto& projection = *source.impl().v4RendererState.particle; sourceField = projection.t0; sourceNextField = projection.t1; sourceProjectionMix = projection.sampleState.mix; sourceTimeline.reset(); sourceUsesV4Projection = true; return; } sourceTimeline = source.impl().timeline; if (sourceTimeline) { const auto frame = sourceTimeline->frame(); sourceField = *frame.t0; sourceNextField = *frame.t1; sourceTimelineWindowRevision = frame.windowRevision; return; } sourceField.reset(); sourceNextField.reset(); if (source.impl().field) { sourceField = *source.impl().field; sourceNextField = source.impl().nextField ? *source.impl().nextField : *source.impl().field; } } void RenderRasterParticleLayer::update(gfx::ShaderRegistry& shaders, gfx::Context& context, const TransformState& transformState, const std::shared_ptr&, const RenderTree&, UniqueChangeRequestVec& changes) { if (!layerGroup) { if (auto group = context.createLayerGroup(layerIndex, 1, getID())) { setLayerGroup(std::move(group), changes); } } if (formalSource && (!sourceField || !sourceNextField)) { if (layerGroup) static_cast(*layerGroup).clearDrawables(); if (gpuResources) { Log::Info(Event::Render, "WeatherRuntime: event=PARTICLE_RESOURCE_RELEASE reason=FIELD_WINDOW_CLEAR layerId=" + getID()); Log::Info(Event::Render, "WeatherRuntime: event=TRAIL_RESOURCE_RELEASE reason=FIELD_WINDOW_CLEAR layerId=" + getID()); removeTargets(gpuResources->registeredTargets, changes); gpuResources->registeredTargets.clear(); // Targets contain tweakers retaining Resources; break that cycle. for (const auto& target : gpuResources->stateTargets) if (target && target->getLayerGroup(0)) target->getLayerGroup(0)->clearDrawables(); for (const auto& target : gpuResources->trailTargets) if (target && target->getLayerGroup(0)) target->getLayerGroup(0)->clearDrawables(); gpuResources.reset(); } return; } // Particle advection requires a compatible vector pair. Scalar-only // remains unavailable; VELOCITY and DIRECTION are resolved in the shader. if (formalSource && (!sourceField->hasVector() || !sourceNextField->hasVector() || !sourceField->vectorSemantics || !sourceNextField->vectorSemantics || sourceField->vectorSemantics != sourceNextField->vectorSemantics)) { if (layerGroup) static_cast(*layerGroup).clearDrawables(); if (gpuResources) { removeTargets(gpuResources->registeredTargets, changes); gpuResources.reset(); } return; } if (!layerGroup || !isLayerRenderable()) return; const auto& properties = static_cast(*evaluatedProperties); const bool active = properties.active; const uint8_t maskMode = properties.maskMode; const uint8_t fixtureMode = properties.fixtureMode; const uint32_t particleCount = properties.particleCount; const float advectionScale = properties.advectionScale; float timelineMix = sourceUsesV4Projection ? sourceProjectionMix : properties.timeMix; bool cadenceAdvanced = true; uint64_t cadenceRevision = sourceTimelineCadenceRevision; if (formalSource && sourceTimeline) { const auto advance = sourceTimeline->advanceIfDue(std::chrono::steady_clock::now()); const auto& frame = advance.frame; timelineMix = frame.mix; cadenceRevision = frame.cadenceRevision; cadenceAdvanced = frame.cadenceRevision != sourceTimelineCadenceRevision; if (frame.windowRevision != sourceTimelineWindowRevision) { sourceField = *frame.t0; sourceNextField = *frame.t1; sourceTimelineWindowRevision = frame.windowRevision; } } auto resources = gpuResources; if (resources && resources->contextDestroyed) { // VALIDATION ONLY: follow the 30-02 resource-generation rule. No stale // State, Trail, or Mask texture survives a notified context loss. gpuResources.reset(); resources.reset(); } if (!resources) { auto owned = std::make_shared(); owned->renderLayerInstanceId = renderLayerInstanceId; owned->generation = ++nextGpuGeneration; owned->formalDisplay = formalSource; owned->shader = context.getGenericShader(shaders, ShaderName); owned->vertices = std::make_shared>( RenderStaticData::heatmapTextureVertices()); owned->segments = RenderStaticData::heatmapTextureSegments(); owned->particleCount = particleCount; owned->stateSize = particleStateSize(owned->particleCount); rebuildParticleDrawResources(owned); for (uint8_t i = 0; i < 2; ++i) { owned->stateTargets[i] = createValidationTarget(context, owned->stateSize, getID() + "-state-" + slotName(i), gfx::TextureFilterType::Nearest, gfx::TextureChannelDataType::Float, "STATE"); } if (!owned->shader || !owned->stateTargets[0] || !owned->stateTargets[1]) { Log::Error( Event::Render, "ParticleStateTarget: event=CREATE_FAILED kind=STATE dataType=Float reason=FRAMEBUFFER_UNAVAILABLE"); return; } owned->maskFixture = makeCoastalMaskFixture(); owned->maskTexture = context.createTexture2D(); if (!owned->maskFixture || !owned->maskTexture) { Log::Error(Event::Render, "ParticleValidation30_03: mask fixture/resource creation failed"); return; } owned->maskTexture->setImage(owned->maskFixture); owned->maskTexture->setSamplerConfiguration({.filter = gfx::TextureFilterType::Nearest, .wrapU = gfx::TextureWrapType::Clamp, .wrapV = gfx::TextureWrapType::Clamp}); owned->maskGeneration = ++nextMaskGeneration; try { if (formalSource) { if (!sourceField || !sourceNextField) { Log::Error(Event::Render, "ParticleField: raster-array source has no loaded time window"); return; } owned->field = *sourceField; owned->nextField = *sourceNextField; owned->fieldGeneration = owned->field.generation; owned->nextFieldGeneration = owned->nextField.generation; } else { owned->fieldGeneration = ++nextFieldGeneration; owned->field = particle::OfflineFixtureParticleAdapter::load(fixtureID(fixtureMode), owned->fieldGeneration); owned->nextField = owned->field; owned->nextFieldGeneration = owned->fieldGeneration; } owned->fieldImage = makeVelocityFieldImage(owned->field); owned->fieldTexture = context.createTexture2D(); owned->nextFieldImage = makeVelocityFieldImage(owned->nextField); owned->nextFieldTexture = context.createTexture2D(); if (!owned->fieldImage || !owned->fieldTexture || !owned->nextFieldImage || !owned->nextFieldTexture) { Log::Error(Event::Render, "ParticleGPU: field resource creation failed"); return; } owned->fieldTexture->setImage(owned->fieldImage); Log::Info(Event::Render, "ParticleGPU: event=FIELD_UPLOAD slot=T0 reason=RESOURCE_CREATE fieldUploadCount=1 " "sourceGeneration=" + std::to_string(owned->field.generation) + " renderLayerInstanceId=" + std::to_string(owned->renderLayerInstanceId) + " resourceGeneration=" + std::to_string(owned->generation)); owned->fieldTexture->setSamplerConfiguration({.filter = gfx::TextureFilterType::Nearest, .wrapU = gfx::TextureWrapType::Clamp, .wrapV = gfx::TextureWrapType::Clamp}); owned->nextFieldTexture->setImage(owned->nextFieldImage); Log::Info(Event::Render, "ParticleGPU: event=FIELD_UPLOAD slot=T1 reason=RESOURCE_CREATE fieldUploadCount=2 " "sourceGeneration=" + std::to_string(owned->nextField.generation) + " renderLayerInstanceId=" + std::to_string(owned->renderLayerInstanceId) + " resourceGeneration=" + std::to_string(owned->generation)); owned->nextFieldTexture->setSamplerConfiguration({.filter = gfx::TextureFilterType::Nearest, .wrapU = gfx::TextureWrapType::Clamp, .wrapV = gfx::TextureWrapType::Clamp}); owned->gpuFieldGeneration = owned->fieldGeneration; owned->gpuNextFieldGeneration = owned->nextFieldGeneration; owned->fieldUploadCount = 2; owned->fieldScale = fieldVelocityScale(owned->field); owned->nextFieldScale = fieldVelocityScale(owned->nextField); owned->fixtureMode = fixtureMode; } catch (const std::exception& error) { Log::Error(Event::Render, "ParticleField: fixture load failed: " + std::string(error.what())); return; } gpuResources = std::move(owned); resources = gpuResources; Log::Info(Event::Render, "ParticleValidation30_02: State A/B create generation=" + std::to_string(resources->generation) + " size=" + std::to_string(resources->stateSize.width) + "x" + std::to_string(resources->stateSize.height) + " independent=true"); Log::Info(Event::Render, "ParticleGPU: event=PARTICLE_RESOURCES_CREATE reason=RESOURCE_CREATE requestedParticleCount=" + std::to_string(particleCount) + " effectiveParticleCount=" + std::to_string(resources->particleCount) + " stateGrid=" + std::to_string(resources->stateSize.width) + "x" + std::to_string(resources->stateSize.height) + " resourceGeneration=" + std::to_string(resources->generation)); Log::Info(Event::Render, "ParticleGPU: event=PARTICLE_DRAW_RESOURCES_CREATE effectiveParticleCount=" + std::to_string(resources->particleCount) + " stateGrid=" + std::to_string(resources->stateSize.width) + "x" + std::to_string(resources->stateSize.height) + " particleDrawCount=" + std::to_string(resources->particleCount) + " streakVertexCount=" + std::to_string(resources->particleVertices->elements()) + " fullParticleDraw=true resourceGeneration=" + std::to_string(resources->generation)); Log::Info(Event::Render, "ParticleField: field loaded id=" + resources->field.fieldID + " type=" + resources->field.fieldType + " bounds=[" + std::to_string(resources->field.west) + ',' + std::to_string(resources->field.east) + "]x[" + std::to_string(resources->field.south) + ',' + std::to_string(resources->field.north) + "] grid=" + std::to_string(resources->field.width) + 'x' + std::to_string(resources->field.height) + " dataVersion=" + std::to_string(resources->field.dataVersion) + " fieldGeneration=" + std::to_string(resources->fieldGeneration)); Log::Info(Event::Render, "ParticleField: field validated id=" + resources->field.fieldID + " noData=" + std::to_string(resources->field.noData) + " vectorCount=" + std::to_string(resources->field.vector.size())); Log::Info(Event::Render, "ParticleField: created id=" + resources->field.fieldID + " generation=" + std::to_string(resources->fieldGeneration)); Log::Info(Event::Render, "ParticleGPU: field upload reason=RESOURCE_RECREATE field=" + resources->field.fieldID + " fieldGeneration=" + std::to_string(resources->fieldGeneration) + " gpuFieldGeneration=" + std::to_string(resources->gpuFieldGeneration) + " resourceGeneration=" + std::to_string(resources->generation)); Log::Info(Event::Render, "ParticleGPU: time window T0=" + resources->field.fieldID + "@" + std::to_string(resources->field.dataVersion) + " T1=" + resources->nextField.fieldID + "@" + std::to_string(resources->nextField.dataVersion) + " uploads=" + std::to_string(resources->fieldUploadCount)); Log::Info( Event::Render, "ParticleValidation30_03: mask fixture ready id=coastal-mask-validation-v1 bounds=[-180,180]x[-85,85] " "encoding=uint8-land-ocean land=0 ocean=255 maskGeneration=" + std::to_string(resources->maskGeneration)); Log::Info(Event::Render, "ParticleValidation30_03: anchors A=0,0 B=0,-90 C=0,-172.8 D=0,172.8 canonical=Mercator-z0"); } // This is a renderer uniform only. It intentionally preserves State, // Trail, Timeline, and uploaded field textures when changed. resources->advectionScale = advectionScale; if (resources->particleCount != particleCount) { const auto previousCount = resources->particleCount; const auto previousSize = resources->stateSize; const auto requestedSize = particleStateSize(particleCount); std::array replacementTargets; for (uint8_t i = 0; i < 2; ++i) { replacementTargets[i] = createValidationTarget(context, requestedSize, getID() + "-state-" + slotName(i), gfx::TextureFilterType::Nearest, gfx::TextureChannelDataType::Float, "STATE"); } if (!replacementTargets[0] || !replacementTargets[1]) { Log::Error(Event::Render, "ParticleGPU: event=PARTICLE_COUNT_REJECTED reason=STATE_RESOURCE_CREATE_FAILED dataType=Float " "requestedParticleCount=" + std::to_string(particleCount) + " effectiveParticleCount=" + std::to_string(resources->particleCount) + " resourceGeneration=" + std::to_string(resources->generation)); return; } Log::Info(Event::Render, "ParticleGPU: event=PARTICLE_RESOURCES_RELEASE reason=PARTICLE_COUNT_CHANGE particleCount=" + std::to_string(previousCount) + " stateGrid=" + std::to_string(previousSize.width) + "x" + std::to_string(previousSize.height) + " resourceGeneration=" + std::to_string(resources->generation)); Log::Info(Event::Render, "ParticleGPU: event=PARTICLE_DRAW_RESOURCES_RELEASE reason=PARTICLE_COUNT_CHANGE streakVertexCount=" + std::to_string(resources->particleVertices ? resources->particleVertices->elements() : 0) + " fullParticleDraw=true resourceGeneration=" + std::to_string(resources->generation)); removeTargets(resources->stateTargets, changes); resources->stateTargets = std::move(replacementTargets); resources->particleCount = particleCount; resources->stateSize = requestedSize; rebuildParticleDrawResources(resources); resources->resetSequence("PARTICLE_COUNT_CHANGE"); Log::Info(Event::Render, "ParticleGPU: event=PARTICLE_RESOURCES_REBUILD reason=PARTICLE_COUNT_CHANGE requestedParticleCount=" + std::to_string(particleCount) + " effectiveParticleCount=" + std::to_string(resources->particleCount) + " stateGrid=" + std::to_string(resources->stateSize.width) + "x" + std::to_string(resources->stateSize.height) + " resourceGeneration=" + std::to_string(resources->generation)); Log::Info(Event::Render, "ParticleGPU: event=PARTICLE_DRAW_RESOURCES_REBUILD effectiveParticleCount=" + std::to_string(resources->particleCount) + " stateGrid=" + std::to_string(resources->stateSize.width) + "x" + std::to_string(resources->stateSize.height) + " particleDrawCount=" + std::to_string(resources->particleCount) + " streakVertexCount=" + std::to_string(resources->particleVertices->elements()) + " fullParticleDraw=true resourceGeneration=" + std::to_string(resources->generation)); } const bool sourceChanged = formalSource && sourceField && sourceNextField && (particle::fieldIdentityChanged(resources->field, *sourceField) || particle::fieldIdentityChanged(resources->nextField, *sourceNextField)); if ((!formalSource && resources->fixtureMode != fixtureMode) || sourceChanged) { try { const auto oldT0 = resources->field; const auto oldT1 = resources->nextField; auto nextT0 = formalSource ? *sourceField : particle::OfflineFixtureParticleAdapter::load(fixtureID(fixtureMode), ++nextFieldGeneration); auto nextT1 = formalSource ? *sourceNextField : nextT0; if (!nextT0.isTimeInterpolationCompatibleWith(nextT1)) { Log::Error(Event::Render, "ParticleGPU: rejected incompatible time-window fields"); return; } const bool reuseOldT0 = particle::sameFieldGpuContent(oldT0, nextT0); const bool reuseOldT1 = particle::sameFieldGpuContent(oldT1, nextT0); const bool reuseNewT0 = particle::sameFieldGpuContent(oldT0, nextT1); const bool reuseNewT1 = particle::sameFieldGpuContent(oldT1, nextT1); const bool windowOverlap = reuseOldT0 || reuseOldT1 || reuseNewT0 || reuseNewT1; const auto upload = [&](const particle::ParticleFieldSnapshot& field, std::shared_ptr& image, gfx::Texture2DPtr& texture, float& scale) { image = makeVelocityFieldImage(field); texture = context.createTexture2D(); if (!image || !texture) return false; texture->setImage(image); texture->setSamplerConfiguration({.filter = gfx::TextureFilterType::Nearest, .wrapU = gfx::TextureWrapType::Clamp, .wrapV = gfx::TextureWrapType::Clamp}); scale = fieldVelocityScale(field); ++resources->fieldUploadCount; Log::Info(Event::Render, "ParticleGPU: event=FIELD_UPLOAD reason=NEW_CONTENT fieldUploadCount=" + std::to_string(resources->fieldUploadCount) + " sourceGeneration=" + std::to_string(field.generation) + " renderLayerInstanceId=" + std::to_string(resources->renderLayerInstanceId) + " resourceGeneration=" + std::to_string(resources->generation)); return true; }; auto takeSlot = [&](const particle::ParticleFieldSnapshot& wanted, const char* destination, particle::ParticleFieldSnapshot& assigned, std::shared_ptr& image, gfx::Texture2DPtr& texture, float& scale) { if (particle::sameFieldGpuContent(oldT0, wanted)) { assigned = wanted; image = resources->fieldImage; texture = resources->fieldTexture; scale = resources->fieldScale; Log::Info(Event::Render, "ParticleGPU: event=FIELD_REUSE from=OLD_T0 to=" + std::string(destination) + " oldGeneration=" + std::to_string(oldT0.generation) + " newGeneration=" + std::to_string(wanted.generation) + " renderLayerInstanceId=" + std::to_string(resources->renderLayerInstanceId) + " resourceGeneration=" + std::to_string(resources->generation)); return true; } if (particle::sameFieldGpuContent(oldT1, wanted)) { assigned = wanted; image = resources->nextFieldImage; texture = resources->nextFieldTexture; scale = resources->nextFieldScale; Log::Info(Event::Render, "ParticleGPU: event=FIELD_REUSE from=OLD_T1 to=" + std::string(destination) + " oldGeneration=" + std::to_string(oldT1.generation) + " newGeneration=" + std::to_string(wanted.generation) + " renderLayerInstanceId=" + std::to_string(resources->renderLayerInstanceId) + " resourceGeneration=" + std::to_string(resources->generation)); return true; } assigned = wanted; return upload(assigned, image, texture, scale); }; particle::ParticleFieldSnapshot assignedT0; particle::ParticleFieldSnapshot assignedT1; std::shared_ptr imageT0; std::shared_ptr imageT1; gfx::Texture2DPtr textureT0; gfx::Texture2DPtr textureT1; float scaleT0 = 1.0f; float scaleT1 = 1.0f; if (!takeSlot(nextT0, "NEW_T0", assignedT0, imageT0, textureT0, scaleT0) || !takeSlot(nextT1, "NEW_T1", assignedT1, imageT1, textureT1, scaleT1)) { Log::Error(Event::Render, "ParticleGPU: field switch resource creation failed"); return; } resources->field = std::move(assignedT0); resources->nextField = std::move(assignedT1); resources->fieldImage = std::move(imageT0); resources->nextFieldImage = std::move(imageT1); resources->fieldTexture = std::move(textureT0); resources->nextFieldTexture = std::move(textureT1); resources->fieldScale = scaleT0; resources->nextFieldScale = scaleT1; resources->fieldGeneration = resources->field.generation; resources->nextFieldGeneration = resources->nextField.generation; resources->gpuFieldGeneration = resources->fieldGeneration; resources->gpuNextFieldGeneration = resources->nextFieldGeneration; resources->fixtureMode = fixtureMode; if (!windowOverlap) resources->resetSequence("FIELD_NO_OVERLAP"); Log::Info(Event::Render, "ParticleGPU: time window advance T0=" + oldT0.fieldID + " T1=" + oldT1.fieldID + " -> T0=" + resources->field.fieldID + " T1=" + resources->nextField.fieldID + " reuse=" + (windowOverlap ? "true" : "false") + " uploads=" + std::to_string(resources->fieldUploadCount) + " simulationRebuild=" + (windowOverlap ? "false" : "true") + " trailCleared=" + (windowOverlap ? "false" : "true")); } catch (const std::exception& error) { Log::Error(Event::Render, "ParticleField: fixture switch failed: " + std::string(error.what())); return; } } // Keep the shared Core runtime alive in the per-frame drawable tweaker. // This is a pointer to Source-owned state, not a second timeline. resources->timeline = sourceTimeline; const auto requestedTimeMix = std::clamp(timelineMix, 0.0f, 1.0f); if (resources->timeMix != requestedTimeMix) { resources->timeMix = requestedTimeMix; if (!sourceTimeline || std::abs(resources->timeMix * 4.0f - std::round(resources->timeMix * 4.0f)) < 0.01f) { Log::Info(Event::Render, "ParticleGPU: event=TIME_MIX_UPDATE value=" + std::to_string(resources->timeMix) + " T0=" + resources->field.fieldID + " T1=" + resources->nextField.fieldID + " renderLayerInstanceId=" + std::to_string(resources->renderLayerInstanceId) + " resourceGeneration=" + std::to_string(resources->generation) + " fieldUploadCount=" + std::to_string(resources->fieldUploadCount) + " resetCount=" + std::to_string(resources->resetCount)); } } const bool visualChanged = resources->lineWidth != properties.lineWidth || resources->particleLength != properties.particleLength || resources->particleOpacity != properties.particleOpacity || resources->trailOpacity != properties.trailOpacity || resources->trailFade != properties.trailFade || resources->speedColorEnabled != properties.speedColorEnabled || resources->particleColor != properties.particleColor || resources->trailColor != properties.trailColor; if (visualChanged) { resources->lineWidth = properties.lineWidth; resources->particleLength = properties.particleLength; resources->particleOpacity = properties.particleOpacity; resources->trailOpacity = properties.trailOpacity; resources->trailFade = properties.trailFade; resources->speedColorEnabled = properties.speedColorEnabled; resources->particleColor = properties.particleColor; resources->trailColor = properties.trailColor; Log::Info(Event::Render, "ParticleGPU: event=VISUAL_PROPERTY_APPLIED lineWidth=" + std::to_string(resources->lineWidth) + " streakLength=" + std::to_string(resources->particleLength) + " particleOpacity=" + std::to_string(resources->particleOpacity) + " trailOpacity=" + std::to_string(resources->trailOpacity) + " trailFade=" + std::to_string(resources->trailFade) + " speedColor=" + (resources->speedColorEnabled ? "true" : "false") + " renderLayerInstanceId=" + std::to_string(resources->renderLayerInstanceId) + " resourceGeneration=" + std::to_string(resources->generation) + " fieldUploadCount=" + std::to_string(resources->fieldUploadCount) + " resetCount=" + std::to_string(resources->resetCount)); } if (!resources->lifecycleModeKnown || resources->lifecycleActive != active) { Log::Info(Event::Render, "ParticleRender: lifecycle transition=" + std::string(active ? "ACTIVE" : "STATIC") + " resourceGeneration=" + std::to_string(resources->generation) + " fixture=" + resources->field.fieldID + " simulationFrame=" + std::to_string(resources->committedFrame) + " stateRead=" + slotName(resources->stateRead) + " trailRead=" + slotName(resources->trailRead)); resources->lifecycleModeKnown = true; resources->lifecycleActive = active; } if (resources->loggedMaskMode != maskMode) { Log::Info(Event::Render, "ParticleValidation30_03: mask mode=" + std::to_string(maskMode) + " consumer=" + (maskMode == 0 ? std::string("GLOBAL") : (maskMode == 1 ? "OCEAN_ONLY_A" : "OCEAN_ONLY_B")) + " maskGeneration=" + std::to_string(resources->maskGeneration) + " reuse=true"); resources->loggedMaskMode = maskMode; } removeTargets(resources->registeredTargets, changes); resources->registeredTargets.clear(); const auto viewport = validViewportSize(transformState.getSize()); const auto trailCamera = transformState.getLatLng(LatLng::Unwrapped); const auto cameraNow = std::chrono::steady_clock::now(); const bool viewportChanged = resources->formalDisplay && resources->trailTargets[0] && resources->trailTargets[1] && resources->trailSize != viewport; const bool transformChanged = resources->formalDisplay && resources->trailCameraKnown && (std::abs(resources->trailCameraLatitude - trailCamera.latitude()) > 0.00001 || std::abs(resources->trailCameraLongitude - trailCamera.longitude()) > 0.00001 || std::abs(resources->trailCameraZoom - transformState.getZoom()) > 0.0001 || std::abs(resources->trailCameraBearing - transformState.getBearing()) > 0.0001 || std::abs(resources->trailCameraPitch - transformState.getPitch()) > 0.0001); if (viewportChanged) { const auto previousSize = resources->trailSize; resources->trailTargets = {}; resources->trailSize = {}; resources->trailRead = 0; resources->trailSeeded = false; resources->trailCameraInvalidated = true; resources->viewportDensityLogged = false; resources->lastTrailCameraChange = cameraNow; Log::Info(Event::Render, "ParticleTrail: event=VIEWPORT_RESIZE old=" + std::to_string(previousSize.width) + "x" + std::to_string(previousSize.height) + " new=" + std::to_string(viewport.width) + "x" + std::to_string(viewport.height) + " statePreserved=true fieldResubmit=false timelineReset=false"); } else if (transformChanged) { if (!resources->trailCameraInvalidated) { const auto reason = std::abs(resources->trailCameraZoom - transformState.getZoom()) > 0.0001 ? "zoom" : std::abs(resources->trailCameraBearing - transformState.getBearing()) > 0.0001 ? "rotate" : std::abs(resources->trailCameraPitch - transformState.getPitch()) > 0.0001 ? "pitch" : "pan"; resources->trailCameraInvalidated = true; resources->trailSeeded = false; resources->viewportDensityLogged = false; Log::Info(Event::Render, "ParticleTrail: event=CAMERA_INVALIDATE reason=" + std::string(reason) + " statePreserved=true fieldResubmit=false timelineReset=false"); } resources->lastTrailCameraChange = cameraNow; } else if (resources->trailCameraInvalidated && cameraNow - resources->lastTrailCameraChange >= TrailCameraStableDelay) { resources->trailCameraInvalidated = false; Log::Info( Event::Render, "ParticleTrail: event=CAMERA_STABLE_RESUME statePreserved=true fieldResubmit=false timelineReset=false"); } resources->trailCameraKnown = true; resources->trailCameraLatitude = trailCamera.latitude(); resources->trailCameraLongitude = trailCamera.longitude(); resources->trailCameraZoom = transformState.getZoom(); resources->trailCameraBearing = transformState.getBearing(); resources->trailCameraPitch = transformState.getPitch(); const auto respawnDomain = viewportRespawnDomain(transformState, viewport, resources->field); resources->viewportDensityActive = resources->formalDisplay && !resources->trailCameraInvalidated && !respawnDomain.fallback; // During a camera gesture, State continues normally but all ordinary // lifecycle respawns stay in the full Field. The viewport domain is only // enabled after the existing stable-camera debounce has completed. resources->respawnBounds = resources->viewportDensityActive ? respawnDomain.bounds : fieldBounds(resources->field); if (resources->formalDisplay && !resources->trailCameraInvalidated && !resources->viewportDensityLogged) { const auto& bounds = resources->respawnBounds; const auto& currentFieldBounds = fieldBounds(resources->field); Log::Info(Event::Render, "ParticleDensity: zoom=" + std::to_string(transformState.getZoom()) + " mode=" + std::string(respawnDomain.fallback ? "FIELD_FALLBACK" : "VIEWPORT_RESPAWN") + " cameraStable=true margin=" + std::to_string(ViewportRespawnMargin) + " respawnBounds=[" + std::to_string(bounds[0]) + "," + std::to_string(bounds[1]) + "," + std::to_string(bounds[2]) + "," + std::to_string(bounds[3]) + "] fieldBounds=[" + std::to_string(currentFieldBounds[0]) + "," + std::to_string(currentFieldBounds[1]) + "," + std::to_string(currentFieldBounds[2]) + "," + std::to_string(currentFieldBounds[3]) + "] fallback=" + (respawnDomain.fallback ? "true" : "false") + " configuredSlots=" + std::to_string(resources->particleCount)); resources->viewportDensityLogged = true; } const auto ensureTrailTargets = [&] { if (resources->trailTargets[0] && resources->trailTargets[1] && resources->trailSize == viewport) { return true; } const auto previousSize = resources->trailSize; resources->trailTargets = {}; for (uint8_t i = 0; i < 2; ++i) { resources->trailTargets[i] = createValidationTarget(context, viewport, getID() + "-trail-" + slotName(i), gfx::TextureFilterType::Linear, gfx::TextureChannelDataType::UnsignedByte, "TRAIL"); } if (!resources->trailTargets[0] || !resources->trailTargets[1]) { Log::Error(Event::Render, "ParticleGPU: Trail resource creation failed"); return false; } resources->trailSize = viewport; resources->trailRead = 0; resources->trailSeeded = false; Log::Info( Event::Render, "ParticleStateTarget: stateAType=Float stateBType=Float trailAType=UnsignedByte trailBType=UnsignedByte " "stateGrid=" + std::to_string(resources->stateSize.width) + "x" + std::to_string(resources->stateSize.height) + " trailSize=" + std::to_string(viewport.width) + "x" + std::to_string(viewport.height) + " resourceGeneration=" + std::to_string(resources->generation)); Log::Info(Event::Render, "ParticleGPU: Trail A/B " + std::string(previousSize.isEmpty() ? "create" : "resize") + " resourceGeneration=" + std::to_string(resources->generation) + " old=" + std::to_string(previousSize.width) + "x" + std::to_string(previousSize.height) + " new=" + std::to_string(viewport.width) + "x" + std::to_string(viewport.height) + " StatePreserved=true"); return true; }; if (!active) { // STATIC freezes simulation only. A recreated activity still needs the // resource bootstrap and first current-frame composite without a button tap. if (!ensureTrailTargets()) { static_cast(*layerGroup).clearDrawables(); return; } resources->pending = false; auto& compositeGroup = static_cast(*layerGroup); if (!resources->stateSeeded || !resources->trailSeeded) { const auto stateWrite = resources->stateWrite(); const auto trailWrite = resources->trailWrite(); auto& stateGroup = static_cast(*resources->stateTargets[stateWrite]->getLayerGroup(0)); auto& trailGroup = static_cast(*resources->trailTargets[trailWrite]->getLayerGroup(0)); const bool stateBuilt = buildQuad(context, resources, stateGroup, getID() + "-static-bootstrap-state-pass", resources->stateTargets[resources->stateRead]->getTexture(), resources->stateTargets[stateWrite]->getTexture(), resources->maskTexture, {}, 0.0f, ValidationPass::State, resources->stateRead, stateWrite, 0, maskMode, true); const bool trailBuilt = buildQuad(context, resources, trailGroup, getID() + "-static-bootstrap-trail-pass", resources->trailTargets[resources->trailRead]->getTexture(), resources->trailTargets[trailWrite]->getTexture(), resources->maskTexture, resources->stateTargets[stateWrite]->getTexture(), 0.0f, ValidationPass::Trail, resources->trailRead, trailWrite, 0, maskMode, true); const bool particlesBuilt = !resources->formalDisplay || resources->trailCameraInvalidated || buildParticlePoints(context, resources, trailGroup, getID() + "-static-bootstrap-trail-particles", resources->stateTargets[resources->stateRead]->getTexture(), resources->stateTargets[stateWrite]->getTexture(), resources->trailTargets[trailWrite]->getTexture(), stateWrite, trailWrite); #if MLN_RENDER_BACKEND_METAL const bool endpointCoverageBuilt = !resources->formalDisplay || resources->trailCameraInvalidated || buildParticleEndpointCoverage( context, resources, trailGroup, getID() + "-static-bootstrap-trail-particle-endpoints", resources->stateTargets[resources->stateRead]->getTexture(), resources->stateTargets[stateWrite]->getTexture(), resources->trailTargets[trailWrite]->getTexture(), stateWrite, trailWrite); #else const bool endpointCoverageBuilt = true; #endif compositeGroup.clearDrawables(); bool compositeBuilt = true; const auto center = transformState.getLatLng(LatLng::Unwrapped); const auto centerWrap = wrapForLongitude(center.longitude()); const auto firstWrap = resources->formalDisplay ? int16_t{0} : static_cast(centerWrap - 1); const auto lastWrap = resources->formalDisplay ? int16_t{0} : static_cast(centerWrap + 1); for (int16_t wrap = firstWrap; wrap <= lastWrap; ++wrap) { compositeBuilt = buildQuad(context, resources, compositeGroup, getID() + "-static-bootstrap-composite-pass-" + std::to_string(wrap), resources->trailTargets[trailWrite]->getTexture(), {}, resources->maskTexture, {}, 0.0f, ValidationPass::Composite, resources->trailRead, trailWrite, wrap, maskMode, false) && compositeBuilt; } if (!stateBuilt || !trailBuilt || !particlesBuilt || !endpointCoverageBuilt || !compositeBuilt) { compositeGroup.clearDrawables(); return; } resources->registeredTargets.emplace_back(resources->stateTargets[resources->stateRead]); resources->registeredTargets.emplace_back(resources->stateTargets[stateWrite]); resources->registeredTargets.emplace_back(resources->trailTargets[resources->trailRead]); resources->registeredTargets.emplace_back(resources->trailTargets[trailWrite]); for (const auto& target : resources->registeredTargets) { changes.emplace_back(std::make_unique(target)); } resources->bootstrapPending = true; resources->pending = true; Log::Info(Event::Render, "ParticleRender: STATIC bootstrap scheduled resourceGeneration=" + std::to_string(resources->generation) + " field=" + resources->field.fieldID + " simulationFrame=" + std::to_string(resources->committedFrame)); return; } if (resources->trailTargets[resources->trailRead]) { compositeGroup.clearDrawables(); const auto center = transformState.getLatLng(LatLng::Unwrapped); const auto centerWrap = wrapForLongitude(center.longitude()); const auto firstWrap = resources->formalDisplay ? int16_t{0} : static_cast(centerWrap - 1); const auto lastWrap = resources->formalDisplay ? int16_t{0} : static_cast(centerWrap + 1); for (int16_t wrap = firstWrap; wrap <= lastWrap; ++wrap) { buildQuad(context, resources, compositeGroup, getID() + "-frozen-composite-pass-" + std::to_string(wrap), resources->trailTargets[resources->trailRead]->getTexture(), {}, resources->maskTexture, {}, 0.0f, ValidationPass::FrozenComposite, resources->trailRead, resources->trailRead, wrap, maskMode, false); } } else { compositeGroup.clearDrawables(); } return; } resources->staticFreezeLogged = false; if (!ensureTrailTargets()) { return; } // Camera-driven frames may recompose existing weather drawables, but do // not advance the shared timeline, State, or Trail before the deadline. if (formalSource && sourceTimeline && !cadenceAdvanced) { auto& compositeGroup = static_cast(*layerGroup); compositeGroup.clearDrawables(); const auto center = transformState.getLatLng(LatLng::Unwrapped); const auto centerWrap = wrapForLongitude(center.longitude()); const auto wrap = static_cast(centerWrap); buildQuad(context, resources, compositeGroup, getID() + "-composite-pass-" + std::to_string(wrap), resources->trailTargets[resources->trailRead]->getTexture(), {}, resources->maskTexture, {}, 0.0f, ValidationPass::Composite, resources->trailRead, resources->trailRead, wrap, maskMode, false); return; } const auto stateWrite = resources->stateWrite(); const auto trailWrite = resources->trailWrite(); auto& stateGroup = static_cast(*resources->stateTargets[stateWrite]->getLayerGroup(0)); auto& trailGroup = static_cast(*resources->trailTargets[trailWrite]->getLayerGroup(0)); auto& compositeGroup = static_cast(*layerGroup); const auto now = std::chrono::steady_clock::now(); float wallDeltaSeconds = 1.0f / 60.0f; if (resources->lastSimulationTick.time_since_epoch().count() != 0) { wallDeltaSeconds = std::chrono::duration(now - resources->lastSimulationTick).count(); } resources->lastSimulationTick = now; const float trailWallDeltaSeconds = std::clamp(wallDeltaSeconds, 0.0f, 0.250f); const float zoom = static_cast(transformState.getZoom()); const float effectiveVisualSpeedScale = std::clamp( VisualSimulationSecondsPerRealSecond * std::exp2(VisualSimulationReferenceZoom - zoom), MinVisualSimulationSecondsPerRealSecond, MaxVisualSimulationSecondsPerRealSecond); const float visualSimulationDeltaSeconds = std::min( std::clamp(wallDeltaSeconds, 1.0f / 240.0f, 0.050f) * effectiveVisualSpeedScale, MaxSimulationDeltaSeconds); const bool stateBuilt = buildQuad(context, resources, stateGroup, getID() + "-state-pass", resources->stateTargets[resources->stateRead]->getTexture(), resources->stateTargets[stateWrite]->getTexture(), resources->maskTexture, {}, visualSimulationDeltaSeconds, ValidationPass::State, resources->stateRead, stateWrite, 0, maskMode, true, trailWallDeltaSeconds, effectiveVisualSpeedScale); const bool trailBuilt = buildQuad(context, resources, trailGroup, getID() + "-trail-pass", resources->trailTargets[resources->trailRead]->getTexture(), resources->trailTargets[trailWrite]->getTexture(), resources->maskTexture, resources->stateTargets[stateWrite]->getTexture(), trailWallDeltaSeconds, ValidationPass::Trail, resources->trailRead, trailWrite, 0, maskMode, true, trailWallDeltaSeconds, effectiveVisualSpeedScale); const bool particlesBuilt = !resources->formalDisplay || resources->trailCameraInvalidated || buildParticlePoints(context, resources, trailGroup, getID() + "-trail-particles", resources->stateTargets[resources->stateRead]->getTexture(), resources->stateTargets[stateWrite]->getTexture(), resources->trailTargets[trailWrite]->getTexture(), stateWrite, trailWrite); #if MLN_RENDER_BACKEND_METAL const bool endpointCoverageBuilt = !resources->formalDisplay || resources->trailCameraInvalidated || buildParticleEndpointCoverage(context, resources, trailGroup, getID() + "-trail-particle-endpoints", resources->stateTargets[resources->stateRead]->getTexture(), resources->stateTargets[stateWrite]->getTexture(), resources->trailTargets[trailWrite]->getTexture(), stateWrite, trailWrite); #else const bool endpointCoverageBuilt = true; #endif compositeGroup.clearDrawables(); bool compositeBuilt = true; const auto center = transformState.getLatLng(LatLng::Unwrapped); const auto centerWrap = wrapForLongitude(center.longitude()); const auto firstWrap = resources->formalDisplay ? int16_t{0} : static_cast(centerWrap - 1); const auto lastWrap = resources->formalDisplay ? int16_t{0} : static_cast(centerWrap + 1); for (int16_t wrap = firstWrap; wrap <= lastWrap; ++wrap) { compositeBuilt = buildQuad(context, resources, compositeGroup, getID() + "-composite-pass-" + std::to_string(wrap), resources->trailTargets[trailWrite]->getTexture(), {}, resources->maskTexture, {}, 0.0f, ValidationPass::Composite, resources->trailRead, trailWrite, wrap, maskMode, false) && compositeBuilt; } if (!stateBuilt || !trailBuilt || !particlesBuilt || !endpointCoverageBuilt || !compositeBuilt) { compositeGroup.clearDrawables(); return; } if (formalSource && sourceTimeline) sourceTimelineCadenceRevision = cadenceRevision; // Read targets are registered only for their one-time clear. Normal frames register // only the opposite write targets, in dependency order, so a sampled texture can // never be attached to the active render pass. if (!resources->stateSeeded) { resources->registeredTargets.emplace_back(resources->stateTargets[resources->stateRead]); } resources->registeredTargets.emplace_back(resources->stateTargets[stateWrite]); if (!resources->trailSeeded) { resources->registeredTargets.emplace_back(resources->trailTargets[resources->trailRead]); } resources->registeredTargets.emplace_back(resources->trailTargets[trailWrite]); for (const auto& target : resources->registeredTargets) { changes.emplace_back(std::make_unique(target)); } resources->pending = true; if (resources->committedFrame < 3 || (resources->committedFrame + 1) % 60 == 0) { Log::Info(Event::Render, "ParticleValidation30_02: schedule generation=" + std::to_string(resources->generation) + " frame=" + std::to_string(resources->committedFrame + 1) + " state=" + slotName(resources->stateRead) + "->" + slotName(stateWrite) + " trail=" + slotName(resources->trailRead) + "->" + slotName(trailWrite) + " trailStateSource=" + slotName(stateWrite) + " compositeTrailSource=" + slotName(trailWrite) + " displayMode=" + (resources->formalDisplay ? "FORMAL_PARTICLE" : "VALIDATION") + " targetsDistinct=true cpuStateCopy=false"); } } } // namespace mbgl