klevze/spacetris
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix particle

Browse Source
This commit is contained in:
Gregor Klevže
2025-11-30 16:48:45 +01:00
parent ace2e6acdc
commit 9d89106275
1 changed files with 96 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files

135
src/main.cpp
View File

@ -523,27 +523,37 @@ static bool helpOverlayPausedGame = false;
static void drawBlockTexture(SDL_Renderer* renderer, SDL_Texture* blocksTex, float x, float y, float size, int blockType); static void drawBlockTexture(SDL_Renderer* renderer, SDL_Texture* blocksTex, float x, float y, float size, int blockType);
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
struct BlockParticle { struct BlockParticle {
float x, y, vx, vy, size, alpha, decay; float x{}, y{};
int blockType; // 0..6 float vx{}, vy{};
float size{}, alpha{}, decay{};
float wobblePhase{}, wobbleSpeed{};
float coreHeat{};
BlockParticle(float sx, float sy) BlockParticle(float sx, float sy)
: x(sx), y(sy) { : x(sx), y(sy) {
float angle = (rand() % 628) / 100.0f; // 0..2pi const float spreadDeg = 35.0f;
float speed = 1.5f + (rand() % 350) / 100.0f; // ~1.5..5.0 const float angleDeg = -90.0f + spreadDeg * ((rand() % 200) / 100.0f - 1.0f); // bias upward
vx = std::cos(angle) * speed; const float angleRad = angleDeg * 3.1415926f / 180.0f;
vy = std::sin(angle) * speed; float speed = 1.3f + (rand() % 220) / 80.0f; // ~1.3..4.05
size = 6.0f + (rand() % 50) / 10.0f; // 6..11 px vx = std::cos(angleRad) * speed * 0.55f;
vy = std::sin(angleRad) * speed;
size = 6.0f + (rand() % 40) / 10.0f; // 6..10 px
alpha = 1.0f; alpha = 1.0f;
decay = 0.012f + (rand() % 200) / 10000.0f; // 0.012..0.032 decay = 0.0095f + (rand() % 180) / 12000.0f; // 0.0095..0.0245
blockType = rand() % 7; // choose a tetris color wobblePhase = (rand() % 628) / 100.0f;
wobbleSpeed = 0.08f + (rand() % 60) / 600.0f;
coreHeat = 0.65f + (rand() % 35) / 100.0f;
} }
bool update() { bool update() {
vx *= 0.985f; // friction vx *= 0.992f;
vy = vy * 0.985f + 0.07f; // gravity vy = vy * 0.985f - 0.015f; // buoyancy pushes upward (negative vy)
x += vx; x += vx;
y += vy; y += vy;
wobblePhase += wobbleSpeed;
x += std::sin(wobblePhase) * 0.12f;
alpha -= decay; alpha -= decay;
size = std::max(2.0f, size - 0.04f); size = std::max(1.8f, size - 0.03f);
return alpha > 0.02f; coreHeat = std::max(0.0f, coreHeat - decay * 0.6f);
return alpha > 0.03f;
} }
}; };
@ -592,36 +602,83 @@ static void updateFireworks(double frameMs) {
} }
// Primary implementation that accepts a texture pointer // Primary implementation that accepts a texture pointer
static void drawFireworks_impl(SDL_Renderer* renderer, SDL_Texture* blocksTexture) { static SDL_Color blendFireColor(float heat, float alphaScale, Uint8 minG, Uint8 minB) {
heat = std::clamp(heat, 0.0f, 1.0f);
Uint8 r = 255;
Uint8 g = static_cast<Uint8>(std::clamp(120.0f + heat * (255.0f - 120.0f), float(minG), 255.0f));
Uint8 b = static_cast<Uint8>(std::clamp(40.0f + (1.0f - heat) * 60.0f, float(minB), 255.0f));
Uint8 a = static_cast<Uint8>(std::clamp(alphaScale * 255.0f, 0.0f, 255.0f));
return SDL_Color{r, g, b, a};
}
static void drawFireworks_impl(SDL_Renderer* renderer, SDL_Texture*) {
SDL_BlendMode previousBlend = SDL_BLENDMODE_NONE;
SDL_GetRenderDrawBlendMode(renderer, &previousBlend);
SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_ADD);
static constexpr int quadIndices[6] = {0, 1, 2, 2, 1, 3};
auto makeVertex = [](float px, float py, SDL_Color c) {
SDL_Vertex v{};
v.position.x = px;
v.position.y = py;
v.color = SDL_FColor{
c.r / 255.0f,
c.g / 255.0f,
c.b / 255.0f,
c.a / 255.0f
};
return v;
};
for (auto& f : fireworks) { for (auto& f : fireworks) {
// Particle draw uses the texture pointer passed into drawBlockTexture calls from f.draw
// We'll set a thread-local-ish variable by passing the texture as an argument to draw
// routines or using the provided texture in the particle's draw path.
// For simplicity, the particle draw function below will reference a global symbol
// via an argument — we adapt by providing the texture when calling drawBlockTexture.
// Implementation: call a small lambda that temporarily binds the texture for drawBlockTexture.
struct Drawer { SDL_Renderer* r; SDL_Texture* tex; void drawParticle(struct BlockParticle& p) {
if (tex) {
Uint8 prevA = 255;
SDL_GetTextureAlphaMod(tex, &prevA);
Uint8 setA = Uint8(std::max(0.0f, std::min(1.0f, p.alpha)) * 255.0f);
SDL_SetTextureAlphaMod(tex, setA);
// Note: color modulation will be applied by callers of drawBlockTexture where needed
// but we mimic behavior from previous implementation by leaving color mod as default.
drawBlockTexture(r, tex, p.x - p.size * 0.5f, p.y - p.size * 0.5f, p.size, p.blockType);
SDL_SetTextureAlphaMod(tex, prevA);
SDL_SetTextureColorMod(tex, 255, 255, 255);
} else {
SDL_SetRenderDrawColor(r, 255, 255, 255, Uint8(p.alpha * 255));
SDL_FRect rect{p.x - p.size/2, p.y - p.size/2, p.size, p.size};
SDL_RenderFillRect(r, &rect);
}
}
} drawer{renderer, blocksTexture};
for (auto &p : f.particles) { for (auto &p : f.particles) {
drawer.drawParticle(p); const float heat = std::clamp(p.alpha * 1.25f + p.coreHeat * 0.5f, 0.0f, 1.0f);
SDL_Color glowColor = blendFireColor(0.45f + heat * 0.55f, p.alpha * 0.55f, 100, 40);
SDL_Color tailBaseColor = blendFireColor(heat * 0.75f, p.alpha * 0.5f, 70, 25);
SDL_Color tailTipColor = blendFireColor(heat * 0.35f, p.alpha * 0.2f, 40, 15);
SDL_Color coreColor = blendFireColor(heat, std::min(1.0f, p.alpha * 1.1f), 150, 80);
float velLen = std::sqrt(p.vx * p.vx + p.vy * p.vy);
SDL_FPoint dir = velLen > 0.001f ? SDL_FPoint{p.vx / velLen, p.vy / velLen}
: SDL_FPoint{0.0f, -1.0f};
SDL_FPoint perp{-dir.y, dir.x};
const float baseWidth = std::max(0.8f, p.size * 0.55f);
const float tipWidth = baseWidth * 0.35f;
const float tailLen = p.size * (3.0f + (1.0f - p.alpha) * 1.8f);
SDL_FPoint base{p.x, p.y};
SDL_FPoint tip{p.x + dir.x * tailLen, p.y + dir.y * tailLen};
SDL_Vertex tailVerts[4];
tailVerts[0] = makeVertex(base.x + perp.x * baseWidth, base.y + perp.y * baseWidth, tailBaseColor);
tailVerts[1] = makeVertex(base.x - perp.x * baseWidth, base.y - perp.y * baseWidth, tailBaseColor);
tailVerts[2] = makeVertex(tip.x + perp.x * tipWidth, tip.y + perp.y * tipWidth, tailTipColor);
tailVerts[3] = makeVertex(tip.x - perp.x * tipWidth, tip.y - perp.y * tipWidth, tailTipColor);
SDL_RenderGeometry(renderer, nullptr, tailVerts, 4, quadIndices, 6);
const float glowAlong = p.size * 0.95f;
const float glowAcross = p.size * 0.6f;
SDL_Vertex glowVerts[4];
glowVerts[0] = makeVertex(base.x + dir.x * glowAlong, base.y + dir.y * glowAlong, glowColor);
glowVerts[1] = makeVertex(base.x - dir.x * glowAlong, base.y - dir.y * glowAlong, glowColor);
glowVerts[2] = makeVertex(base.x + perp.x * glowAcross, base.y + perp.y * glowAcross, glowColor);
glowVerts[3] = makeVertex(base.x - perp.x * glowAcross, base.y - perp.y * glowAcross, glowColor);
SDL_RenderGeometry(renderer, nullptr, glowVerts, 4, quadIndices, 6);
const float coreWidth = p.size * 0.35f;
const float coreHeight = p.size * 0.9f;
SDL_Vertex coreVerts[4];
coreVerts[0] = makeVertex(base.x + perp.x * coreWidth, base.y + perp.y * coreWidth, coreColor);
coreVerts[1] = makeVertex(base.x - perp.x * coreWidth, base.y - perp.y * coreWidth, coreColor);
coreVerts[2] = makeVertex(base.x + dir.x * coreHeight, base.y + dir.y * coreHeight, coreColor);
coreVerts[3] = makeVertex(base.x - dir.x * coreHeight, base.y - dir.y * coreHeight, coreColor);
SDL_RenderGeometry(renderer, nullptr, coreVerts, 4, quadIndices, 6);
} }
} }
SDL_SetRenderDrawBlendMode(renderer, previousBlend);
} }
// External wrappers for use by other translation units (MenuState) // External wrappers for use by other translation units (MenuState)
// Expect callers to pass the blocks texture via StateContext so we avoid globals. // Expect callers to pass the blocks texture via StateContext so we avoid globals.