iterator.c

Go to the documentation of this file.

#include "../ctl/ctldef.h"
#include "iterator.h"


void LinePath_init( LinePath* self, int x1,int y1,int z1, unsigned msBegin, int x2,int y2,int z2, unsigned msFinish )
{
    self->begin = msBegin;
    self->end = msFinish;
    self->x1 = x1;
    self->y1 = y1;
    self->z1 = z1;
    self->x2 = x2;
    self->y2 = y2;
    self->z2 = z2;
}

void LinePath_setpos( LinePath* self, int x,int y,int z, unsigned msCurrent )
{
    self->begin = msCurrent;
    self->end = msCurrent;
    self->x2 = self->x1 = x;
    self->y2 = self->y1 = y;
    self->z2 = self->z1 = z;
}

void LinePath_moveto( LinePath* self, int x,int y,int z, unsigned msCurrent, unsigned msArrive )
{
    LinePath_curr( self, &self->x1,&self->y1,&self->z1, msCurrent );
    self->begin = msCurrent;
    self->end = msArrive;
    self->x2 = x;
    self->y2 = y;
    self->z2 = z;
}

bool LinePath_curr( const LinePath* self, int *x,int *y,int *z, unsigned msCurrent )
{
    if( msCurrent <= self->begin )
    {
        *x = self->x1;
        *y = self->y1;
        *z = self->z1;
        return true;
    }
    else if( msCurrent >= self->end )
    {
        *x = self->x2;
        *y = self->y2;
        *z = self->z2;
        return false;
    }
    else
    {
        int total = (int)(1u + self->end - self->begin);
        int elapsed = (int)(msCurrent - self->begin);
        *x = self->x1 + ((self->x2-self->x1) * elapsed / total);
        *y = self->y1 + ((self->y2-self->y1) * elapsed / total);
        *z = self->z1 + ((self->z2-self->z1) * elapsed / total);
        return true;
    }
}

int Animator_init( Animator* self, int firstFrame, int lastFrame, Animator_Dir dir, unsigned msPerFrame )
{
    self->msprev = 0;
    self->msframe = msPerFrame;
    self->firstFrame = firstFrame;
    self->lastFrame = lastFrame;
    self->aDir = dir;
    switch( dir )
    {
        case an_Stop:
        case an_ForwardOneshot:
        case an_ForwardLoop:
        case an_ForwardPingPong:
        case an_Random:
            self->iFrame = firstFrame;
            break;
        case an_BackwardOneshot:
        case an_BackwardLoop:
        case an_BackwardPingPong:
            self->iFrame = lastFrame;
            break;
    }
    return firstFrame;
}

int Animator_set( Animator* self, int frame )
{
    self->msprev = 0;
    self->msframe = 0;
    self->aDir = an_Stop;
    self->firstFrame = frame;
    self->lastFrame = frame;
    self->iFrame = frame;
    return frame;
}

bool Animator_pending( const Animator* self )
{
    if( self->aDir == an_ForwardOneshot )
        return self->iFrame <= self->lastFrame;
    else if( self->aDir == an_BackwardOneshot )
        return self->iFrame >= self->firstFrame;
    return false;
}


bool Animator_curr( Animator* self, int* frame, unsigned msCurrent )
{
    if( msCurrent - self->msprev > self->msframe )
    {
        if( !self->msprev )
        {
            self->msprev = msCurrent;
            *frame = self->iFrame;
            return false;
        }
        self->msprev = msCurrent;
        switch( self->aDir )
        {
        case an_Stop:
            break;
        case an_ForwardOneshot:
            if( ++self->iFrame > self->lastFrame )
            {
                *frame = self->iFrame = self->lastFrame;
                self->aDir = an_Stop;
                return false;
            }
            break;
        case an_BackwardOneshot:
            if( --self->iFrame < self->firstFrame )
            {
                *frame = self->iFrame = self->firstFrame;
                self->aDir = an_Stop;
                return false;
            }
            break;
        case an_ForwardLoop:
            if( ++self->iFrame > self->lastFrame )
                self->iFrame = self->firstFrame;
            break;
        case an_BackwardLoop:
            if( --self->iFrame < self->firstFrame )
                self->iFrame = self->lastFrame;
            break;
        case an_ForwardPingPong:
            if( ++self->iFrame > self->lastFrame )
            {
                self->iFrame = self->lastFrame-1;
                self->aDir = an_BackwardPingPong;
            }
            break;
        case an_BackwardPingPong:
            if( --self->iFrame < self->firstFrame )
            {
                self->iFrame = self->firstFrame + 1;
                self->aDir = an_ForwardPingPong;
            }
            break;
        case an_Random:
            self->iFrame = self->firstFrame + (rand() % (1+self->lastFrame-self->firstFrame));
            break;
        }

    }
    *frame = self->iFrame;
    return true;
}