Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
rubberduckycooly
GitHub Repository: rubberduckycooly/Sonic-1-2-2013-Decompilation
 Path: blob/main/RSDKv4/NativeObjects/InstructionsScreen.cpp
817 views
1
#include "RetroEngine.hpp"

2


3
ushort helpText[0x1000];

4


5
void InstructionsScreen_Create(void *objPtr)

6
{

7
    RSDK_THIS(InstructionsScreen);

8


9
    self->labelPtr                  = CREATE_ENTITY(TextLabel);

10
    self->labelPtr->useRenderMatrix = true;

11
    self->labelPtr->fontID          = FONT_HEADING;

12
    self->labelPtr->scale           = 0.2;

13
    self->labelPtr->alpha           = 256;

14
    self->labelPtr->x               = -144.0;

15
    self->labelPtr->y               = 100.0;

16
    self->labelPtr->z               = 16.0;

17
    self->labelPtr->state           = TEXTLABEL_STATE_IDLE;

18
    SetStringToFont(self->labelPtr->text, strInstructions, FONT_HEADING);

19
    SetStringToFont8(self->pageIDText, "1 / 5", FONT_TEXT);

20
    SetStringToFont(helpText, strHelpText1, FONT_TEXT);

21


22
    self->meshPanel = LoadMesh("Data/Game/Models/Panel.bin", -1);

23
    SetMeshVertexColors(self->meshPanel, 0, 0, 0, 0xC0);

24
    self->textureArrows = LoadTexture("Data/Game/Menu/ArrowButtons.png", TEXFMT_RGBA5551);

25
    self->touchedPrev   = false;

26
    self->textY         = 68.0;

27
    self->textHeight    = (GetTextHeight(helpText, FONT_TEXT, 0.14) - 152.0) + 68.0;

28


29
    if (Engine.gameDeviceType == RETRO_STANDARD) {

30
        self->textureDPad = LoadTexture("Data/Game/Menu/Generic.png", TEXFMT_RGBA8888);

31
        if (timeAttackTex)

32
            ReplaceTexture("Data/Game/Menu/HelpGraphics.png", timeAttackTex);

33
        else

34
            self->textureHelp = LoadTexture("Data/Game/Menu/HelpGraphics.png", TEXFMT_RGBA5551);

35
    }

36
    else {

37
        self->textureDPad = LoadTexture("Data/Game/Menu/VirtualDPad.png", TEXFMT_RGBA8888);

38
        if (timeAttackTex)

39
            ReplaceTexture("Data/Game/Menu/HelpGraphics.png", timeAttackTex);

40
        else

41
            self->textureHelp = LoadTexture("Data/Game/Menu/HelpGraphics.png", TEXFMT_RGBA5551);

42
    }

43
}

44
void InstructionsScreen_Main(void *objPtr)

