File content as of revision 24:ab74d2018e6c:

#include "renderclass.h"
#include "mbed.h"
#include "laserProjectorHardware.h"
#include <vector>

Ticker translationTimer;

//for translating -----------------------------------------------------------------

inline void render::shearing(point2dl& dataBefore)
{
    dataBefore.x = dataBefore.x - vx * speedTimer.read_us()/100; //2000000;//dataBefore.x - speed *speedTimer.read_us()/1000000 ;//- speed * cos(angle+PI/2)*speedTimer.read_us()/800;
    dataBefore.y = dataBefore.y - vy * speedTimer.read_us()/2000000;//dataBefore.y ;//- speed * sin(angle+PI/2)*speedTimer.read_us()/800;
}

inline void render::rotation(point2dl& dataBefore)
{
    int x=dataBefore.x;
    dataBefore.x = x + abs((int)angle) % (2 * (CENTER_AD_MIRROR_X-200)) -  CENTER_AD_MIRROR_X+200;//x + (CENTER_AD_MIRROR_X-200) * cos(angle);//radious * cos(angle) + sin(angle)*x - cos(angle)*dataBefore.y;//
    dataBefore.y = -dataBefore.y;//radious * sin(angle) - cos(angle)*x - sin(angle)*dataBefore.y;//

}
//----------------------------------------------------------------------------------

void render::startRender()
{
    speedTimer.start();
    renderTimer.attach_us(this, &render::draw,RENDER_INTERVAL);
    pc.printf("render started!\n");
}

void render::stopRender()
{
    renderTimer.detach();
    speedTimer.stop();
}

void render::setRender(vector<letter> *p)
{
    translated.clear();
    
    ptext = p;
    pc.printf("Size of text to render: %d/n", (*ptext).size() );
    //for(int i=0; i!=(*ptext).size(); i++){
    int count=0;
    for(std::vector<letter>::iterator itr = (*ptext).begin(); itr != (*ptext).end(); ++itr) {
        letter translatedLetter;
        for(int i=0; i<(*itr).letpoints.size(); i++) {
            point2dl tranPoint;
            tranPoint.x=itr->letpoints[i].x+560*count;
            tranPoint.y=itr->letpoints[i].y;
            tranPoint.laserSwitch=itr->letpoints[i].laserSwitch;
            translatedLetter.letpoints.push_back(tranPoint);
        
    }                                            //copy the liblary to the buffer.
    translated.push_back(translatedLetter);
    count++;
}

    shearingSwitch = 1;
    radious = 1800;

    currentLetters=0;

    firstPointCounter=0;
    lastPointCounter=0;

    rendererState=FIRST_POINT;
}


void render::updateSpeed(float gspeed, float gangle, float vvx, float vvy)
{
    speed = gspeed;
    angle = gangle;

    vx = vvx;//gspeed * radious * cos(angle+PI/2);
    vy = vvy;//gspeed * radious * sin(angle+PI/2);


    //speed=sqrt(vx*vx+vy*vy);//*factorSpeed;
    //angle=atan2(vy,vx);
}

void render::draw()
{
    if(translated.size()>0) {

        switch(rendererState) {

            case NORMAL_POINT:
                point2dl drawPoint=translated[currentLetters].letpoints[currentPoints];
                transform(drawPoint);               // transform it with the current speed and angle
                IO.writeOutXY(CENTER_AD_MIRROR_X + (int)drawPoint.x , CENTER_AD_MIRROR_Y + (int)drawPoint.y);
                IO.setRedPower(translated[currentLetters].letpoints[currentPoints].laserSwitch);

                // move to the next point
                currentPoints++;

                //Should we change the state?
                if(currentPoints >= translated[currentLetters].letpoints.size() ) {
                    rendererState=AFTER_LAST_POINT;
                }
                break;

            case AFTER_LAST_POINT:
                // just wait!
                if (lastPointCounter<WAITING_LAST) {
                IO.setRedPower(0);
                lastPointCounter++;
                }
                else {
                    lastPointCounter=0;
                    currentPoints = 0;
                    // switch the laser off and move to the first point of the next letter:
                    
                    currentLetters++;
                    if(currentLetters >= translated.size()) {
                        currentLetters = 0;
                        speedTimer.reset();
                    }
                    rendererState=FIRST_POINT;
                    }
                    break;

                case FIRST_POINT:
                    if (firstPointCounter<WAITING_FIRST) {
                    firstPointCounter++;
                    
                    // show first point!
                    point2dl drawPoint=translated[currentLetters].letpoints[0];
                    transform(drawPoint);               // transform it with the current speed and angle
                    IO.writeOutXY(CENTER_AD_MIRROR_X + (int)drawPoint.x , CENTER_AD_MIRROR_Y + (int)drawPoint.y);
                    //IO.setRedPower(translated[currentLetters].letpoints[currentPoints].laserSwitch);

                    } else {
                        firstPointCounter=0;
                        currentPoints=1;
                        rendererState=NORMAL_POINT;
                    }
                    break;
                }
        }
    }

    void render::transform(point2dl& mypoint) {
        rotation(mypoint);
        if(shearingSwitch == 1) shearing(mypoint);
    }