bool Scene::update()
{
if(pG_floor->pMovepath)
{
/*
if(step>allSteps)
{
step=0;
pfMoveStepNow[0]=-pfMoveStepNow[0];
pfMoveStepNow[1]=-pfMoveStepNow[1];
pfMoveStepNow[2]=-pfMoveStepNow[2];
}
*/
getMovesteps();
updateMove();
renewPhyScene();
//step++;
}else
{
//LOGI("update 0");
pG_floor->draw();
//LOGI("num_coins: %d",num_coins);
for(int i=0;i<num_coins;i++)
{//LOGI("num_coins i: %d",i);
vCoin[i]->update(pLR);
}
/*
for(int i=0;i<num_enemys;i++)
{
if(vEnemy[i]->state==2)
continue;
updateOneEnemy( vEnemy[i]);
}
*/
for(int i=0;i<num_thorns;i++)
{
vThorn[i]->update(pLR);
}
for(int i=0;i<num_thornballs;i++)
{
vThornball[i]->update(pLR);
}
}
return true;
}
bool Scene::updateLess()
{
//LOGI("updateL0");
if(pG_floor->pMovepath)
{
getMovesteps();
updateMoveLess();
//renewPhyScene();
//step++;
}else
{
pG_floor->draw();
/*
for(int i=0;i<num_coins;i++)
{
vCoin[i]->updateLess();
}
for(int i=0;i<num_enemys;i++)
{
if(vEnemy[i]->state==2)
continue;
updateOneEnemy( vEnemy[i]);
}
*/
for(int i=0;i<num_thorns;i++)
{
//if(vThorn[i])
vThorn[i]->updateLess();
}
for(int i=0;i<num_thornballs;i++)
{
vThornball[i]->updateLess();//update(pLR);//
}
}
//LOGI("updateL1");
return true;
}
void Motion::gcode_precalc(GCode& gcode, float& feedin, Point* lastend)
{
if(gcode.state >= GCode::PREPARED)
return;
if(gcode[G].isUnused())
return;
if(gcode[G].getInt() == 92)
{
// Just carry over new position
for(int ax=0;ax<NUM_AXES;ax++)
{
if(!gcode[ax].isUnused())
{
(*lastend)[ax] = gcode[ax].getFloat();
}
}
gcode.state = GCode::PREPARED;
return;
}
if(gcode[G].getInt() != 1 and gcode[G].getInt() != 2)
{
// no precalc for anything but 92, 1, 2
gcode.state = GCode::PREPARED;
return;
}
// We want to carry over the previous ending position and feedrate if possible.
gcode.startpos = *lastend;
if(gcode[F].isUnused())
gcode.feed = feedin;
else
gcode.feed = gcode[F].getFloat();
if(gcode.feed == 0)
gcode.feed = SAFE_DEFAULT_FEED;
getMovesteps(gcode);
getActualEndpos(gcode);
*lastend = gcode.endpos;
feedin = gcode.feed;
gcode.state = GCode::PREPARED;
if(gcode.movesteps == 0)
return;
// Calculate actual distance of move along vector
gcode.actualmm = 0;
for(int ax=0;ax<NUM_AXES;ax++)
{
gcode.actualmm += pow(gcode.axismovesteps[ax]/AXES[ax].getStepsPerMM(), 2);
}
gcode.actualmm = sqrt(gcode.actualmm);
float axisspeeds[NUM_AXES];
// Calculate individual axis movement speeds
float mult = gcode.feed/gcode.actualmm;
for(int ax=0;ax<NUM_AXES;ax++)
{
axisspeeds[ax] = (gcode.axismovesteps[ax] / AXES[ax].getStepsPerMM()) * mult;
#ifdef DEBUG_LAME
HOST.labelnum("AS", ax, false);
HOST.labelnum(":", axisspeeds[ax]);
#endif
}
// Calculate ratio of movement speeds to main axis
for(int ax=0;ax < NUM_AXES;ax++)
{
if(axisspeeds[ax] != 0)
gcode.axisratio[ax] = axisspeeds[gcode.leading_axis] / axisspeeds[ax];
else
gcode.axisratio[ax] = 0;
}
// Check all axis for violation o top speed. Take the biggest violator and change
// the leading axis speed to match it.
float bigdiff = 0;
float littlediff = 0;
for(int ax = 0;ax<NUM_AXES;ax++)
{
if(axisspeeds[ax] > AXES[ax].getMaxFeed())
{
float d = (axisspeeds[ax] - AXES[ax].getMaxFeed()) * gcode.axisratio[ax];
#ifdef DEBUG_LAME
HOST.labelnum("D",ax,false);
HOST.labelnum(":",axisspeeds[ax] - AXES[ax].getMaxFeed(),false);
HOST.labelnum(" rat: ", gcode.axisratio[ax]);
#endif
if(d > bigdiff)
bigdiff = d;
}
if(axisspeeds[ax] > AXES[ax].getStartFeed()/2)
{
float d = (axisspeeds[ax] - (AXES[ax].getStartFeed()/2)) * gcode.axisratio[ax];
if(d > littlediff)
littlediff = d;
}
}
#ifdef DEBUG_LAME
HOST.labelnum("BD:", bigdiff);
HOST.labelnum("LD:", littlediff);
#endif
gcode.maxfeed = axisspeeds[gcode.leading_axis] - bigdiff;
gcode.startfeed = axisspeeds[gcode.leading_axis] - littlediff;
gcode.endfeed = gcode.startfeed;
gcode.currentfeed = gcode.startfeed;
gcode.minfeed = gcode.startfeed;
// TODO: We shoudl treat accel as we do the speeds above and scale it to fit the chosen axis.
// instead we just take the accel of the leadng axis.
float accel = AXES[gcode.leading_axis].getAccel();
gcode.accel = accel;
for(int ax=0;ax<NUM_AXES;ax++)
{
if(gcode.axismovesteps[ax])
AXES[ax].enable();
}
#ifdef DEBUG_LAME
HOST.labelnum("F1: ", gcode.startfeed);
HOST.labelnum("F2: ", gcode.maxfeed);
HOST.labelnum("Accel: ", accel);
#endif
uint32_t dist = AXES[gcode.leading_axis].getAccelDist(gcode.startfeed, gcode.maxfeed, accel);
uint32_t halfmove = gcode.movesteps >> 1;
if(halfmove <= dist)
{
gcode.accel_until = gcode.movesteps - halfmove;
gcode.decel_from = halfmove;
}
else
{
gcode.accel_until = gcode.movesteps - dist;
gcode.decel_from = dist;
}
gcode.currentinterval = AXES[gcode.leading_axis].int_interval_from_feedrate(gcode.startfeed);
gcode.currentfeed = gcode.startfeed;
// TODO: this only changes when we change accel rates; can we just store it per-axis until we scale accels properly?
gcode.accel_inc = (float)((float)accel * 60.0f / ACCELS_PER_SECOND);
gcode.accel_timer = ACCEL_INC_TIME;
gcode.optimized = false;
}