45
{

46
    RSDK_THIS(InstructionsScreen);

47
    NativeEntity_OptionsMenu *optionsMenu = (NativeEntity_OptionsMenu *)self->optionsMenu;

48
    switch (self->state) {

49
        case INSTRUCTIONSCREEN_STATE_ENTER: {

50
            if (self->arrowAlpha < 0x100)

51
                self->arrowAlpha += 8;

52


53
            self->scale = fminf(self->scale + ((1.05 - self->scale) / ((60.0 * Engine.deltaTime) * 8.0)), 1.0f);

54


55
            NewRenderState();

56
            MatrixScaleXYZF(&self->renderMatrix, self->scale, self->scale, 1.0);

57
            MatrixTranslateXYZF(&self->matrixTemp, 0.0, -8.0, 160.0);

58
            MatrixMultiplyF(&self->renderMatrix, &self->matrixTemp);

59
            SetRenderMatrix(&self->renderMatrix);

60


61
            memcpy(&self->labelPtr->renderMatrix, &self->renderMatrix, sizeof(MatrixF));

62


63
            self->timer += Engine.deltaTime;

64
            if (self->timer > 1.0) {

65
                self->arrowAlpha = 256;

66
                self->timer      = 0.0;

67
                self->state      = INSTRUCTIONSCREEN_STATE_MAIN;

68
            }

69
            break;

70
        }

71


72
        case INSTRUCTIONSCREEN_STATE_MAIN: {

73
            CheckKeyDown(&keyDown);

74
            CheckKeyPress(&keyPress);

75
            SetRenderMatrix(&self->matrixTemp);

76


77
            if (usePhysicalControls) {

78
                if (touches > 0) {

79
                    usePhysicalControls = false;

80
                }

81
                else {

82
                    self->touchedPrev = false;

83
                    self->touchedNext = false;

84
                    self->touchedBack = false;

85


86
                    if (self->textHeight > 68.0) {

87
                        if (keyDown.up)

88
                            self->textY = fmaxf(68.0, self->textY - 2.0);

89
                        if (keyDown.down)

90
                            self->textY = fminf(self->textHeight, self->textY + 2.0);

91
                    }

92


93
                    if (keyDown.left) {

94
                        PlaySfxByName("Menu Move", false);

95
                        self->state       = INSTRUCTIONSCREEN_STATE_FLIP;

96
                        self->stateInput  = INSTRUCTIONSCREEN_STATEINPUT_CHECKPRESS;

97
                        self->touchedPrev = false;

98
                        self->flipRight   = true;

99
                        if (--self->pageID < 0)

100
                            self->pageID = 4;

101
                    }

102
                    else if (keyDown.right) {

103
                        PlaySfxByName("Menu Move", false);

104
                        self->state       = INSTRUCTIONSCREEN_STATE_FLIP;

105
                        self->stateInput  = INSTRUCTIONSCREEN_STATEINPUT_CHECKPRESS;

106
                        self->touchedNext = false;

107
                        self->flipRight   = false;

108
                        self->pageID      = (self->pageID + 1) % 5;

109
                    }

110
                }

111
            }

112
            else {

113
                switch (self->stateInput) {

114
                    case INSTRUCTIONSCREEN_STATEINPUT_CHECKPRESS:

115
                        if (touches > 0) {

116
                            if (CheckTouchRect(0.0, -8.0, 128.0, 96.0) >= 0 && self->textHeight > 68.0) {

117
                                self->stateInput         = INSTRUCTIONSCREEN_STATEINPUT_HANDLEMOVEMENT;

118
                                self->lastSwipeDistanceV = 0.0;

119
                                self->lastTouchY         = touchYF[0];

120
                            }

121
                        }

122
                        else {

123
                            self->selectionEnabled = false;

124
                        }

125


126
                        if (keyDown.up || keyDown.down)

127
                            usePhysicalControls = true;

128
                        break;

129


130
                    case INSTRUCTIONSCREEN_STATEINPUT_HANDLEMOVEMENT:

131
                        if (touches > 0) {

132
                            self->swipeDistanceV = self->lastTouchY - touchYF[0];

133
                            if (self->lastSwipeDistanceV > 0.0 || self->lastSwipeDistanceV < 0.0)

134
                                self->textVelocity = self->lastSwipeDistanceV - self->swipeDistanceV;

135
                            else

136
                                self->textVelocity = 0.0;

137
                            self->lastSwipeDistanceV = self->swipeDistanceV;

138
                            self->textY += self->textVelocity;

139
                        }

140
                        else {

141
                            self->stateInput = INSTRUCTIONSCREEN_STATEINPUT_HANDLESCROLL;

142
                        }

143
                        break;

144


145
                    case INSTRUCTIONSCREEN_STATEINPUT_HANDLESCROLL:

146
                        if (touches <= 0) {

147
                            float acc = self->textVelocity / ((60.0 * Engine.deltaTime) * 1.1);

148
                            self->textY += acc;

149
                            self->textVelocity = acc;

150


151
                            if (abs(self->textVelocity) < 0.0025)

152
                                self->stateInput = INSTRUCTIONSCREEN_STATEINPUT_CHECKPRESS;

153


154
                            if (68.0 - abs(self->textVelocity * 4.0) > self->textY) {

155
                                self->swipeDistanceV = 68.0;

156
                                self->stateInput     = INSTRUCTIONSCREEN_STATEINPUT_HANDLESWIPE;

157
                            }

158


159
                            if (self->textY > (abs(self->textVelocity * 4.0) + self->textHeight)) {

160
                                self->swipeDistanceV = self->textHeight;

161
                                self->stateInput     = INSTRUCTIONSCREEN_STATEINPUT_HANDLESWIPE;

162
                            }

163
                        }

164
                        else if (CheckTouchRect(0.0, -8.0, 128.0, 96.0) >= 0) {

165
                            self->stateInput         = INSTRUCTIONSCREEN_STATEINPUT_HANDLEMOVEMENT;

166
                            self->lastSwipeDistanceV = 0.0;

167
                            self->lastTouchY         = touchYF[0];

168
                        }

169
                        break;

170


171
                    case INSTRUCTIONSCREEN_STATEINPUT_HANDLESWIPE:

172
                        if (touches <= 0) {

173
                            self->textY = ((self->swipeDistanceV - self->textY) / ((60.0 * Engine.deltaTime) * 8.0)) + self->textY;

174


175
                            if (abs(self->swipeDistanceV - self->textY) < 0.025) {

176
                                self->textY      = self->swipeDistanceV;

177
                                self->stateInput = INSTRUCTIONSCREEN_STATEINPUT_CHECKPRESS;

178
                            }

179
                        }

180
                        else if (CheckTouchRect(0.0, -8.0, 128.0, 96.0) >= 0) {

181
                            self->stateInput         = INSTRUCTIONSCREEN_STATEINPUT_HANDLEMOVEMENT;

182
                            self->lastSwipeDistanceV = 0.0;

183
                            self->lastTouchY         = touchYF[0];

184
                        }

185
                        break;

186
                }

187
            }

188


189
            if (touches <= 0) {

190
                if (self->touchedBack) {

191
                    PlaySfxByName("Menu Back", false);

192
                    self->touchedBack = false;

193
                    self->state       = INSTRUCTIONSCREEN_STATE_EXIT;

194
                }

195


196
                if (self->touchedPrev) {

197
                    PlaySfxByName("Menu Move", false);

198
                    self->state       = INSTRUCTIONSCREEN_STATE_FLIP;

199
                    self->stateInput  = INSTRUCTIONSCREEN_STATEINPUT_CHECKPRESS;

200
                    self->touchedPrev = false;

201
                    self->flipRight   = true;

202


203
                    if (--self->pageID < 0)

204
                        self->pageID = 4;

205
                }

206


207
                if (self->touchedNext) {

208
                    PlaySfxByName("Menu Move", false);

209
                    self->state       = INSTRUCTIONSCREEN_STATE_FLIP;

210
                    self->stateInput  = INSTRUCTIONSCREEN_STATEINPUT_CHECKPRESS;

211
                    self->touchedNext = false;

212
                    self->flipRight   = false;

213
                    self->pageID      = (self->pageID + 1) % 5;

214
                }

215
            }

216
            else if (self->state == 1) {

217
                self->touchedBack = CheckTouchRect(128.0, -92.0, 32.0, 32.0) >= 0;

218
                self->touchedPrev = CheckTouchRect(-162.0, 0.0, 32.0, 32.0) >= 0;

219
                self->touchedNext = CheckTouchRect(162.0, 0.0, 32.0, 32.0) >= 0;

220


221
                if (self->selectionEnabled) {

222
                    if (self->lastTouchX - touchXF[0] > 16.0f) {

223
                        PlaySfxByName("Menu Move", false);

224
                        self->state            = INSTRUCTIONSCREEN_STATE_FLIP;

225
                        self->stateInput       = INSTRUCTIONSCREEN_STATEINPUT_CHECKPRESS;

226
                        self->flipRight        = false;

227
                        self->selectionEnabled = false;

228
                        self->pageID           = (self->pageID + 1) % 5;

229
                    }

230
                    else if (self->lastTouchX - touchXF[0] < -16.0f) {

231
                        PlaySfxByName("Menu Move", false);

232
                        self->state            = INSTRUCTIONSCREEN_STATE_FLIP;

233
                        self->stateInput       = INSTRUCTIONSCREEN_STATEINPUT_CHECKPRESS;

234
                        self->flipRight        = true;

235
                        self->selectionEnabled = false;

236
                        if (--self->pageID < 0)

237
                            self->pageID = 4;

238
                    }

239
                }

240
                else {

241
                    self->selectionEnabled = true;

242
                }

243
                self->lastTouchX = touchXF[0];

244
            }

245
            else {

246
                self->selectionEnabled = false;

247
            }

248


249
            if (keyDown.up || keyDown.down || keyDown.left || keyDown.right)

250
                usePhysicalControls = true;

251


252
            if (self->state == 1 && keyPress.B) {

253
                PlaySfxByName("Menu Back", false);

254
                self->touchedBack = false;

255
                self->state       = INSTRUCTIONSCREEN_STATE_EXIT;

256
            }

257
            break;

258
        }

259


260
        case INSTRUCTIONSCREEN_STATE_FLIP: {

261
            if (!self->flipRight) {

262
                self->rotationY -= (10.0 * Engine.deltaTime);

263
            }

264
            else {

265
                self->rotationY += (10.0 * Engine.deltaTime);

266
            }

267


268
            if (abs(self->rotationY) > (M_PI * 0.5)) {

269
                self->state     = INSTRUCTIONSCREEN_STATE_FINISHFLIP;

270
                self->rotationY = self->rotationY < 0.0f ? -4.712389 : 4.712389;

271
                switch (self->pageID) {

272
                    case 0:

273
                        SetStringToFont(helpText, strHelpText1, FONT_TEXT);

274
                        SetStringToFont8(self->pageIDText, "1 / 5", 2);

275
                        break;

276


277
                    case 1:

278
                        if (Engine.gameDeviceType == RETRO_MOBILE)

279
                            SetStringToFont(helpText, strHelpText2, FONT_TEXT);

280
                        else

281
                            SetStringToFont8(helpText, "                                                      CONTROLS", FONT_TEXT);

282
                        SetStringToFont8(self->pageIDText, "2 / 5", FONT_TEXT);

283
                        break;

284


285
                    case 2:

286
                        SetStringToFont(helpText, strHelpText3, 2);

287
                        SetStringToFont8(self->pageIDText, "3 / 5", FONT_TEXT);

288
                        break;

289


290
                    case 3:

291
                        SetStringToFont(helpText, strHelpText4, 2);

292
                        SetStringToFont8(self->pageIDText, "4 / 5", FONT_TEXT);

293
                        break;

294


295
                    case 4:

296
                        SetStringToFont(helpText, strHelpText5, 2);

297
                        SetStringToFont8(self->pageIDText, "5 / 5", FONT_TEXT);

298
                        break;

299


300
                    default: break;

301
                }

302
                self->shownPage  = self->pageID;

303
                self->textY      = 68.0;

304
                self->textHeight = (GetTextHeight(helpText, FONT_TEXT, 0.14) - 152.0) + 68.0;

305
            }

306


307
            NewRenderState();

308
            MatrixRotateYF(&self->renderMatrix, self->rotationY);

309
            MatrixTranslateXYZF(&self->matrixTemp, 0.0, -8.0, 160.0);

310
            MatrixMultiplyF(&self->renderMatrix, &self->matrixTemp);

311
            SetRenderMatrix(&self->renderMatrix);

312
            break;

313
        }

314


315
        case INSTRUCTIONSCREEN_STATE_FINISHFLIP: {

316
            if (self->flipRight) {

317
                self->rotationY += (10.0 * Engine.deltaTime);

318
                if (self->rotationY > (M_PI_2)) {

319
                    self->state     = INSTRUCTIONSCREEN_STATE_MAIN;

320
                    self->rotationY = 0.0;

321
                }

322
            }

323
            else {

324
                self->rotationY -= (10.0 * Engine.deltaTime);

325
                if (self->rotationY < -(M_PI_2)) {

326
                    self->state     = INSTRUCTIONSCREEN_STATE_MAIN;

327
                    self->rotationY = 0.0;

328
                }

329
            }

330
            NewRenderState();

331
            MatrixRotateYF(&self->renderMatrix, self->rotationY);

332
            MatrixTranslateXYZF(&self->matrixTemp, 0.0, -8.0, 160.0);

333
            MatrixMultiplyF(&self->renderMatrix, &self->matrixTemp);

334
            SetRenderMatrix(&self->renderMatrix);

335
            break;

336
        }

337


338
        case INSTRUCTIONSCREEN_STATE_EXIT: {

339
            if (self->arrowAlpha > 0)

340
                self->arrowAlpha -= 8;

341


342
            if (self->timer < 0.2)

343
                self->scale = fmaxf(self->scale + ((1.5f - self->scale) / ((Engine.deltaTime * 60.0) * 8.0)), 0.0);

344
            else

345
                self->scale = fmaxf(self->scale + ((-1.0f - self->scale) / ((Engine.deltaTime * 60.0) * 8.0)), 0.0);

346


347
            NewRenderState();

348
            MatrixScaleXYZF(&self->renderMatrix, self->scale, self->scale, 1.0);

349
            MatrixTranslateXYZF(&self->matrixTemp, 0.0, -8.0, 160.0);

350
            MatrixMultiplyF(&self->renderMatrix, &self->matrixTemp);

351
            SetRenderMatrix(&self->renderMatrix);

352


353
            memcpy(&self->labelPtr->renderMatrix, &self->renderMatrix, sizeof(MatrixF));

354


355
            self->timer += Engine.deltaTime;

356
            if (self->timer > 0.5) {

357
                optionsMenu->state = OPTIONSMENU_STATE_EXITSUBMENU;

358
                RemoveNativeObject(self->labelPtr);

359
                RemoveNativeObject(self);

360
                return;

361
            }

362
            break;

363
        }

364
        default: break;

365
    }

366


367
    RenderMesh(self->meshPanel, MESH_COLORS, false);

368
    RenderTextClipped(helpText, FONT_TEXT, -138.0, self->textY, 8.0, 0.14, 255);

369


370
    switch (self->shownPage) {

371
        case 0:

372
            if (Engine.gameType == GAME_SONIC1) {

373
                RenderImageClipped(0.0, self->textY - 36.0, 8.0, 0.3, 0.3, 72.0, 72.0, 144.0, 144.0, 4.0, 4.0, 255, self->textureHelp);

374
                switch (Engine.language) {

375
                    default:

376
                        RenderImageClipped(0.0, self->textY - 164.0, 8.0, 0.3, 0.3, 72.0, 72.0, 144.0, 144.0, 312.0, 300.0, 255, self->textureHelp);

377
                        break;

378


379
                    case RETRO_FR:

380
                        RenderImageClipped(0.0, self->textY - 172.0, 8.0, 0.3, 0.3, 72.0, 72.0, 144.0, 144.0, 312.0, 300.0, 255, self->textureHelp);

381
                        break;

382


383
                    case RETRO_JP:

384
                        RenderImageClipped(0.0, self->textY - 248.0, 8.0, 0.3, 0.3, 72.0, 72.0, 144.0, 144.0, 312.0, 300.0, 255, self->textureHelp);

385
                        break;

386


387
                    case RETRO_KO:

388
                        RenderImageClipped(0.0, self->textY - 268.0, 8.0, 0.3, 0.3, 72.0, 72.0, 144.0, 144.0, 312.0, 300.0, 255, self->textureHelp);

389
                        break;

390
                }

391
            }

392
            else {

393
                RenderImageClipped(0.0, self->textY - 36.0, 8.0, 0.3, 0.3, 72.0, 72.0, 144.0, 144.0, 312.0, 300.0, 255, self->textureHelp);

394
            }

395
            break;

396


397
        case 1:

398
            if (Engine.gameDeviceType == RETRO_MOBILE) {

399
                RenderImageClipped(-96.0, self->textY - 28.0, 8.0, 0.2, 0.2, 128.0, 128.0, 256.0, 256.0, 0.0, 0.0, 255, self->textureDPad);

400
                RenderImageClipped(-96.0, self->textY - 28.0, 8.0, 0.2, 0.2, 84.0, 84.0, 168.0, 168.0, 16.0, 328.0, 255, self->textureDPad);

401
                RenderImageClipped(-96.0, self->textY - 92.0, 8.0, 0.2, 0.2, 128.0, 128.0, 256.0, 256.0, 0.0, 0.0, 255, self->textureDPad);

402
                RenderImageClipped(-96.0, self->textY - 92.0, 8.0, 0.2, 0.2, 128.0, 128.0, 256.0, 120.0, 256.0, 256.0, 255, self->textureDPad);

403
                RenderImageClipped(-96.0, self->textY - 92.0, 8.0, 0.2, 0.2, 84.0, 104.0, 168.0, 168.0, 16.0, 328.0, 255, self->textureDPad);

404
                RenderImageClipped(-96.0, self->textY - 156.0, 8.0, 0.2, 0.2, 128.0, 128.0, 256.0, 256.0, 0.0, 0.0, 255, self->textureDPad);

405
                RenderImageClipped(-96.0, self->textY - 156.0, 8.0, 0.2, 0.2, 128.0, -8.0, 256.0, 120.0, 256.0, 392.0, 255, self->textureDPad);

406
                RenderImageClipped(-96.0, self->textY - 156.0, 8.0, 0.2, 0.2, 84.0, 64.0, 168.0, 168.0, 16.0, 328.0, 255, self->textureDPad);

407
                RenderImageClipped(-96.0, self->textY - 220.0, 8.0, 0.2, 0.2, 128.0, 128.0, 256.0, 256.0, 256.0, 0.0, 255, self->textureDPad);

408
                RenderImageClipped(-96.0, self->textY - 220.0, 8.0, 0.25, 0.25, 84.0, 84.0, 168.0, 168.0, 16.0, 328.0, 255, self->textureDPad);

409
                RenderImageClipped(-96.0, self->textY - 284.0, 8.0, 0.5, 0.5, 32.0, 32.0, 64.0, 64.0, 160.0, 258.0, 255, self->textureDPad);

410
            }

411
            else {

412
                RenderImage(0.0, 0.0, 0.0, 0.275, 0.275, 512.0, 256.0, 1024.0, 512.0, 0.0, 0.0, 255, self->textureDPad);

413
            }

414
            break;

415


416
        case 2: break;

417


418
        case 3:

419
            switch (Engine.language) {

420
                default:

421
                    RenderImageClipped(0.0, self->textY - 128.0, 8.0, 0.3, 0.3, 253.0, 45.0, 506.0, 90.0, 155.0, 10.0, 255, self->textureHelp);

422
                    RenderImageClipped(0.0, self->textY - 220.0, 8.0, 0.3, 0.3, 24.0, 96.0, 48.0, 192.0, 4.0, 152.0, 255, self->textureHelp);

423
                    break;

424


425
                case RETRO_JP:

426
                    RenderImageClipped(0.0, self->textY - 112.0, 8.0, 0.3, 0.3, 253.0, 45.0, 506.0, 90.0, 155.0, 10.0, 255, self->textureHelp);

427
                    RenderImageClipped(0.0, self->textY - 232.0, 8.0, 0.3, 0.3, 24.0, 96.0, 48.0, 192.0, 4.0, 152.0, 255, self->textureHelp);

428
                    break;

429


430
                case RETRO_KO:

431
                    RenderImageClipped(0.0, self->textY - 132.0, 8.0, 0.3, 0.3, 253.0, 45.0, 506.0, 90.0, 155.0, 10.0, 255, self->textureHelp);

432
                    RenderImageClipped(0.0, self->textY - 232.0, 8.0, 0.3, 0.3, 24.0, 96.0, 48.0, 192.0, 4.0, 152.0, 255, self->textureHelp);

433
                    break;

434


435
                case RETRO_ZS:

436
                    RenderImageClipped(0.0, self->textY - 122.0, 8.0, 0.3, 0.3, 253.0, 45.0, 506.0, 90.0, 155.0, 10.0, 255, self->textureHelp);

437
                    RenderImageClipped(0.0, self->textY - 210.0, 8.0, 0.3, 0.3, 24.0, 96.0, 48.0, 192.0, 4.0, 152.0, 255, self->textureHelp);

438
                    break;

439
            }

440
            break;

441


442
        case 4:

443
            RenderImageClipped(0.0, self->textY - 56.0, 8.0, 0.5, 0.5, 162.0, 96.0, 324.0, 192.0, 152.0, 104.0, 255, self->textureHelp);

444


445
            if (Engine.gameType == GAME_SONIC1) {

446
                switch (Engine.language) {

447
                    default:

448
                        RenderImageClipped(0.0, self->textY - 188.0, 8.0, 0.3, 0.3, 204.0, 24.0, 408.0, 48.0, 16.0, 448.0, 255, self->textureHelp);

449
                        RenderImageClipped(0.0, self->textY - 240.0, 8.0, 0.3, 0.3, 36.0, 36.0, 72.0, 72.0, 4.0, 360.0, 255, self->textureHelp);

450
                        RenderImageClipped(0.0, self->textY - 288.0, 8.0, 0.3, 0.3, 42.0, 42.0, 84.0, 84.0, 56.0, 152.0, 255, self->textureHelp);

451
                        RenderImageClipped(0.0, self->textY - 336.0, 8.0, 0.3, 0.3, 36.0, 36.0, 72.0, 72.0, 80.0, 360.0, 255, self->textureHelp);

452
                        RenderImageClipped(0.0, self->textY - 380.0, 8.0, 0.3, 0.3, 76.0, 36.0, 152.0, 72.0, 156.0, 360.0, 255, self->textureHelp);

453
                        break;

454


455
                    case RETRO_JP:

456
                        RenderImageClipped(0.0, (self->textY - 188.0) - 32.0, 8.0, 0.3, 0.3, 204.0, 24.0, 408.0, 48.0, 16.0, 448.0, 255,

457
                                           self->textureHelp);

458
                        RenderImageClipped(0.0, (self->textY - 240.0) - 26.0, 8.0, 0.3, 0.3, 36.0, 36.0, 72.0, 72.0, 4.0, 360.0, 255,

459
                                           self->textureHelp);

460
                        RenderImageClipped(0.0, (self->textY - 288.0) - 32.0, 8.0, 0.3, 0.3, 42.0, 42.0, 84.0, 84.0, 56.0, 152.0, 255,

461
                                           self->textureHelp);

462
                        RenderImageClipped(0.0, (self->textY - 336.0) - 32.0, 8.0, 0.3, 0.3, 36.0, 36.0, 72.0, 72.0, 80.0, 360.0, 255,

463
                                           self->textureHelp);

464
                        RenderImageClipped(0.0, (self->textY - 380.0) - 42.0, 8.0, 0.3, 0.3, 76.0, 36.0, 152.0, 72.0, 156.0, 360.0, 255,

465
                                           self->textureHelp);

466
                        break;

467


468
                    case RETRO_RU:

469
                        RenderImageClipped(0.0, self->textY - 204.0, 8.0, 0.3, 0.3, 204.0, 24.0, 408.0, 48.0, 16.0, 448.0, 255, self->textureHelp);

470
                        RenderImageClipped(0.0, self->textY - 256.0, 8.0, 0.3, 0.3, 36.0, 36.0, 72.0, 72.0, 4.0, 360.0, 255, self->textureHelp);

471
                        RenderImageClipped(0.0, self->textY - 304.0, 8.0, 0.3, 0.3, 42.0, 42.0, 84.0, 84.0, 56.0, 152.0, 255, self->textureHelp);

472
                        RenderImageClipped(0.0, self->textY - 352.0, 8.0, 0.3, 0.3, 36.0, 36.0, 72.0, 72.0, 80.0, 360.0, 255, self->textureHelp);

473
                        RenderImageClipped(0.0, self->textY - 396.0, 8.0, 0.3, 0.3, 76.0, 36.0, 152.0, 72.0, 156.0, 360.0, 255, self->textureHelp);

474
                        break;

475


476
                    case RETRO_ZH:

477
                        RenderImageClipped(0.0, (self->textY - 188.0) - 22.0, 8.0, 0.3, 0.3, 204.0, 24.0, 408.0, 48.0, 16.0, 448.0, 255,

478
                                           self->textureHelp);

479
                        RenderImageClipped(0.0, (self->textY - 240.0) - 20.0, 8.0, 0.3, 0.3, 36.0, 36.0, 72.0, 72.0, 4.0, 360.0, 255,

480
                                           self->textureHelp);

481
                        RenderImageClipped(0.0, (self->textY - 288.0) - 22.0, 8.0, 0.3, 0.3, 42.0, 42.0, 84.0, 84.0, 56.0, 152.0, 255,

482
                                           self->textureHelp);

483
                        RenderImageClipped(0.0, (self->textY - 336.0) - 22.0, 8.0, 0.3, 0.3, 36.0, 36.0, 72.0, 72.0, 80.0, 360.0, 255,

484
                                           self->textureHelp);

485
                        RenderImageClipped(0.0, (self->textY - 380.0) - 22.0, 8.0, 0.3, 0.3, 76.0, 36.0, 152.0, 72.0, 156.0, 360.0, 255,

486
                                           self->textureHelp);

487
                        break;

488


489
                    case RETRO_ZS:

490
                        RenderImageClipped(0.0, self->textY - 196.0, 8.0, 0.3, 0.3, 204.0, 24.0, 408.0, 48.0, 16.0, 448.0, 255, self->textureHelp);

491
                        RenderImageClipped(0.0, self->textY - 240.0, 8.0, 0.3, 0.3, 36.0, 36.0, 72.0, 72.0, 4.0, 360.0, 255, self->textureHelp);

492
                        RenderImageClipped(0.0, self->textY - 288.0, 8.0, 0.3, 0.3, 42.0, 42.0, 84.0, 84.0, 56.0, 152.0, 255, self->textureHelp);

493
                        RenderImageClipped(0.0, self->textY - 336.0, 8.0, 0.3, 0.3, 36.0, 36.0, 72.0, 72.0, 80.0, 360.0, 255, self->textureHelp);

494
                        RenderImageClipped(0.0, self->textY - 380.0, 8.0, 0.3, 0.3, 76.0, 36.0, 152.0, 72.0, 156.0, 360.0, 255, self->textureHelp);

495
                        break;

496
                }

497
            }

498
            break;

499
    }

500


501
    NewRenderState();

502
    SetRenderMatrix(NULL);

503


504
    if (self->touchedPrev)

505
        RenderImageFlipH(-146.0, 0.0, 160.0, 0.2, 0.3, 64.0, 64.0, 128.0, 128.0, 0.0, 128.0, self->arrowAlpha, self->textureArrows);

506
    else

507
        RenderImageFlipH(-146.0, 0.0, 160.0, 0.2, 0.3, 64.0, 64.0, 128.0, 128.0, 0.0, 0.0, self->arrowAlpha, self->textureArrows);

508


509
    if (self->touchedNext)

510
        RenderImage(146.0, 0.0, 160.0, 0.2, 0.3, 64.0, 64.0, 128.0, 128.0, 0.0, 128.0, self->arrowAlpha, self->textureArrows);

511
    else

512
        RenderImage(146.0, 0.0, 160.0, 0.2, 0.3, 64.0, 64.0, 128.0, 128.0, 0.0, 0.0, self->arrowAlpha, self->textureArrows);

513


514
    if (self->touchedBack)

515
        RenderImage(128.0, -92.0, 160.0, 0.3, 0.3, 64.0, 64.0, 128.0, 128.0, 128.0, 128.0, self->arrowAlpha, self->textureArrows);

516
    else

517
        RenderImage(128.0, -92.0, 160.0, 0.3, 0.3, 64.0, 64.0, 128.0, 128.0, 128.0, 0.0, self->arrowAlpha, self->textureArrows);

518


519
    SetRenderVertexColor(0x00, 0x00, 0x40);

520
    RenderText(self->pageIDText, FONT_TEXT, -18.0, -110.0, 160.0, 0.25, 255);

521
    SetRenderVertexColor(0xFF, 0xFF, 0xFF);

522
}

523


524