path: root/visualization/extrasmeltutils.cpp

#include <cstdio>
#include <cstdarg>
#include <algorithm>
#include <smcolor.hpp>
#include "extrasmeltutils.hpp"
SMELT *smEntity3DBuffer::sm = nullptr;
SMELT *smParticle::sm = nullptr;
SMELT *smParticleSystem::sm = nullptr;
smVertex makeVertex(float x, float y, float z, DWORD color, float tx, float ty)
{
    smVertex v;
    v.x = x;
    v.y = y;
    v.z = z;
    v.col = color;
    v.tx = tx;
    v.ty = ty;
    return v;
}
void smEntity3D::addVertices(size_t n, ...)
{
    va_list vl;
    va_start(vl, n);
    for (int i = 0; i < n; ++i)
    {
        smVertex v = va_arg(vl, smVertex);
        vertices.push_back(v);
    }
    va_end(vl);
}
void smEntity3D::addIndices(size_t n, ...)
{
    va_list vl;
    va_start(vl, n);
    for (int i = 0; i < n; ++i)
    {
        int idx = va_arg(vl, int);
        indices.push_back((WORD)idx);
    }
    va_end(vl);
}
smVertex smEntity3D::vertex(size_t idx)const
{
    if (idx > 0 && idx < vertices.size())
        return vertices[idx];
    return smVertex();
}
WORD smEntity3D::index(size_t idx)const
{
    if (idx > 0 && idx < indices.size())
        return indices[idx];
    return 0;
}
void smEntity3D::setVertex(size_t idx, smVertex v)
{
    if (idx > 0 && idx < vertices.size())
        vertices[idx] = v;
}
void smEntity3D::setIndex(size_t idx, WORD i)
{
    if (idx > 0 && idx < indices.size())
        indices[idx] = i;
}

