static void draw_image(SkCanvas* canvas, bool showGL, int flags) {
SkPaint paint;
paint.setAntiAlias(true);
paint.setFilterBitmap(true);
setFade(&paint, showGL);
static SkBitmap* gBM;
if (NULL == gBM) {
gBM = new SkBitmap;
SkImageDecoder::DecodeFile("/skimages/startrek.png", gBM);
}
SkRect r = SkRect::MakeWH(gBM->width(), gBM->height());
canvas->save();
canvas->translate(30, 30);
canvas->scale(0.8f, 0.8f);
canvas->drawBitmap(*gBM, 0, 0, &paint);
if (showGL) {
show_mesh(canvas, r);
}
canvas->restore();
canvas->translate(210, 290);
canvas->rotate(-35);
canvas->drawBitmap(*gBM, 0, 0, &paint);
if (showGL) {
show_mesh(canvas, r);
}
}
static void draw_text(SkCanvas* canvas, bool showGL, int flags) {
SkPaint paint;
paint.setAntiAlias(true);
paint.setLCDRenderText(true);
const char text[] = "Graphics at Google";
size_t len = strlen(text);
setFade(&paint, showGL);
canvas->translate(40, 50);
for (int i = 0; i < 10; ++i) {
paint.setTextSize(12 + i * 3);
canvas->drawText(text, len, 0, 0, paint);
if (showGL) {
SkRect bounds[256];
SkScalar widths[256];
int count = paint.getTextWidths(text, len, widths, bounds);
SkScalar adv = 0;
for (int j = 0; j < count; ++j) {
bounds[j].offset(adv, 0);
show_mesh(canvas, bounds[j]);
adv += widths[j];
}
}
canvas->translate(0, paint.getTextSize() * 3 / 2);
}
}
static void draw_rect(SkCanvas* canvas, bool showGL, int flags) {
SkPaint paint;
paint.setAntiAlias(true);
SkRect r = SkRect::MakeLTRB(50, 70, 250, 370);
setFade(&paint, showGL);
canvas->drawRect(r, paint);
if (showGL) {
show_mesh(canvas, r);
}
canvas->translate(320, 0);
paint.setStyle(SkPaint::kStroke_Style);
paint.setStrokeWidth(25);
canvas->drawRect(r, paint);
if (showGL) {
SkScalar rad = paint.getStrokeWidth() / 2;
SkPoint pts[8];
r.outset(rad, rad);
r.toQuad(&pts[0]);
r.inset(rad*2, rad*2);
r.toQuad(&pts[4]);
const uint16_t indices[] = {
0, 4, 1, 5, 2, 6, 3, 7, 0, 4
};
show_mesh(canvas, pts, indices, SK_ARRAY_COUNT(indices));
}
}
void PGE_QuestionBox::processBox(float)
{
#ifndef __APPLE__
if(AppSettings.interprocessing)
qApp->processEvents();
#endif
SDL_Event event;
while ( SDL_PollEvent(&event) )
{
PGE_Window::processEvents(event);
switch(event.type)
{
case SDL_QUIT:
reject();
break;
case SDL_KEYDOWN: // If pressed key
processKeyEvent(event.key.keysym.sym);
break;
default:
break;
}
}
if(_menu.isSelected())
{
if(_menu.isAccepted())
_answer_id = _menu.currentItemI();
else
_answer_id = -1;
_page++; setFade(10, 0.0f, 0.05f);return;
}
}
ImageItem::ImageItem(const QPixmap & img,const QString & infotext, QWidget * parent) :
QWidget(parent,Qt::FramelessWindowHint),
mFade(0),
mIsAnimationFinished(true),
mPixmapOrig(img)
{
resize(parent->size());
setFade(mFade);
}
void PGE_QuestionBox::update(float ticks)
{
switch(_page)
{
case 0: setFade(10, 1.0f, 0.05f); _page++; break;
case 1: processLoader(ticks); break;
case 2: processBox(ticks); break;
case 3: processUnLoader(ticks); break;
case 4:
default: running=false; break;
}
}
static void draw_line(SkCanvas* canvas, bool showGL, int flags) {
SkPaint paint;
paint.setAntiAlias(true);
if (showGL) {
setGLFrame(&paint);
}
canvas->drawLine(50, 50, 400, 100, paint);
paint.setColor(SK_ColorBLACK);
canvas->rotate(40);
setFade(&paint, showGL);
paint.setStrokeWidth(40);
canvas->drawLine(100, 50, 450, 50, paint);
if (showGL) {
show_mesh(canvas, SkRect::MakeLTRB(100, 50-20, 450, 50+20));
}
}
void ContextWidget::updateImage(QImage img, bool created)
{
DBUG << img.isNull() << currentBackdrop.isNull();
oldBackdrop=currentBackdrop;
oldIsAlbumCoverBackdrop=albumCoverBackdrop;
currentBackdrop=QPixmap();
animator.stop();
if (img.isNull() && oldBackdrop.isNull()) {
return;
}
if (img.isNull()) {
currentImage=img;
} else {
if (backdropOpacity<100) {
img=TreeView::setOpacity(img, (backdropOpacity*1.0)/100.0);
}
if (backdropBlur>0) {
QImage blurred(img.size(), QImage::Format_ARGB32_Premultiplied);
blurred.fill(Qt::transparent);
QPainter painter(&blurred);
qt_blurImage(&painter, img, backdropBlur, true, false);
painter.end();
img = blurred;
}
#ifdef SCALE_CONTEXT_BGND
currentImage=img;
#else
currentBackdrop=QPixmap::fromImage(img);
#endif
}
albumCoverBackdrop=created;
resizeBackdrop();
animator.stop();
if (PlayQueueView::BI_Custom==backdropType || !isVisible()) {
setFade(1.0);
} else {
fadeValue=0.0;
animator.setDuration(250);
animator.setEndValue(1.0);
animator.start();
}
}
static void draw_oval(SkCanvas* canvas, bool showGL, int flags) {
SkPaint paint;
paint.setAntiAlias(true);
SkRect r = SkRect::MakeLTRB(50, 70, 250, 370);
setFade(&paint, showGL);
canvas->drawOval(r, paint);
if (showGL) {
switch (flags) {
case 0: {
SkPath path;
path.addOval(r);
show_glframe(canvas, path);
} break;
case 1:
case 3: {
SkPath src, dst;
src.addOval(r);
tesselate(src, &dst);
show_fan(canvas, dst, r.centerX(), r.centerY());
} break;
case 2: {
SkPaint p(paint);
show_mesh(canvas, r);
setGLFrame(&p);
paint.setStyle(SkPaint::kFill_Style);
canvas->drawCircle(r.centerX(), r.centerY(), 3, p);
} break;
}
}
canvas->translate(320, 0);
paint.setStyle(SkPaint::kStroke_Style);
paint.setStrokeWidth(25);
canvas->drawOval(r, paint);
if (showGL) {
switch (flags) {
case 0: {
SkPath path;
SkScalar rad = paint.getStrokeWidth() / 2;
r.outset(rad, rad);
path.addOval(r);
r.inset(rad*2, rad*2);
path.addOval(r);
show_glframe(canvas, path);
} break;
case 1: {
SkPath path0, path1;
SkScalar rad = paint.getStrokeWidth() / 2;
r.outset(rad, rad);
path0.addOval(r);
r.inset(rad*2, rad*2);
path1.addOval(r);
show_mesh_between(canvas, path0, path1);
} break;
case 2: {
SkPath path;
path.addOval(r);
show_glframe(canvas, path);
SkScalar rad = paint.getStrokeWidth() / 2;
r.outset(rad, rad);
show_mesh(canvas, r);
} break;
case 3: {
SkScalar rad = paint.getStrokeWidth() / 2;
r.outset(rad, rad);
SkPaint paint;
paint.setAlpha(0x33);
canvas->drawRect(r, paint);
show_mesh(canvas, r);
} break;
}
}
}
void GfxPalette32::fadeOff() {
setFade(100, 0, 255);
}
void PGE_QuestionBox::reject()
{
_answer_id=-1; _page++; setFade(10, 0.0f, 0.05f);
if(reject_snd>0)
PGE_Audio::playSound(reject_snd);
}
KinectScene2::KinectScene2() : ofxFadeScene("Kinect2")
{
setSingleSetup(true); // call setup each time the scene is loaded
setFade(1000, 1000); // 1 second fade in/out
bUseDepth = true;
}
void IMuseDigital::playComiMusic(const char *songName, const imuseComiTable *table, int atribPos, bool sequence) {
int hookId = 0;
if ((songName != NULL) && (atribPos != 0)) {
if (table->atribPos != 0)
atribPos = table->atribPos;
hookId = _attributes[COMI_STATE_OFFSET + atribPos];
if (table->hookId != 0) {
if ((hookId != 0) && (table->hookId > 1)) {
_attributes[COMI_STATE_OFFSET + atribPos] = 2;
} else {
_attributes[COMI_STATE_OFFSET + atribPos] = hookId + 1;
if (table->hookId < hookId + 1)
_attributes[COMI_STATE_OFFSET + atribPos] = 1;
}
}
}
switch (table->opcode) {
case 0:
fadeOutMusic(120);
break;
case 8:
case 9:
setHookId(table->soundId, table->soundId);
break;
case 1:
if (table->filename[0] == 0) {
fadeOutMusic(120);
return;
}
fadeOutMusic(120);
startMusic(table->filename, table->soundId, 0, 1);
setFade(table->soundId, 127, 120);
break;
case 2:
if (table->filename[0] == 0) {
fadeOutMusic(60);
return;
}
fadeOutMusic(table->fadeOut60TicksDelay);
startMusic(table->filename, table->soundId, table->hookId, 127);
break;
case 3:
case 4:
case 12:
if (table->filename[0] == 0) {
fadeOutMusic(60);
return;
}
fadeOutMusic(table->fadeOut60TicksDelay);
if ((!sequence) && (table->atribPos != 0) &&
(table->atribPos == _comiStateMusicTable[_curMusicState].atribPos)) {
startMusic(table->filename, table->soundId, 0, 127);
return;
}
if (table->opcode == 12) {
startMusic(table->filename, table->soundId, table->hookId, 127);
} else {
startMusic(table->filename, table->soundId, hookId, 127);
}
break;
}
}
// ---
void QGAMES::Background::initialize ()
{
// The initial values...
int fadeGrade = 255;
bool autMove = false;
QGAMES::Vector movDirection (__BD 1, __BD 0, __BD 0);
int speed = 0, pixels = 0;
QGAMES::Background* linkedBackground = NULL;
int linkedSpeed = 0;
bool roll = false;
bool fix = false;
// Has the fasdegrade property been defined?
if (existObjProperty (_FADEGRADEPROPERTY))
fadeGrade = std::stoi (objectProperty (_FADEGRADEPROPERTY));
// Has the automatic movement property been defined?
if (existObjProperty (_AUTOMATICMOVEPROPERTY))
autMove = (objectProperty (_AUTOMATICMOVEPROPERTY) ==
std::string (__YES_STRING__)) ? true : false ;
// Has the movement direction property been defined?
if (existObjProperty (_MOVDIRECTIONPROPERTY))
{
std::vector <int> cV;
std::string m = objectProperty (_MOVDIRECTIONPROPERTY);
while (m != std::string (__NULL_STRING__))
{
int cP = m.find_first_of (','); // The vector dta is separated by comma!
if (cP != -1)
{
cV.push_back (std::stoi (m.substr (0, cP)));
m = (cP != m.length () - 1)
? m.substr (cP + 1) : std::string (__NULL_STRING__);
}
else
{
cV.push_back (std::stoi (m));
m = std::string (__NULL_STRING__);
}
}
movDirection = QGAMES::Vector ((cV.size () > 0) ? __BD cV [0] : __BD 0,
(cV.size () > 1) ? __BD cV [1] : __BD 0, (cV.size () > 2) ? __BD cV [2] : __BD 0);
}
// Has the speed property been defined?
if (existObjProperty (_SPEEDPROPERTY))
speed = std::stoi (objectProperty (_SPEEDPROPERTY));
// Has the pixels property been defined?
if (existObjProperty (_PIXELSPROPERTY))
pixels = std::stoi (objectProperty (_PIXELSPROPERTY));
// Has the background linked been defined?
if (existObjProperty (_LINKEDBKPROPERTY))
{
assert (game ()); // The game has to have been defined...
linkedBackground = (QGAMES::Background*) game () -> objectBuilder () ->
object (std::stoi (objectProperty (_LINKEDBKPROPERTY)));
linkedBackground -> initialize ();
}
// Has the speed of the background linked been defined?
if (existObjProperty (_SPEEDLINKEDBKPROPERTY))
linkedSpeed = std::stoi (objectProperty (_SPEEDLINKEDBKPROPERTY));
// Has to roll?
if (existObjProperty (_ROLLPROPERTY))
roll = (objectProperty (_ROLLPROPERTY) ==
std::string (__YES_STRING__)) ? true : false ;
// The position is fixed?
if (existObjProperty (_FIXPOSITIONPROPERTY))
fix = (objectProperty (_FIXPOSITIONPROPERTY) ==
std::string (__YES_STRING__)) ? true : false ;
// The background is a mandatory attribute...
// Sets the fadegrade
setFade (fadeGrade);
// Sets the movement
setMove (autMove, movDirection);
// Sets the movement data
setMovementData (speed, pixels);
// Sets the linked background if any...
setLinkedBackground (linkedSpeed, linkedBackground);
// Sets whether it rolls or not!
setRoll (roll);
// Sets whether the position is or not fix...
setFixPosition (fix);
// Restats the counters...
reStartAllCounters ();
// Initially the position of the background is to 0...
setPosition (QGAMES::Position::_cero);
}
void PGE_TextInputBox::processBox(double tickTime)
{
PGE_BoxBase::processBox(tickTime);
bool wasExitKeyPress = m_keys.run_pressed || m_keys.alt_run_pressed || m_keys.start_pressed;
if(wasExitKeyPress)
{
if(m_keys.start_pressed || m_keys.jump_pressed || m_keys.alt_jump_pressed)
m_inputTextSrc = m_inputText;
nextPage();
setFade(10, 0.0, 0.05);
SDL_StopTextInput();
return;
}
m_blinkTimeout -= tickTime;
if(m_blinkTimeout < 0.0)
{
m_blinkShown = !m_blinkShown;
m_blinkTimeout += (tickTime < 250.0) ? 250.0 : tickTime + 250.0;
}
SDL_StartTextInput();
SDL_Event event;
while(SDL_PollEvent(&event))
{
PGE_Window::processEvents(event);
switch(event.type)
{
case SDL_QUIT:
nextPage();
setFade(10, 0.0, 0.05);
SDL_StopTextInput();
break;
case SDL_KEYDOWN: // If pressed key
{
switch(event.key.keysym.sym)
{
// Check which
case SDLK_ESCAPE: // ESC
case SDLK_RETURN:// Enter
case SDLK_KP_ENTER:
case SDLK_AC_BACK://Android "back" key
{
if(event.key.keysym.sym != SDLK_ESCAPE && event.key.keysym.sym != SDLK_AC_BACK)
m_inputTextSrc = m_inputText;
nextPage();
setFade(10, 0.0, 0.05);
SDL_StopTextInput();
break;
}
case SDLK_BACKSPACE:
{
if(m_inputText.length() > 0)
{
FontManager::utf8_pop_back(m_inputText);
updatePrintable();
}
break;
}
default:
break;
}
switch(event.key.keysym.scancode)
{
case SDL_SCANCODE_V:
{
if((event.key.keysym.mod & KMOD_CTRL) && (SDL_HasClipboardText() == SDL_TRUE))
{
m_inputText.append(SDL_GetClipboardText());
std::remove(m_inputText.begin(), m_inputText.end(), '\r');
std::replace(m_inputText.begin(), m_inputText.end(), '\n', ' ');
updatePrintable();
}
break;
}
default:
break;
}
break;
}
case SDL_TEXTINPUT:
{
D_pLogDebug("TEXT INPUT EVENT %s", event.text.text);
m_inputText.append(event.text.text);
updatePrintable();
}
break;
case SDL_TEXTEDITING:
{
D_pLogDebug("TEXT EDIT EVENT start %d, %s", event.edit.start, event.edit.text);
m_inputText = event.edit.text;
m_cursor = event.edit.start;
m_selectionLength = event.edit.length;
updatePrintable();
}
break;
// case SDL_MOUSEBUTTONDOWN:
// switch(event.button.button)
// {
// case SDL_BUTTON_LEFT:
// {
// _page++;
// setFade(10, 0.0f, 0.05f);
// }
// break;
// }
// break;
default:
break;
}
}
}
void IMuseDigital::parseScriptCmds(int cmd, int b, int c, int d, int e, int f, int g, int h) {
int soundId = b;
int sub_cmd = c;
if (!cmd)
return;
switch (cmd) {
case 10: // ImuseStopAllSounds
stopAllSounds();
break;
case 12: // ImuseSetParam
switch (sub_cmd) {
case 0x400: // select group volume
selectVolumeGroup(soundId, d);
break;
case 0x500: // set priority
setPriority(soundId, d);
break;
case 0x600: // set volume
setVolume(soundId, d);
break;
case 0x700: // set pan
setPan(soundId, d);
break;
default:
warning("IMuseDigital::doCommand SetParam DEFAULT command %d", sub_cmd);
break;
}
break;
case 14: // ImuseFadeParam
switch (sub_cmd) {
case 0x600: // set volume fading
if ((d != 0) && (e == 0))
setVolume(soundId, d);
else if ((d == 0) && (e == 0))
stopSound(soundId);
else
setFade(soundId, d, e);
break;
default:
warning("IMuseDigital::doCommand FadeParam DEFAULT sub command %d", sub_cmd);
break;
}
break;
case 25: // ImuseStartStream
debug(3, "ImuseStartStream (%d, %d, %d)", soundId, c, d);
break;
case 26: // ImuseSwitchStream
debug(3, "ImuseSwitchStream (%d, %d, %d, %d, %d)", soundId, c, d, e, f);
break;
case 0x1000: // ImuseSetState
debug(5, "ImuseSetState (%d)", b);
if ((_vm->_game.id == GID_DIG) && (_vm->_game.features & GF_DEMO)) {
if (b == 1) {
fadeOutMusic(200);
startMusic(1, 127);
} else {
if (getSoundStatus(2) == 0) {
fadeOutMusic(200);
startMusic(2, 127);
}
}
} else if ((_vm->_game.id == GID_CMI) && (_vm->_game.features & GF_DEMO)) {
if (b == 2) {
fadeOutMusic(108);
startMusic("in1.imx", 1100, 0, 127);
} else if (b == 4) {
fadeOutMusic(108);
startMusic("in2.imx", 1120, 0, 127);
} else if (b == 8) {
fadeOutMusic(108);
startMusic("out1.imx", 1140, 0, 127);
} else if (b == 9) {
fadeOutMusic(108);
startMusic("out2.imx", 1150, 0, 127);
} else if (b == 16) {
fadeOutMusic(108);
startMusic("gun.imx", 1210, 0, 127);
} else {
fadeOutMusic(120);
}
} else if (_vm->_game.id == GID_DIG) {
setDigMusicState(b);
} else if (_vm->_game.id == GID_CMI) {
setComiMusicState(b);
} else if (_vm->_game.id == GID_FT) {
setFtMusicState(b);
}
break;
case 0x1001: // ImuseSetSequence
debug(5, "ImuseSetSequence (%d)", b);
if (_vm->_game.id == GID_DIG) {
setDigMusicSequence(b);
} else if (_vm->_game.id == GID_CMI) {
setComiMusicSequence(b);
} else if (_vm->_game.id == GID_FT) {
setFtMusicSequence(b);
}
break;
case 0x1002: // ImuseSetCuePoint
debug(5, "ImuseSetCuePoint (%d)", b);
if (_vm->_game.id == GID_FT) {
setFtMusicCuePoint(b);
}
break;
case 0x1003: // ImuseSetAttribute
debug(5, "ImuseSetAttribute (%d, %d)", b, c);
assert((_vm->_game.id == GID_DIG) || (_vm->_game.id == GID_FT));
if (_vm->_game.id == GID_DIG) {
_attributes[b] = c;
}
break;
case 0x2000: // ImuseSetGroupSfxVolume
break;
case 0x2001: // ImuseSetGroupVoiceVolume
break;
case 0x2002: // ImuseSetGroupMusicVolume
break;
default:
error("IMuseDigital::doCommand DEFAULT command %d", cmd);
}
}
void fbClass::runCommand(std::string command_string)
{
std::string command;
std::istringstream iss(command_string);
std::getline(iss, command, ' ');
int values_int[10];
std::string value;
//printf("Command (fb): %s\n", command_string.c_str());
if (command == "FILLBOX")
{
int i = 0;
while (std::getline(iss, value, ' '))
{
values_int[i++] = atoi(value.c_str());
}
if (i >= 4)
{
fillBox(values_int[0], values_int[1], values_int[2], values_int[3], values_int[4]);
}
}
else if (command == "SETFADE")
{
int i = 0;
while (std::getline(iss, value, ' '))
{
values_int[i++] = atoi(value.c_str());
}
if (i >= 7)
{
setFade(values_int[0], values_int[1], values_int[2], values_int[3], values_int[4], values_int[5], values_int[6]);
}
}
else if (command == "PUTTEXT") // x y color max_size(-1) alignment(=0) text
{
for (int i = 0; i < 5; i++)
{
std::getline(iss, value, ' ');
values_int[i] = atoi(value.c_str());
}
std::getline(iss, value, '\n');
/*float size;
sscanf(value.c_str(), "%f", &size);*/
std::getline(iss, value, '\n');
if (vars->isavailable(value))
value = vars->getvalue(value);
/*if (size != factor)
setTextSize(size);*/
putText(values_int[0], values_int[1], values_int[2], value, values_int[3], values_int[4]);
}
else if (command == "CLEARSCREEN")
{
//printf("ClearScreen\n");
clearScreen();
}
else if (command == "SETTEXTSIZE")
{
std::getline(iss, value, ' ');
float val;
sscanf(value.c_str(), "%f", &val);
//std::cout << "Value: " << val << std::endl;
setTextSize(val);
}
}
