unsigned char TFT::drawFloat(float floatNumber,unsigned int poX, unsigned int poY,unsigned int size,unsigned int fgcolor)
{
unsigned char decimal=2;
unsigned int temp=0;
float decy=0.0;
float rounding = 0.5;
unsigned char f=0;
if(floatNumber<0.0) /* floatNumber < 0 */
{
drawChar('-',poX, poY, size, fgcolor); /* add a '-' */
floatNumber = -floatNumber;
if(poX < MAX_X)
{
poX+=FONT_SPACE*size; /* Move cursor right */
}
f =1;
}
for (unsigned char i=0; i<decimal; ++i)
{
rounding /= 10.0;
}
floatNumber += rounding;
temp = (unsigned int)floatNumber;
unsigned char howlong=drawNumber(temp,poX, poY, size, fgcolor);
f += howlong;
if((poX+8*size*howlong) < MAX_X)
{
poX+=FONT_SPACE*size*howlong; /* Move cursor right */
}
if(decimal>0)
{
drawChar('.',poX, poY, size, fgcolor);
if(poX < MAX_X)
{
poX += FONT_SPACE*size; /* Move cursor right */
}
f +=1;
}
decy = floatNumber-temp; /* decimal part, */
for(unsigned char i=0;i<decimal;i++)
{
decy *=10; /* for the next decimal */
temp = decy; /* get the decimal */
drawNumber(temp,poX, poY, size, fgcolor);
floatNumber = -floatNumber;
if(poX < MAX_X)
{
poX += FONT_SPACE*size; /* Move cursor right */
}
decy -= temp;
}
f += decimal;
return f;
}
INT8U TFT::drawFloat(float floatNumber,INT16U poX, INT16U poY,INT16U size,INT16U fgcolor)
{
INT8U decimal=2;
INT16U temp=0;
float decy=0.0;
float rounding = 0.5;
INT8U f=0;
if(floatNumber<0.0) /* floatNumber < 0 */
{
drawChar('-',poX, poY, size, fgcolor); /* add a '-' */
floatNumber = -floatNumber;
if(poX < MAX_X)
{
poX+=FONT_SPACE*size; /* Move cursor right */
}
f =1;
}
for (INT8U i=0; i<decimal; ++i)
{
rounding /= 10.0;
}
floatNumber += rounding;
temp = (INT16U)floatNumber;
INT8U howlong=drawNumber(temp,poX, poY, size, fgcolor);
f += howlong;
if((poX+8*size*howlong) < MAX_X)
{
poX+=FONT_SPACE*size*howlong; /* Move cursor right */
}
if(decimal>0)
{
drawChar('.',poX, poY, size, fgcolor);
if(poX < MAX_X)
{
poX += FONT_SPACE*size; /* Move cursor right */
}
f +=1;
}
decy = floatNumber-temp; /* decimal part, */
for(INT8U i=0;i<decimal;i++)
{
decy *=10; /* for the next decimal */
temp = decy; /* get the decimal */
drawNumber(temp,poX, poY, size, fgcolor);
floatNumber = -floatNumber;
if(poX < MAX_X)
{
poX += FONT_SPACE*size; /* Move cursor right */
}
decy -= temp;
}
f += decimal;
return f;
}
void GameMenu::drawScore(GameScoreType score, GameScoreType total, const Common::Rect &scoreBounds, Surface *numbers) {
CoordType x = scoreBounds.right;
drawNumber(total, x, scoreBounds.top, numbers);
x -= 12;
Common::Rect r1(120, 0, 132, 12); // The slash.
Common::Rect r2 = r1;
r2.moveTo(x, scoreBounds.top);
numbers->copyToCurrentPort(r1, r2);
drawNumber(score, x, scoreBounds.top, numbers);
}
void DIGITAL_drawBackground(struct tm *t)
{
drawDate(t);
/* Initialize the current time */
drawNumber(t->tm_hour, TIME_ROW, HOUR_COL);
drawNumber(t->tm_min, TIME_ROW, MINUTE_COL);
drawNumber(t->tm_sec, TIME_ROW, SECOND_COL);
GUI_DispStringAt(":", 6 * 8, TIME_ROW);
GUI_DispStringAt(":", 9 * 8, TIME_ROW);
}
void Pong::drawTimer(int time)
{
time = (time - 45) * -1; // the time sent is starting at 0. this makes it look like a countdown,
//rather than it counting up
div_t timeSplit = div(time, 10);
if (timeSplit.quot > 0)
{
drawNumber(timeSplit.quot, TIMER_TENS);
}
drawNumber(timeSplit.rem, TIMER_ONES);
}
/*********************************************
* GAME :: DRAW
* Draw everything on the screen
*********************************************/
void Game :: draw(const Interface & ui)
{
lander.draw();
if (lander.isLanded())
{
drawText(Point(), "You have successfully landed!");
}
if (!lander.isAlive())
{
drawText(Point(), "You have crashed!");
}
if (lander.canThrust())
{
drawLanderFlames(lander.getPoint(), ui.isDown(), ui.isLeft(), ui.isRight());
}
Point fuelLocation;
fuelLocation.setX(topLeft.getX() + 5);
fuelLocation.setY(topLeft.getY() - 5);
drawNumber(fuelLocation, lander.getFuel());
// draw ground
ground.draw();
}
void StackLayout::processLine(uint8_t *pixelData, int dataOffset)
{
if (itemNr < 0)
return;
if (itemScanLine >= getItemHeight(itemNr)) {
itemScanLine = 0;
if (--itemNr < 0)
return;
currentNumberWidth = getNumberWidth(itemNr + firstLevelVisible);
}
DisplayItem *item = NULL;
if (itemNr < getItems().getLength())
item = getItems().getAt(itemNr);
if (itemScanLine == 0 && item) {
if (drawOffsetX <= item->getX())
item->initLineScanning(0, 0, drawWidth - item->getX());
else
item->initLineScanning(0, drawOffsetX - item->getX(), drawWidth);
}
if (itemNr > 0)
drawNumber(pixelData, dataOffset, itemNr + firstLevelVisible);
if (item != NULL && isItemVisible(item)) {
if (itemScanLine < item->getHeight()) {
if (drawOffsetX <= item->getX())
item->processLine(pixelData, dataOffset + item->getX() - drawOffsetX);
else
item->processLine(pixelData, dataOffset);
}
}
itemScanLine++;
}
void CSVRenderer::drawBar(CSVElement *csvElement, int idx) {
CSVDST cdst, cdst_next;
CSVSRC csrc;
// get Object
CSVSelectData *current = CSVSelectList::getSongData(idx - csvElement->parent->barCenter);
if (!current)
return;
// get DSTs
if (!(csvElement->getDSTBar(&cdst, idx) && (csvElement->getDSTBar(&cdst_next, idx+1)))) {
return;
}
// morphing X/Y coordination
double a = CSVSelectList::moveProgress;
cdst.setDSTX( cdst.getX() * (1-a)
+ cdst_next.getX() * a );
cdst.setDSTY( cdst.getY() * (1-a)
+ cdst_next.getY() * a );
// search BAR_BODY for SRC
csvElement->srcNum = current->type;
csvElement->getSRC(&csrc);
// draw bar
drawFunc(csvElement->src[csvElement->srcNum]->getImgNum(), 0, &csrc, &cdst);
// draw BAR_FLASH
// - this implemented in drawElement
// draw BAR_LEVEL
// only draws when type == SONG
if (current->type == CSVSelectType::SONG) {
CSVElement *cele_level = csvElement->parent->csvBarLevel;
if (cele_level) {
cele_level->srcNum = cele_level->dstNum = current->songData.difficulty; // 0 means NONE
cele_level->dstOffsetX = cdst.getX();
cele_level->dstOffsetY = cdst.getY();
drawNumber(cele_level, current->songData.level);
}
}
// draw BAR_LAMP
// draw BAR_MY_LAMP
// draw BAR_RIVAL_LAMP
// draws BAR_TITLE
for (int i=0; i<csvElement->parent->csvBarTitle.size(); i++) {
CSVElement *cele_title = csvElement->parent->csvBarTitle[i];
cele_title->dstOffsetX = cdst.getX();
cele_title->dstOffsetY = cdst.getY();
drawText(cele_title, current->songData.title.c_str());
}
// restore everything to default
csvElement->srcNum = 0;
}
//////////////////////////////////////////////////////////////////
// drawMenu
//
//
//
// Returns:
// void
//
void drawMenu() {
u8* pvmem;
cpct_waitVSYNC();
cpct_memset(CPCT_VMEM_START, cpct_px2byteM0(0, 0), 0x4000);
//Small Logo
pvmem = cpct_getScreenPtr(CPCT_VMEM_START, 23, 0);
cpct_drawSprite(logo_micro, pvmem, 5, 18);
drawText("AMSTHREES", 30, 4, 0);
// Session Highest Card
drawText("SESSION", 1, 57, 0);
drawText("HIGH", 5, 72, 0);
pvmem = cpct_getScreenPtr(CPCT_VMEM_START, 7, 92);
cpct_drawSprite(cards[highestCardAll], pvmem, CARD_W, CARD_H);
drawFrame(23, 43, 76, 151);
//Camelot Mode Badgae
if (camelotMode) {
pvmem = cpct_getScreenPtr(CPCT_VMEM_START, 80 - G_CAMELOTBADGE_W, 8);
cpct_drawSpriteMaskedAlignedTable(g_camelotBadge, pvmem, G_CAMELOTBADGE_W, G_CAMELOTBADGE_H, am_tablatrans);
}
drawText("REDEFINE", 38, 60, 0);
drawText("MUSIC", 38, 80, 0);
if (playing)
drawText("OFF", 56, 80, 0);
else
drawText("ON", 56, 80, 0);
drawText("HELP", 38, 100, 0);
drawText("PLAY", 38, 120, 0);
drawNumber(1, 1, 31, 60);
drawNumber(2, 1, 31, 80);
drawNumber(3, 1, 31, 100);
drawNumber(4, 1, 31, 120);
drawText("JOHN LOBO", 25, 170, 1);
drawText("@ GLASNOST CORP 2016", 11, 185, 1);
drawMarker();
}
void dibPunto::procesFile(Document_Interface *doc)
{
QString sep;
QMessageBox::information(this, "Info", "dibpunto procesFile");
currDoc = doc;
//Warning, can change adding or reordering "formatedit"
QString::SplitBehavior skip = QString::KeepEmptyParts;
switch (formatedit->currentIndex()) {
case 0:
sep = " ";
break;
case 3:
sep = " ";
skip = QString::SkipEmptyParts;
break;
case 2:
sep = ",";
break;
default:
sep = "\t";
}
if (!QFile::exists(fileedit->text()) ) {
QMessageBox::critical ( this, "DibPunto", QString(tr("The file %1 not exist")).arg(fileedit->text()) );
return;
}
QFile infile(fileedit->text());
if (!infile.open(QIODevice::ReadOnly | QIODevice::Text)) {
QMessageBox::critical ( this, "DibPunto", QString(tr("Can't open the file %1")).arg(fileedit->text()) );
return;
}
//Warning, can change adding or reordering "formatedit"
if (formatedit->currentIndex() == 4)
procesfileODB(&infile, sep);
else
procesfileNormal(&infile, sep, skip);
infile.close ();
QString currlay = currDoc->getCurrentLayer();
if (pt2d->checkOn() == true)
draw2D();
if (pt3d->checkOn() == true)
draw3D();
if (ptelev->checkOn() == true)
drawElev();
if (ptnumber->checkOn() == true)
drawNumber();
if (ptcode->checkOn() == true)
drawCode();
currDoc->setLayer(currlay);
/* draw lines in current layer */
if ( connectPoints->isChecked() )
drawLine();
currDoc = NULL;
}
void Hruler::drawMarks(QPainter& p)
{
p.setBrush(Qt::black);
p.setPen(Qt::black);
//p.drawLine(0, 16, width(), 16);
double sc = Scaling;
double cc = width() / sc;
double firstMark = ceil(offs / iter) * iter - offs;
while (firstMark < cc)
{
p.drawLine(qRound(firstMark * sc), 13, qRound(firstMark * sc), 16);
firstMark += iter;
}
firstMark = ceil(offs / iter2) * iter2 - offs;
int markC = static_cast<int>(ceil(offs / iter2));
QString tx;
double xl, frac;
while (firstMark < cc)
{
p.drawLine(qRound(firstMark * sc), topline + 5, qRound(firstMark * sc), 16);
switch (m_doc->unitIndex())
{
case SC_MM:
tx = QString::number(markC * iter2 / (iter2 / 100) / cor);
break;
case SC_IN:
xl = (markC * iter2 / iter2) / cor;
tx = QString::number(static_cast<int>(xl));
frac = fabs(xl - static_cast<int>(xl));
if ((static_cast<int>(xl) == 0) && (frac > 0.1))
tx = "";
if ((frac > 0.24) && (frac < 0.26))
tx += QChar(0xBC);
if ((frac > 0.49) && (frac < 0.51))
tx += QChar(0xBD);
if ((frac > 0.74) && (frac < 0.76))
tx += QChar(0xBE);
tx = tx;
break;
case SC_P:
case SC_C:
tx = QString::number(markC * iter2 / (iter2 / 5) / cor);
break;
case SC_CM:
tx = QString::number(markC * iter2 / iter2 / cor);
break;
default:
tx = QString::number(markC * iter2);
break;
}
drawNumber(tx, qRound(firstMark * sc) + 2, 9, p);
//p.drawText(qRound(firstMark * sc)+2, 9, tx);
firstMark += iter2;
markC++;
}
}
void ScenePause::draw()
{
m_sp1P->Draw(m_sp1P->_pos);
m_spHi->Draw(m_spHi->_pos);
m_spBadge->Draw(m_spBadge->_pos);
m_spRest->Draw(m_spRest->_pos);
m_spStage->Draw(m_spStage->_pos);
m_spNameStage->Draw(m_spNameStage->_pos);
m_spTitle->Draw(m_spTitle->_pos);
// ve so
int delta = m_timeCount % 15;
if (m_timeCount % 15 > 4 && m_timeCount % 15 < 15)
{
drawNumber(to_string(m_resource->m_numScore), 100, 25);
drawNumber(to_string(m_resource->m_highScore), 110, 75);
drawNumber(to_string(m_resource->m_life), 70, 45);
}
// ve hieu ung button
if (!m_checkItem)
{
m_spConti->Draw(m_spConti->_pos);
m_spEnd->Draw(m_spEnd->_pos);
}
else
{
if (m_curItem == Item1)
{
m_spEnd->Draw(m_spEnd->_pos);
if (m_timeDuring % 15 > 5 && m_timeDuring % 15 < 10)
{
m_spConti->Draw(m_spConti->_pos);
}
}
else if (m_curItem == Item2)
{
m_spConti->Draw(m_spConti->_pos);
if (m_timeDuring % 15 > 5 && m_timeDuring % 15 < 10)
{
m_spEnd->Draw(m_spEnd->_pos);
}
}
}
}
void GraduationView::paintEvent(QPaintEvent *)
{
QPainter painter(this);
dimg->setImage(dimg->getImageOriginal()->scaled(this->width()-ADJUSTEMENT,this->height()-ADJUSTEMENT));
dimg->updateImage(rampEditor);
painter.drawImage(MARGIN+1,MARGIN,*dimg->getImage());
drawMillimeter(&painter);
drawNumber(&painter);
}
void Pong::drawScore(int right, int left) // draws the score of each paddle in their respective field halves
{
div_t rightDiv = div(right, 10);
div_t leftDiv = div(left, 10);
if (rightDiv.quot > 0)
{
drawNumber((int)rightDiv.quot, RIGHT_TENS);
}
drawNumber((int)rightDiv.rem, RIGHT_ONES);
if (leftDiv.quot > 0)
{
drawNumber((int)leftDiv.quot, LEFT_TENS);
}
drawNumber((int)leftDiv.rem, LEFT_ONES);
}
void updateTopScore() {
drawNumber(COORDS(5, 1), hiScores[0].score);
drawChar(COORDS(1, 39), hiScores[0].name[0]);
drawChar(COORDS(4, 39), hiScores[0].name[1]);
drawChar(COORDS(7, 39), hiScores[0].name[2]);
drawChar(COORDS(10, 39), hiScores[0].name[3]);
drawChar(COORDS(12, 39), hiScores[0].name[4]);
drawChar(COORDS(14, 39), hiScores[0].name[5]);
}
/** Draws a digital watch */
static DrawLimits drawWatchFace(struct tm *t)
{
DrawLimits ret = getDrawingLimits(t);
if ( lastTime.tm_yday != t->tm_yday ) {
/* Date changed, update everything */
FB_clearBuffer();
DIGITAL_drawBackground(t);
}
drawNumber(t->tm_sec, TIME_ROW, SECOND_COL);
drawNumber(t->tm_min, TIME_ROW, MINUTE_COL);
drawNumber(t->tm_hour, TIME_ROW, HOUR_COL);
/* Save the rendered time */
lastTime = *t;
return ret;
}
/*************************************************
* PONG : DRAW
* Draw the stuff
************************************************/
void Pong::draw()
{
// draw the ball and the paddle
drawRect(paddle, 2, PADDLE * 2, 0);
// draw the ball
if (!dead)
drawCircle(ball, 8);
// draw the score
Point point(ball.getXMin() + 5, ball.getYMax() - 5);
drawNumber(point, score);
}
static void drawResult(void)
{
/* Score */
arduboy.setTextSize(2);
int dx = 59;
uint32_t dummy = score;
while (dummy >= 10) {
dummy /= 10;
dx -= 6;
}
drawNumber(dx, 0, score);
arduboy.setTextSize(1);
/* Each die */
uint32_t totalErasedDice = 0;
for (int i = 0; i < 6; i++) {
int dx = (i % 3) * 30 + 37;
int dy = (i / 3) * 6 + 38;
arduboy.drawBitmap(dx, dy, imgMiniDie[i], 5, 5, WHITE);
drawNumber(dx + 6, dy, min(erasedEachDie[i], EACHDIE_MAX));
totalErasedDice += erasedEachDie[i];
}
/* Others */
arduboy.printEx(1, 14, F("LEVEL"));
arduboy.printEx(1, 20, F("MAX CHAIN"));
arduboy.printEx(1, 26, F("PLAY TIME"));
arduboy.printEx(1, 32, F("ERASED DICE"));
if (gameMode == GAME_MODE_ENDLESS) {
drawNumber(73, 14, level);
} else {
arduboy.printEx(73, 14, F("--"));
}
drawNumber(73, 20, maxChain);
drawTime(73, 26, gameFrames);
drawNumber(73, 32, totalErasedDice);
}
void GLWidget::paintGL()
{
glClearColor(0.847f, 0.749f, 0.847f, 0.0f); //background color
glClear(GL_COLOR_BUFFER_BIT);
glLoadIdentity();
//Background
glColor3f(0.502f, 0.000f, 0.502f);
drawCircle(200);
glColor3f(0.0f, 0.0f, 0.0f);
glScaled(0.8,0.8,1);
drawCircle(200);
glColor3f(0.980f, 0.502f, 0.447f);
drawNumber();
//Second Hand
glLoadIdentity();
glColor3f(0.980f, 0.502f, 0.447f);
glRotated(-6*sec,0,0,1);
drawRec(160,1);
//Minute Hand
glLoadIdentity();
glColor3f(0.980f, 0.502f, 0.447f);
glRotated(-6*min,0,0,1);
drawRec(170,5);
//Hour Hand
glLoadIdentity();
glColor3f(0.980f, 0.502f, 0.447f);
glRotated(-30*hour-0.5*min,0,0,1);
drawRec(130,8);
//Center dot
glLoadIdentity();
glColor3f(0.502f, 0.000f, 0.502f);
drawCircle(10);
// glPushMatrix();
// glPopMatrix();
}
/**
* drawPoints
* Zeichnen der bis zu dem Zeitpunkt erreichten Punktzahl.
*/
void
GameWorld::drawPoints() {
CMatrix * modelview = getModelView();
modelview->Push();
modelview->Translate(1.8,4.2,0.0);
drawNumber(getGameState()->getPoints());
modelview->Pop();
/*glPushMatrix();
glTranslatef(0.8,2.2,0.0);
drawNumber(getGameState()->getPoints());
glPopMatrix();*/
}
int drawNumberString(gdImagePtr im, char* buffer, int x, int y, int color, bool doDraw)
{
char c;
int offsetX = 0;
int i = 0;
while((c = buffer[i]) != 0)
{
int number = c - ZERO_CHAR;
if(c == ':')
{
number = 10;
offsetX -= 2;
}
if(c == '1')
{
offsetX -= 1;
}
if(number < 0 || number > 10)
number = 0;
if(doDraw)
drawNumber(im, number, offsetX + x, y, color);
switch(c)
{
case ':':
offsetX += 4;
break;
default:
offsetX += 6;
break;
}
i++;
}
return offsetX;
}
int main()
{
WidgetTable.init();
clearScreen();
Packet p;
while (1)
{
interpret();
drawNumber(4, 207,counter, CYAN);
++counter;
}
return 0;
}
void LayoutPulseCounter::draw(GMCounterBase* data, layoutConfig_t& conf)
{
itsDisplay.clearDisplay();
// show legend
uint8_t pulseValue = data->getSample(0U);
drawNumber(pulseValue, 0U, 0U);
drawText(conf.pulseConfig.pulseLabel, 18U, 0U);
// TODO: dirty hack, we want to show value only when
// showing graph for pulses per minute.
if(conf.pulseConfig.doseLabel != "")
{
// TODO use a wrapper for writting numbers
float doseValue = data->getDose();
itsDisplay.setTextSize(0);
itsDisplay.setTextColor(BLACK);
itsDisplay.setCursor(36, 0);
itsDisplay.print(doseValue);
drawText(conf.pulseConfig.doseLabel, 59U, 0U);
}
// show graph
const uint8_t graphHeight = 40U;
sample_t maxValue = data->getMaxSampleValue();
for (uint16_t i = 0U; (i < data->getSampleCount()) && (i < LCDWIDTH); i++)
{
sample_t sampleValue = data->getSample(i);
// data normalization
sampleValue = uint8_t( (float(sampleValue) / float(maxValue)) *graphHeight);
const uint16_t x = LCDWIDTH - i - 1U;
itsDisplay.drawLine(x, itsDisplay.height(), x, itsDisplay.height() - sampleValue, BLACK);
}
itsDisplay.display();
}
void drawScore(uint score) {
uchar n;
drawNumber(COORDS(67, 1), score);
if(score < hiScores[0].score) n = (score / (hiScores[0].score / 6));
else n = 7;
if(playerSpriteTop != n) {
playerSpriteTop = n;
waitHorzSync();
if(n > 6) { superDraw(COORDS(63, 6), 0, 23, 7, rightSprite, 17, 17); n=1; }
else { superDraw(COORDS(63, 6), 6-n, 23, n, gameScreen + 63 + 12*80, 17, 80); n=0; }
if(kingSprite != n) {
kingSprite = n;
if(n) superDraw(COORDS(0, 6), 5, 16, 0, leftSprite, 18, 18);
else superDraw(COORDS(0, 6), 0, 21, 0, gameScreen + 0 + 6*80, 18, 80);
}
}
}
static void drawIssues(void)
{
arduboy.printEx(34, 0, F("[ PUZZLE ]"));
for (int i = 0; i <= COUNT_ISSUES; i++) {
int dx = i % 5 * 24 + 10, dy = i / 5 * 6 + 8;
if (i == issue) {
dx -= 4;
arduboy.fillRect(dx - 6, dy, 5, 5, WHITE);
}
if (i == COUNT_ISSUES) {
arduboy.printEx(dx, dy, F("BACK TO TITLE"));
} else {
drawNumber(dx, dy, i + 1);
if (record.puzzleClearFlag[i / 8] & 1 << i % 8) {
arduboy.drawFastHLine(dx - 2, dy + 2, 15 - (i < 9) * 6, WHITE);
}
}
}
drawSoundEnabled();
}
/**
* drawEndPoints
* Zeichnen der erreichten Endpunktzahl.
*/
void
GameWorld::drawEndPoints() {
CMatrix * modelview = getModelView();
modelview->Push();
modelview->Translate(-0.1,2.0,0.0);
modelview->Scale(1.5,1.5,1.5);
drawNumber(getGameState()->getPoints());
modelview->Pop();
/*
glPushMatrix();
glTranslatef(-0.1,1.3,0.0);
glScalef(1.5,1.5,1.5);
drawNumber(getGameState()->getPoints());
glPopMatrix();
*/
}
/******************************************************************
* Score::draw()
* Draws the user and computers scores on the screen! Excellent!
* Calls a function in uiDraw.h to do this for us.
*****************************************************************/
void Score::draw()
{
char multiplier = 0;
if (score[HIT] > 9 && score[HIT] < 100)
multiplier = 1;
else if (score[HIT] > 99 && score[HIT] < 1000)
multiplier = 2;
else if (score[HIT] > 999 && score[HIT] < 10000)
multiplier = 3;
else if (score[HIT] > 9999 && score[HIT] < 100000)
multiplier = 4;
hitPos.setX(hitPos.getXMax() - (12 + (11 * multiplier)));
glColor3ub(0, 255, 0);
drawNumber(hitPos, score[HIT]);
glColor3ub(255, 255, 255);
return;
}
//////////////////////////////////////////////////////////////////
// drawScore
//
//
//
// Returns:
// void
//
void drawScore() {
u8 i, j, z;
u8 x, y;
u32 partialScore;
for (i = 0; i < 4; i++) {
y = 4 + (i * 48);
for (j = 0; j < 4; j++) {
x = 6 + (j * 12);
z = cells[i][j];
if (z >= 3) {
if (z == 3) {
partialScore = 1;
} else {
partialScore = scores[z];
}
score += partialScore;
drawNumber(partialScore, 4, x - 3, y);
}
}
}
}
/**
* drawTime
* Zeichnen der Zeit.
*/
void
GameWorld::drawTime() {
int time = getGameState()->getTime();
if(time >= 0) {
CMatrix * modelview = getModelView();
modelview->Push();
modelview->Translate(-2.0,4.2,0.0);
drawNumber(time);
modelview->Pop();
/*
glPushMatrix();
glTranslatef(-1.0,2.2,0.0);
drawNumber(time);
glPopMatrix();
*/
}
}
void *inputCheck(void *data) {
// Variables to be assigned values
extern int frequency[];
extern float amplitude[];
extern float timeDiv;
extern int triggerLevel;
extern int voltageDiv;
extern int waveType[2];
extern int offset;
extern int menu;
extern int mode;
//Stores latest value of buttons
int latestValue[4];
//Stores previous values for buttons
int previousValue[4] = { 1, 1, 1, 1 };
while (!gShouldStop) {
//Handles Scroll Button Input
if (is_high(scrollButton))
latestValue[0] = 1;
else
latestValue[0] = 0;
//Cycles through menu
if (latestValue[0] == 0 && previousValue[0] == 1) {
if (mode == -1) {
menu++;
menu %= 3;
memcpy(displayBuffer, &menuBuffer[menu], 1024);
}
}
previousValue[0] = latestValue[0];
//Handles Select Button Input
if (is_high(selectButton))
latestValue[1] = 1;
else
latestValue[1] = 0;
if (latestValue[1] == 0 && previousValue[1] == 1) {
//Selects menu or goes back to menu
if (mode == -1) {
if (menu == 0) {
mode = 0;
memcpy(displayBuffer, &oscilliscopeBuffer, 1024);
} else if (menu == 1) {
mode = 1;
memcpy(displayBuffer, &signalGenBuffer, 1024);
} else if (menu == 2) {
mode = 2;
memcpy(displayBuffer, &aboutBuffer, 1024);
}
} else {
mode = -1;
memcpy(displayBuffer, &menuBuffer[menu], 1024);
}
}
previousValue[1] = latestValue[1];
//Handles Wave Type For Channel 1 or Offset for oscilloscope
if (is_high(button1))
latestValue[2] = 1;
else
latestValue[2] = 0;
if (latestValue[2] == 0 && previousValue[2] == 1) {
if (mode == 1) {
if (waveType[0] == 0) {
waveType[0] = 1;
drawCross(26, 57, 0);
drawCross(58, 57, 1);
} else if (waveType[0] == 1) {
waveType[0] = 2;
drawCross(26, 57, 0);
drawCross(58, 57, 0);
} else {
waveType[0] = 0;
drawCross(26, 57, 1);
}
} else if (mode == 0) {
offset++;
if (offset > 30)
offset = 30;
}
}
previousValue[2] = latestValue[2];
//Handles Wave Type For Channel 2 or Offset for oscilloscope
if (is_high(button2))
latestValue[3] = 1;
else
latestValue[3] = 0;
if (latestValue[3] == 0 && previousValue[3] == 1) {
if (mode == 1) {
if (waveType[1] == 0) {
waveType[1] = 1;
drawCross(89, 57, 0);
drawCross(121, 57, 1);
} else if (waveType[1] == 1) {
waveType[1] = 2;
drawCross(89, 57, 0);
drawCross(121, 57, 0);
} else {
waveType[1] = 0;
drawCross(89, 57, 1);
}
} else if (mode == 0) {
offset--;
if (offset < 1)
offset = 1;
}
}
previousValue[3] = latestValue[3];
//Retrieves 10 analouge samples
BBBIO_work(10);
//Averages the retrieved smaples
int sampleAverage[5] = { 0, 0, 0, 0, 0 };
for (int n = 0; n < 10; n++) {
for (int m = 0; m < 5; m++) {
sampleAverage[m] += analougeInputs[m][n];
}
}
for (int n = 0; n < 5; n++)
sampleAverage[n] /= 10;
//End of averaging
//checks if device in oscilliscope mode
if (mode == 0) {
triggerLevel = 1 + (sampleAverage[2] * (62 - 1) / 4096); // Normalises trigger level to between 1 and 62
voltageDiv = 1 + (sampleAverage[1] * (5 - 1) / 4096); // normalise to between 0 and 5 for voltage division
sampleAverage[0] = (sampleAverage[0] * 6 / 4096); // normalise to between 0 and 6 for time divisions
//10 pixels per division hence sampleSkip=sampleRate X timeDiv /10
switch (sampleAverage[0]) {
case 0:
timeDiv = 0.1; //0.1mS
sampleSkip = 1; //0.96
break;
case 1:
timeDiv = 0.5; //0.5mS
sampleSkip = 5; //4.8
break;
case 2:
timeDiv = 1; //1mS
sampleSkip = 10; //9.6
break;
case 3:
timeDiv = 2; //2mS
sampleSkip = 19; //19.2
break;
case 4:
timeDiv = 5; //5mS
sampleSkip = 48; //48
break;
case 5:
timeDiv = 10; //10mS
sampleSkip = 96; //96
break;
}
printf(
"\rTime Div = %.1f mS, Voltage Div = %.2f v,TriggerLevel= %d ",
timeDiv, (float) voltageDiv / 4, triggerLevel);
fflush(stdout);
//Checks if device in signal generator mode
} else if (mode == 1) {
frequency[0] = ((50 + (sampleAverage[3] * (20000 - 50) / 4096)) / 50
* 50); // normalise to 50-20000 and assigns to frequency1
frequency[1] = ((50 + (sampleAverage[4] * (20000 - 50) / 4096)) / 50
* 50); // normalise to 50-20000 and assigns to frequency2
drawNumber(18, 19, frequency[0], 4);
drawNumber(82, 19, frequency[1], 4);
amplitude[0] = (float) sampleAverage[1] / 4096;
amplitude[1] = (float) sampleAverage[2] / 4096;
drawNumber(42, 30, sampleAverage[1] * (100) / 4096, 1);
drawNumber(106, 30, sampleAverage[2] * (100) / 4096, 1);
}
updateDisplay();
usleep(30000);
}
pthread_exit(NULL);
}