smEntity3D smEntity3D::cube(smvec3d a, smvec3d b, DWORD color, int faces)
{
    smEntity3D ret;
    ret.addVertices(8,
        makeVertex(a.x, a.y, a.z, color, 0, 0), makeVertex(b.x, a.y, a.z, color, 0, 0),
        makeVertex(b.x, b.y, a.z, color, 0, 0), makeVertex(a.x, b.y, a.z, color, 0, 0),
        makeVertex(a.x, a.y, b.z, color, 0, 0), makeVertex(b.x, a.y, b.z, color, 0, 0),
        makeVertex(b.x, b.y, b.z, color, 0, 0), makeVertex(a.x, b.y, b.z, color, 0, 0));
    if (faces & 0x1) //a.z
        ret.addIndices(6, 0, 1, 3, 1, 2, 3);
    if (faces & 0x2) //b.z
        ret.addIndices(6, 4, 5, 7, 5, 6, 7);
    if (faces & 0x4) //a.x
        ret.addIndices(6, 0, 3, 7, 0, 4, 7);
    if (faces & 0x8) //b.x
        ret.addIndices(6, 1, 2, 6, 1, 5, 6);
    if (faces & 0x10) //a.y
        ret.addIndices(6, 0, 1, 4, 1, 4, 5);
    if (faces & 0x20) //b.y
        ret.addIndices(6, 2, 3, 7, 2, 6, 7);
    return ret;
}
smEntity3DBuffer::smEntity3DBuffer()
{
    sm = smGetInterface(SMELT_APILEVEL);
    vertices.clear();
    indices.clear();
}
void smEntity3DBuffer::addTransformedEntity(smEntity3D *entity, smMatrix t, smvec3d p)
{
    if (entity->vertices.size() + vertices.size() > 4000)
        drawBatch();
    for (unsigned i = 0; i < entity->indices.size(); ++i)
        indices.push_back(entity->indices[i] + vertices.size());
    for (unsigned i = 0; i < entity->vertices.size(); ++i)
    {
        smvec3d tp = smvec3d(entity->vertices[i].x, entity->vertices[i].y, entity->vertices[i].z);
        tp = t * tp;
        tp = tp + p;
        vertices.push_back(makeVertex(tp.x, tp.y, tp.z, entity->vertices[i].col, entity->vertices[i].tx, entity->vertices[i].ty));
    }
}
void smEntity3DBuffer::drawBatch()
{
    if (!vertices.size())
        return;
    sm->smDrawCustomIndexedVertices(&vertices[0], &indices[0], vertices.size(), indices.size(), BLEND_ALPHABLEND, 0);
    vertices.clear();
    indices.clear();
}
smParticle::smParticle()
{
    sm = smGetInterface(SMELT_APILEVEL);
    dead = false;
    clifespan = 0;
}
smParticle::~smParticle()
{
    sm->smRelease();
}
void smParticle::render()
{
    sm->smRenderQuad(&q);
}
void smParticle::update()
{
    clifespan += sm->smGetDelta();
    if (clifespan > lifespan)
    {
        dead = true;
        return;
    }
    vel = vel + accel;
    pos = pos + vel;
    rotv = rotv + rota;
    rot = rot + rotv;
    size = clifespan / lifespan * (finalsize - initsize) + initsize;
    smColorRGBA fc(finalcolor), ic(initcolor), cc;
    cc.a = clifespan / lifespan * (fc.a - ic.a) + ic.a;
    cc.r = clifespan / lifespan * (fc.r - ic.r) + ic.r;
    cc.g = clifespan / lifespan * (fc.g - ic.g) + ic.g;
    cc.b = clifespan / lifespan * (fc.b - ic.b) + ic.b;
    color = cc.getHWColor();
    for (int i = 0; i < 4; ++i)
        q.v[i].col = color;
    smMatrix m;
    m.loadIdentity();
    if (lookat)
        m.lookat(pos, lookatpos, smvec3d(0, 0, 1));
    else
    {
        m.rotate(rot.x, 1, 0, 0);
        m.rotate(rot.y, 0, 1, 0);
        m.rotate(rot.z, 0, 0, 1);
    }
    smvec3d v0 = m * smvec3d(-size, -size, 0), v1 = m * smvec3d(size, -size, 0);
    smvec3d v2 = m * smvec3d(size, size, 0), v3 = m * smvec3d(-size, size, 0);
    q.v[0].x = v0.x + pos.x;
    q.v[0].y = v0.y + pos.y;
    q.v[0].z = v0.z + pos.z;
    q.v[1].x = v1.x + pos.x;
    q.v[1].y = v1.y + pos.y;
    q.v[1].z = v1.z + pos.z;
    q.v[2].x = v2.x + pos.x;
    q.v[2].y = v2.y + pos.y;
    q.v[2].z = v2.z + pos.z;
    q.v[3].x = v3.x + pos.x;
    q.v[3].y = v3.y + pos.y;
    q.v[3].z = v3.z + pos.z;
}
smParticleSystem::smParticleSystem()
{
    sm = smGetInterface(SMELT_APILEVEL);
    particles.clear();
    posGenerator = nullptr;
    active = false;
}
smParticleSystem::~smParticleSystem()
{
    for (unsigned i = 0; i < particles.size(); ++i)
        delete particles[i];
    particles.clear();
}
void smParticleSystem::setParticleSystemInfo(smParticleSystemInfo _psinfo)
{
    psinfo = _psinfo;
}
void smParticleSystem::setPos(smvec3d _pos)
{
    pos = _pos;
}
void smParticleSystem::setPSEmissionPosGen(smPSEmissionPositionGenerator *_gen)
{
    posGenerator = _gen;
}
void smParticleSystem::setPSLookAt(smvec3d at)
{
    lookat = true;
    lookatpos = at;
}
void smParticleSystem::unsetPSLookAt()
{
    lookat = false;
}
void smParticleSystem::startPS()
{
    active = true;
    nemdelay = 0;
    re.setSeed(time(nullptr));
}
void smParticleSystem::stopPS()
{
    active = false;
}
void smParticleSystem::updatePS()
{
    cemdelay += sm->smGetDelta();
    if (active && cemdelay > nemdelay && (int)particles.size() < psinfo.maxcount)
    {
        int ec = re.nextInt(psinfo.emissioncount - psinfo.ecvar, psinfo.emissioncount + psinfo.ecvar);
        for (int i = 0; i < ec; ++i)
        {
            smParticle *p = new smParticle();
            p->pos = pos + (posGenerator ? posGenerator->genPos() : smvec3d(0, 0, 0));
            p->vel = smvec3d(
                    re.nextDouble(psinfo.vel.x - psinfo.velvar.x, psinfo.vel.x + psinfo.velvar.x),
                    re.nextDouble(psinfo.vel.y - psinfo.velvar.y, psinfo.vel.y + psinfo.velvar.y),
                    re.nextDouble(psinfo.vel.z - psinfo.velvar.z, psinfo.vel.z + psinfo.velvar.z));
            p->accel = smvec3d(
                    re.nextDouble(psinfo.acc.x - psinfo.accvar.x, psinfo.acc.x + psinfo.accvar.x),
                    re.nextDouble(psinfo.acc.y - psinfo.accvar.y, psinfo.acc.y + psinfo.accvar.y),
                    re.nextDouble(psinfo.acc.z - psinfo.accvar.z, psinfo.acc.z + psinfo.accvar.z));
            p->rotv = smvec3d(
                    re.nextDouble(psinfo.rotv.x - psinfo.rotvvar.x, psinfo.rotv.x + psinfo.rotvvar.x),
                    re.nextDouble(psinfo.rotv.y - psinfo.rotvvar.y, psinfo.rotv.y + psinfo.rotvvar.y),
                    re.nextDouble(psinfo.rotv.z - psinfo.rotvvar.z, psinfo.rotv.z + psinfo.rotvvar.z));
            p->rota = smvec3d(
                    re.nextDouble(psinfo.rota.x - psinfo.rotavar.x, psinfo.rota.x + psinfo.rotavar.x),
                    re.nextDouble(psinfo.rota.y - psinfo.rotavar.y, psinfo.rota.y + psinfo.rotavar.y),
                    re.nextDouble(psinfo.rota.z - psinfo.rotavar.z, psinfo.rota.z + psinfo.rotavar.z));
            p->rot = smvec3d(0, 0, 0);
            if (lookat)
                p->lookat = true, p->lookatpos = lookatpos;
            else p->lookat = false;
            p->lifespan = re.nextDouble(psinfo.lifespan - psinfo.lifespanvar, psinfo.lifespan + psinfo.lifespanvar);
            p->initsize = re.nextDouble(psinfo.initsize - psinfo.initsizevar, psinfo.initsize + psinfo.initsizevar);
            p->finalsize = re.nextDouble(psinfo.finalsize - psinfo.finalsizevar, psinfo.finalsize + psinfo.finalsizevar);
            p->size = p->initsize;
            p->initcolor = ARGB(
                    re.nextInt(GETA(psinfo.initcolor) - GETA(psinfo.initcolorvar), GETA(psinfo.initcolor) + GETA(psinfo.initcolorvar)),
                    re.nextInt(GETR(psinfo.initcolor) - GETR(psinfo.initcolorvar), GETR(psinfo.initcolor) + GETR(psinfo.initcolorvar)),
                    re.nextInt(GETG(psinfo.initcolor) - GETG(psinfo.initcolorvar), GETG(psinfo.initcolor) + GETG(psinfo.initcolorvar)),
                    re.nextInt(GETB(psinfo.initcolor) - GETB(psinfo.initcolorvar), GETB(psinfo.initcolor) + GETB(psinfo.initcolorvar)));
            p->finalcolor = ARGB(
                    re.nextInt(GETA(psinfo.finalcolor) - GETA(psinfo.finalcolorvar), GETA(psinfo.finalcolor) + GETA(psinfo.finalcolorvar)),
                    re.nextInt(GETR(psinfo.finalcolor) - GETR(psinfo.finalcolorvar), GETR(psinfo.finalcolor) + GETR(psinfo.finalcolorvar)),
                    re.nextInt(GETG(psinfo.finalcolor) - GETG(psinfo.finalcolorvar), GETG(psinfo.finalcolor) + GETG(psinfo.finalcolorvar)),
                    re.nextInt(GETB(psinfo.finalcolor) - GETB(psinfo.finalcolorvar), GETB(psinfo.finalcolor) + GETB(psinfo.finalcolorvar)));
            p->color = p->initcolor;
            p->q.tex = psinfo.texture;
            p->q.blend = psinfo.blend;
            p->q.v[0].tx = p->q.v[3].tx = 0;
            p->q.v[0].ty = p->q.v[1].ty = 0;
            p->q.v[1].tx = p->q.v[2].tx = 1;
            p->q.v[2].ty = p->q.v[3].ty = 1;
            particles.push_back(p);
        }
        cemdelay = 0;
        nemdelay = re.nextDouble(psinfo.emissiondelay - psinfo.edvar, psinfo.emissiondelay + psinfo.edvar);
    }
    for (unsigned i = 0, j; i < particles.size() && !particles[i]->dead; ++i)
    {
        particles[i]->update();
        if (particles[i]->dead)
        {
            for (j = particles.size() - 1; j > i && particles[j]->dead; --j);
            std::swap(particles[i], particles[j]);
        }
    }
    while (!particles.empty() && particles.back()->dead)
    {
        delete particles.back();
        particles.back() = nullptr;
        particles.pop_back();
    }
}
void smParticleSystem::renderPS()
{
    for (unsigned i = 0; i < particles.size(); ++i)
        particles[i]->render();
}

smColor::smColor()
{
    r = g = b = h = s = v = a = 0;
}

void smColor::update_rgb()
{
    auto f = [this](float n)
    {
        float k = fmodf(n + 6.0f * this->h, 6.0f);
        return this->v - this->v * this->s * max(0.0f, min(1.0f, min(k, 4.0f - k)));
    };
    r = f(5);
    g = f(3);
    b = f(1);
}
void smColor::update_hsv()
{
    v = max(r, max(g, b));
    float vm = min(r, min(g, b));
    float chroma = v - vm;
    if (v - vm < EPSF)
        h = 0;
    else if (v - r < EPSF)
        h = (0.0f + (g - b) / chroma) / 6.0f;
    else if (v - g < EPSF)
        h = (2.0f + (b - r) / chroma) / 6.0f;
    else if (v - b < EPSF)
        h = (4.0f + (r - g) / chroma) / 6.0f;
    if (v < EPSF)
        s = 0;
    else s = chroma / v;
}

void smColor::clamp(bool hsv)
{
    if (hsv)
    {
        h = min(1.0f, max(0.0f, h));
        s = min(1.0f, max(0.0f, s));
        v = min(1.0f, max(0.0f, v));
        update_rgb();
    }
    else
    {
        r = min(1.0f, max(0.0f, r));
        g = min(1.0f, max(0.0f, g));
        b = min(1.0f, max(0.0f, b));
        update_hsv();
    }
}
float smColor::alpha()const
{
    return a;
}
float smColor::red()const
{
    return r;
}
float smColor::green()const
{
    return g;
}
float smColor::blue()const
{
    return b;
}
float smColor::hue()const
{
    return h;
}
float smColor::saturation()const
{
    return s;
}
float smColor::hslSaturation()const
{
    float l = lightness();
    if (fabsf(l) < EPSF || fabsf(l - 1) < EPSF)
        return 0;
    return (v - l) / min(l, 1 - l);
}
float smColor::value()const
{
    return v;
}
float smColor::lightness()const
{
    return v - v * s / 2;
}

void smColor::setAlpha(float alpha)
{
    a = alpha;
}
void smColor::setRed(float red)
{
    if (fabsf(r - red) > EPSF)
    {
        r = red;
        update_hsv();
    }
}
void smColor::setGreen(float green)
{
    if (fabsf(g - green) > EPSF)
    {
        g = green;
        update_hsv();
    }
}
void smColor::setBlue(float blue)
{
    if (fabsf(b - blue) > EPSF)
    {
        b = blue;
        update_hsv();
    }
}
void smColor::setHue(float hue)
{
    if (fabsf(h - hue) > EPSF)
    {
        h = hue;
        update_rgb();
    }
}
void smColor::setSaturation(float saturation)
{
    if (fabsf(s - saturation) > EPSF)
    {
        s = saturation;
        update_rgb();
    }
}
void smColor::setHSLSaturation(float saturation)
{
    float ss = hslSaturation();
    float l = lightness();
    if (fabsf(ss - saturation) > EPSF)
    {
        ss = saturation;
        v = l + ss * min(l, 1 - l);
        if (v < EPSF)
            s = 0;
        else s = 2 - 2 * l / v;
        update_rgb();
    }
}
void smColor::setValue(float value)
{
    if (fabsf(v - value) > EPSF)
    {
        v = value;
        update_rgb();
    }
}
void smColor::setLightness(float lightness)
{
    float ss = hslSaturation();
    float l = this->lightness();
    if (fabsf(l - lightness) > EPSF)
    {
        l = lightness;
        v = l + ss * min(l, 1 - l);
        if (v < EPSF)
            s = 0;
        else s = 2 - 2 * l / v;
        update_rgb();
    }
}
smColor smColor::lighter(int factor)
{
    smColor ret(*this);
    ret.setValue(v * (factor / 100.0f));
    ret.clamp(true);
    return ret;
}
smColor smColor::darker(int factor)
{
    smColor ret(*this);
    ret.setValue(factor ? (v / (factor / 100.0f)) : 1.);
    ret.clamp(true);
    return ret;
}

uint32_t smColor::toHWColor()
{
    return RGBA(r * 255, g * 255, b * 255, a * 255);
}
smColor smColor::fromHWColor(uint32_t color)
{
    smColor ret;
    ret.r = GETR(color) / 255.0f;
    ret.g = GETG(color) / 255.0f;
    ret.b = GETB(color) / 255.0f;
    ret.a = GETA(color) / 255.0f;
    ret.update_hsv();
    return ret;
}