void AudioScope::render(int width, int height) {
if (!_isEnabled) {
return;
}
static const float backgroundColor[4] = { 0.4f, 0.4f, 0.4f, 0.6f };
static const float gridColor[4] = { 0.7f, 0.7f, 0.7f, 1.0f };
static const float inputColor[4] = { 0.3f, 1.0f, 0.3f, 1.0f };
static const float outputLeftColor[4] = { 1.0f, 0.3f, 0.3f, 1.0f };
static const float outputRightColor[4] = { 0.3f, 0.3f, 1.0f, 1.0f };
static const int gridRows = 2;
int gridCols = _framesPerScope;
int x = (width - (int)SCOPE_WIDTH) / 2;
int y = (height - (int)SCOPE_HEIGHT) / 2;
int w = (int)SCOPE_WIDTH;
int h = (int)SCOPE_HEIGHT;
renderBackground(backgroundColor, x, y, w, h);
renderGrid(gridColor, x, y, w, h, gridRows, gridCols);
renderLineStrip(_inputID, inputColor, x, y, _samplesPerScope, _scopeInputOffset, _scopeInput);
renderLineStrip(_outputLeftID, outputLeftColor, x, y, _samplesPerScope, _scopeOutputOffset, _scopeOutputLeft);
renderLineStrip(_outputRightD, outputRightColor, x, y, _samplesPerScope, _scopeOutputOffset, _scopeOutputRight);
}
GLUSboolean update(GLUSfloat time)
{
static GLfloat passedTime = 0.0f;
static GLUSfloat angle = 0.0f;
GLfloat inverseViewMatrix[16];
glusLookAtf(g_viewMatrix, 0.0f, 1.0f, 0.0f, (GLfloat) 0.5f * sinf(angle), 1.0f, -(GLfloat) 0.5f * cosf(angle), 0.0f, 1.0f, 0.0f);
glusMatrix4x4Copyf(inverseViewMatrix, g_viewMatrix, GLUS_TRUE);
glusMatrix4x4InverseRigidBodyf(inverseViewMatrix);
glusMatrix4x4ExtractMatrix3x3f(g_inverseViewNormalMatrix, inverseViewMatrix);
// Render the background
renderBackground(g_viewMatrix);
// Render the water texture
renderWaterTexture(passedTime);
// Render the water scene
renderWater(passedTime);
passedTime += time;
angle += 2.0f * PIf / 120.0f * time;
return GLUS_TRUE;
}
void CheckBox::render() {
if (parent == NULL) { preRender(); }
renderBackground();
if (m_checked) { renderTick(); }
renderOverlay();
if (parent == NULL) { postRender(); }
}
void HudGaugeWingmanStatus::render(float frametime)
{
int i, count, num_wings_to_draw = 0;
for (i = 0; i < MAX_SQUADRON_WINGS; i++) {
if ( (HUD_wingman_status[i].used > 0) && (HUD_wingman_status[i].ignore == 0) ) {
num_wings_to_draw++;
}
}
if ( !hud_wingman_status_wingmen_exist(num_wings_to_draw) ) {
return;
}
// hud_set_default_color();
setGaugeColor();
// blit the background frames
renderBackground(num_wings_to_draw);
count = 0;
for (i = 0; i < MAX_SQUADRON_WINGS; i++) {
if ( (HUD_wingman_status[i].used <= 0) || (HUD_wingman_status[i].ignore == 1) ) {
continue;
}
renderDots(i, count, num_wings_to_draw);
count++;
}
}
void render_menu(Game *game)
{
renderBackground(mainmenuTexture);
renderMenuObjects(game);
renderMenuText(game);
game_credits(game);
}
void PCPUploadRenderer::process() {
if (!_inport.hasData())
return;
utilgl::ClearColor colorState(glm::vec4(0.0));
utilgl::activateAndClearTarget(_outport);
//glFinish();
//{
//IVW_CPU_PROFILING("PCPUploadRenderer");
renderParallelCoordinates();
//glFinish();
//}
renderBackground();
if (_enableTextRendering) {
renderTextOverlay(
_textRenderer,
_outport.getData()->getDimensions(),
_dimensionOrdering,
_dimensionMask
);
}
utilgl::deactivateCurrentTarget();
}
void ComboBox::render() {
renderBackground();
renderArrow();
renderOverlay();
Renderer* g = ARK2D::getRenderer();
if (m_selected != NULL) {
float tx = 0;
float ty = 0;
if (m_state == Button::STATE_DOWN || m_open) {
tx += 2;
ty += 2;
}
g->drawString(m_selected->m_text, tx, ty);
}
if (m_open) {
int y = 0 + m_originalHeight;
for(unsigned int i = 0; i < m_items.size(); i++) {
m_items.at(i)->setLocation(0, y);
y += m_items.at(i)->getHeight();
}
renderChildren();
}
}
void Scene::render( Graphics2D& g , Vec2f const& pos )
{
for ( int i = 0 ; i < mLevel.mNumCellData ; ++i )
{
BubbleCell& cell = mLevel.getCell(i);
if ( cell.isBlock() || cell.isEmpty() )
continue;
Vec2f cPos = mLevel.calcCellCenterPos( i );
//if ( cell.isBlock() )
//{
// g.setBrush( ColorKey3( 255 , 0 , 0 ) );
// g.drawCircle( pos + cPos , g_BubbleRadius );
//}
//else if ( cell.isEmpty() )
//{
// g.setBrush( ColorKey3( 255 , 255 , 255 ) );
// g.drawCircle( pos + cPos , g_BubbleRadius );
//}
//else
{
renderBubble( g , pos + cPos , cell.getColor() );
}
}
renderBackground( g , pos );
renderBubbleList( g , pos , mShootList );
renderBubbleList( g , pos , mFallList );
renderLauncher( g , pos );
}
void AscentApp::MapRender() {
for (int x = 0; x < numSquaresX; x++)
for (int y = 0; y < numSquaresY; y++) {
Point corP = Point(x - numSquaresX / 2, y - numSquaresY / 2);
renderBackground(engine->getBackground(corP), x, y);
renderForeground(engine->getForeground(corP), x, y);
if (engine->seeCreatureHere(corP))
renderHPLine(engine->creatureHPPercentHere(corP), x, y);
}
if (mouseInSquares) {
SDL_SetRenderDrawColor(renderer, 0x00, 0x00, 0xFF, 0xFF);
int qss = SQUARE_SIZE / 4;
int tqss = (SQUARE_SIZE * 3) / 4;
int xos = xOfSquare(mouseSquareX);
int yos = yOfSquare(mouseSquareY);
SDL_RenderDrawLine(renderer, xos,
yos + qss,
xos,
yos + tqss);
SDL_RenderDrawLine(renderer, xos + SQUARE_SIZE - 1,
yos + qss,
xos + SQUARE_SIZE - 1,
yos + tqss);
SDL_RenderDrawLine(renderer, xos + qss,
yos,
xos + tqss,
yos);
SDL_RenderDrawLine(renderer, xos + qss,
yos + SQUARE_SIZE - 1,
xos + tqss,
yos + SQUARE_SIZE - 1);
}
}
void EquipActivity::render() {
renderBackground();
if(m_itemMode) m_statswin->draw(m_itemwin->currentItem());
else m_statswin->draw();
m_choicewin->draw(!m_itemMode);
m_itemwin->draw(m_itemMode, m_itemMode);
}
int main (int argc, char* argv[])
{
if (!loadMapFromFile ("maps/level1.map"))
{
printf ("Can't locate map!");
}
initGUI();
initMap();
initPlayer();
SDL_Event e;
int quit = 0;
int start_time;
int urd_time;
int wait_time;
int target_time = 1000/FPS;
while (!quit)
{
start_time = SDL_GetTicks();
while (SDL_PollEvent (&e))
{
if (e.type == SDL_QUIT)
{
quit = 1;
}
else
{
player->left = 0;
player->right = 0;
}
processInput ();
}
clearScreen();
updatePlayer (player);
renderBackground();
renderMap();
renderPlayer (player);
draw();
urd_time = (SDL_GetTicks() - start_time);
wait_time = target_time - urd_time;
SDL_Delay (wait_time);
}
destroyGUI();
deletePlayer (player);
return 0;
}
void MenuActivity::render() {
renderBackground();
m_cmdwin->draw(ActivityManager::top() == this && !m_actorChoiceMode);
if(m_actorChoiceMode) {
m_actorChoicewin->draw();
}
}
void RenderBackground::Process(tgt::RenderTarget *input)
{
privatetarget_->activateTarget();
MatStack.matrixMode(tgt::MatrixStack::PROJECTION);
MatStack.loadIdentity();
MatStack.matrixMode(tgt::MatrixStack::MODELVIEW);
MatStack.loadIdentity();
glClearDepth(1.0);
glDisable(GL_DEPTH_TEST);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// first the background
renderBackground();
privatetarget_->deactivateTarget();
///
///
glEnable(GL_DEPTH_TEST);
// blending background with input
output_->activateTarget();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// use the shader to to blend the original picture over the background and to keep the
// depth values
tgt::TextureUnit colorUnit0, depthUnit0, colorUnit1, depthUnit1;
privatetarget_->bindTextures(colorUnit0.getEnum(), depthUnit0.getEnum());
input->bindTextures(colorUnit1.getEnum(), depthUnit1.getEnum());
// initialize shader
program_->activate();
setGlobalShaderParameters(program_, 0, output_->getSize());
program_->setUniform("colorTex0_", colorUnit0.getUnitNumber());
program_->setUniform("depthTex0_", depthUnit0.getUnitNumber());
program_->setUniform("colorTex1_", colorUnit1.getUnitNumber());
program_->setUniform("depthTex1_", depthUnit1.getUnitNumber());
privatetarget_->setTextureParameters(program_, "textureParameters0_");
input->setTextureParameters(program_, "textureParameters1_");
glDepthFunc(GL_ALWAYS);
renderQuad();
glDepthFunc(GL_LESS);
program_->deactivate();
output_->deactivateTarget();
tgt::TextureUnit::setZeroUnit();
}
void Client::beforeUI() {
UIApp::beforeUI();
_drawCallsWorld = 0;
_drawCallsEntities = 0;
if (_world->isCreated())
renderMap();
else
renderBackground();
}
void KBounceGameWidget::resizeEvent( QResizeEvent* ev )
{
kDebug() << "Size" << ev->size();
m_renderer.setBackgroundSize( ev->size() );
renderBackground();
QSize boardSize( ev->size().width() - 30, ev->size().height() - 30 );
m_board->resize( boardSize );
m_board->moveTo( ( ev->size().width() - boardSize.width() ) / 2, ( ev->size().height() - boardSize.height() ) / 2 );
redraw();
}
void ComboBoxItem::render() {
renderBackground();
renderOverlay();
Renderer* g = ARK2D::getRenderer();
float tx = 0;
float ty = 0;
if (m_state == Button::STATE_DOWN) {
tx += 2;
ty += 2;
}
g->drawString(m_text, tx, ty);
}
//--------------------------------------------------------------
void ofApp::draw(){
// - - - - - - - - - - - - - - - - VIDEO SYNC! - - - [ DRAW ]- - - - - - - -
ofSetColor(255);
videoPlayer.draw(0,0, 1920, 2160);
if (bINFO) {
string num = ofToString(syncPOSITION) + "\n" + ofToString(ofGetFrameRate(),1);
font250.drawString(num, (ofGetWidth()-font250.stringWidth(num))*.5, (ofGetHeight()-font250.stringHeight(num))*.5);
ofDrawBitmapString(ofToString(syncPOSITION, 5), 10,30);
ofDrawBitmapString(ofToString(bPLAY), 10,10);
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//Render background
renderBackground();
//Set line and color stuff
ofNoFill();
ofSetColor( 255, 255, 0 );
//for each customer render their display space. For now just their number.
for (int i=0; i<NUM_CUSTOMERS; i++) {
arrCustomers[i].render();
}
//Render debug animation
renderDebugAnimation();
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
ofSetColor(255,255,255);
if (bTestPlay) {
cVideoTest[0].draw(0, 0);
cVideoTest[1].draw(ofGetWidth() - cVideoTest[0].getWidth(),0);
cVideoTest[2].draw(0, 1080);
cVideoTest[3].draw(ofGetWidth() - cVideoTest[0].getWidth(), 1080);
}
// - - - - - - - - - - - - - - - - - FACT VIDEO TEST - - - - - - - - - - - -
}
// ritarut alla objekt
void EntityManager::render()
{
//mLight->SetCenter(Vec2f(mCharacters[mPrimaryCharacter]->getPosition().x, mVideoMode->height - mCharacters[mPrimaryCharacter]->getPosition().y));
renderBackground();
updateView();
for(int h = 0; h < 4; ++h)
{
for(EntityVector::size_type i = 0; i < mEntities.size(); ++i)
{
if(mEntities[i]->getLayer() == h)
{
sf::Vector2f pos = mEntities[i]->getPosition();
float width = mEntities[i]->getWidth(), height = mEntities[i]->getHeight();
float screenWidth = mView->getSize().x + width, screenHeight = mView->getSize().y + height;
pos.x -= (mView->getCenter().x - mView->getSize().x/2);
pos.y -= (mView->getCenter().y - mView->getSize().y/2);
if ( (pos.x + width) > 0
&& pos.x < screenWidth
&& pos.y + height > 0
&& pos.y < screenHeight)
{
mEntities[i]->render();
}
}
}
}
renderLifeAndMask();
renderPortrait();
lifeAndMaskPosition();
updateMovingCamera();
//sf::RectangleShape rect(sf::Vector2f(mMapRight - 512, mMapBottom - 360));
//rect.setPosition(mMapLeft, mMapTop);
//sf::Color colo(255,255,255,128);
//rect.setFillColor(colo);
//ImageManager::render(&rect);
//// Calculate the lights
//mLightSystem->RenderLights();
//// Draw the lights
//mLightSystem->RenderLightTexture();
}
void SettingsActivity::render() {
renderBackground();
if(m_mode == Mode::Settings) {
m_settings->draw();
}
else if(m_mode == Mode::Sound) {
m_settings->draw(false);
m_sound->draw();
}
else if(m_mode == Mode::Language) {
m_settings->draw(false);
m_language->draw();
}
}
void ShadowView::paintGL()
{
// setup the view matrix
setupUserViewProj();
// enable Texturing
glEnable(GL_TEXTURE_2D);
// Clear Buffer for new frame
glClearColor(0.0f ,0.0f, 0.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// render Background
renderBackground();
// // render the sun
// renderSun();
// Modelview Transformation
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef( 0.0f, 0.0f, g_fCameraZoom); // Zoom
glRotatef(g_fCameraElevation, 1.0f, 0.0f, 0.0f); // rotate elevation
glRotatef(g_fCameraAzimuth, 0.0f, 1.0f, 0.0f); // rotate azimuth
//glTranslatef( 0.0f, -g_fGroundLevel, 0.0f); // Lower the whole scene so that the center of the Mesh overlappes with the center of rotation
std::cout << g_fCameraZoom << " \t" << g_fCameraElevation << " \t" << g_fCameraAzimuth << std::endl;
std::cout.flush();
renderGround();
if( !m_mesh.expired() )
{
// enable sceneRendering Shader
//sceneRendering.enable();
// setup shader parameters
// TODO not elegant! try to do with uniform variabiles
//glColor4f(g_fSceneRenderingMode/4.0f, 0.0f, 0.0f, 0.0f);
// render the scene
//m_mesh.lock()->draw();
//sceneRendering.disable();
}
}
void KBounceGameWidget::settingsChanged()
{
kDebug() << "Settings changed";
m_board->setSounds( KBounceSettings::playSounds() );
if (KBounceSettings::useRandomBackgroundPictures())
{
m_renderer.setCustomBackgroundPath(KBounceSettings::backgroundPicturePath());
}
else
{
m_renderer.setCustomBackgroundPath(QString());
}
renderBackground();
redraw();
}
void ComboBox::render() {
renderBackground();
renderArrow();
renderOverlay();
Renderer* g = ARK2D::getRenderer();
if (m_selected != NULL) {
g->drawString(m_selected->m_text, m_x, m_y);
}
if (m_open) {
int y = m_y + m_originalHeight;
for(unsigned int i = 0; i < m_items.size(); i++) {
m_items.at(i)->setLocation(m_x, y);
m_items.at(i)->render();
y += m_items.at(i)->getHeight();
}
}
}
void Compass::doRender(RenderContext& renderContext) {
const Camera& camera = renderContext.camera();
const Camera::Viewport& viewport = camera.unzoomedViewport();
const int viewWidth = viewport.width;
const int viewHeight = viewport.height;
const Mat4x4f projection = orthoMatrix(0.0f, 1000.0f, -viewWidth / 2.0f, viewHeight / 2.0f, viewWidth / 2.0f, -viewHeight / 2.0f);
const Mat4x4f view = viewMatrix(Vec3f::PosY, Vec3f::PosZ) * translationMatrix(500.0f * Vec3f::PosY);
const ReplaceTransformation ortho(renderContext.transformation(), projection, view);
const Mat4x4f compassTransformation = translationMatrix(Vec3f(-viewWidth / 2.0f + 55.0f, 0.0f, -viewHeight / 2.0f + 55.0f)) * scalingMatrix<4>(2.0f);
const MultiplyModelMatrix compass(renderContext.transformation(), compassTransformation);
const Mat4x4f cameraTransformation = cameraRotationMatrix(camera);
glAssert(glClear(GL_DEPTH_BUFFER_BIT));
renderBackground(renderContext);
glAssert(glClear(GL_DEPTH_BUFFER_BIT));
doRenderCompass(renderContext, cameraTransformation);
}
std::string
PostscriptRenderer::render (
const boost::filesystem::path& tempDir,
const std::string& filenamePrefix,
const Registry<JourneyPattern>& lines,
synthese::map::Map& map,
const synthese::map::RenderingConfig& config
) {
std::string resultFilename = filenamePrefix + ".ps";
const boost::filesystem::path psFile (tempDir / resultFilename);
// Create the postscript canvas for output
std::ofstream of (psFile.string ().c_str ());
// Filter accents (temporary workaround til having found how to
// render accents properly in ghostscript.
// boost::iostreams::filtering_ostream fof;
// fof.push (synthese::util::PlainCharFilter());
// fof.push (of);
// ---- Render postscript file ----
PostscriptCanvas _canvas(of);
_config = config;
_canvas.startPage(0, 0, map.getWidth (), map.getHeight ());
renderBackground (_canvas, map);
renderLines (_canvas, map);
renderPhysicalStops (_canvas, map);
_canvas.showPage();
of.close ();
return resultFilename;
}
void KBounceGameWidget::newLevel()
{
m_state = Running;
emit stateChanged( m_state );
m_clock->start();
m_board->newLevel( m_level );
m_board->setPaused( false );
m_bonus = 0;
m_lives = m_level + 1;
m_time = 30 * ( m_level + 2 );
emit livesChanged( m_lives );
emit timeChanged( m_time );
if (KBounceSettings::useRandomBackgroundPictures())
{
m_renderer.loadNewBackgroundPixmap();
renderBackground();
}
redraw();
}
void UINodeBackgroundScene::render (int x, int y) const
{
UINode::render(x, y);
x += getRenderX(false);
y += getRenderY(false);
renderBackground(x, y);
if (MapFailedReasons::FAILED_WATER_HEIGHT == *_reason)
renderFailedWaterHeight(x, y);
else if (MapFailedReasons::FAILED_NPC_FLYING == *_reason)
renderFailedNpcFlying(x, y);
else if (MapFailedReasons::FAILED_NPC_WALKING == *_reason)
renderFailedNpcWalking(x, y);
else if (MapFailedReasons::FAILED_NPC_MAMMUT == *_reason)
renderFailedNpcMammut(x, y);
else if (MapFailedReasons::FAILED_NPC_FISH == *_reason)
renderFailedNpcFish(x, y);
else if (MapFailedReasons::FAILED_HITPOINTS == *_reason || MapFailedReasons::FAILED_SIDESCROLL == *_reason)
renderFailedHitpoints(x, y);
}
void render(Game *game)
{
glClear(GL_COLOR_BUFFER_BIT);
//glPushMatrix();
//glColor3ub(150,160,220);
// JBC removed "particle" stuff that is no longer in use
// DT
// JBC commented out... please keep for my testing
// if (game->nmissiles < 10) {
// createEMissiles(game);
// }
renderBackground(starsTexture);
//endLevel(game);
renderRadar(game);
renderUFO(game);
renderEMissiles(game);
renderEExplosions(game);
renderDefenseMissile(game);
renderStruc(game);
renderScores(game);
renderSMissile(game);
// renderDefExplosions(game);
}
void DSStatusBar::show() {
// 更改投影方式为 2D 平行投影
glMatrixMode(GL_PROJECTION);
glPushMatrix();
{
glLoadIdentity();
glOrtho(0, status_bar_width, 0, window_height, 0.01, 1000);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glViewport(
window_width - status_bar_width,
0,
status_bar_width,
window_height
);
glDisable(GL_LIGHTING);
glDisable(GL_TEXTURE_2D);
gluLookAt(0.0, 0.0, 200.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
glColor3d(1.0, 1.0, 1.0);
renderBackground();
//fillRectange2D(0, 0, status_bar_width, window_height);
// 这里画小地图，战场，人物等状态信息
glColor3f(0,1,1);
// 让我们在这里写一下眼睛位置
std::wostringstream os;
/*os << "(" << std::fixed << std::setprecision(2) << eye[0]
<< ", " << eye[1] << ", " << eye[2] << ")";
glPushMatrix();
{
glLoadIdentity();
dstext_small.print(8.0, 8.0, os.str());
dstext_small.print(40.0, 30.0, L"Eye position");
}
glPopMatrix();*/
//让我们写一下被选中人物的信息
glPushMatrix();
{
//std::stringstream o;
os.str(L"");
os << frame.actors.selectInfo();
glLoadIdentity();
dstext_small.print(12.0, 400.0, os.str());
}
glPopMatrix();
//提示消息
glPushMatrix();
{
//std::stringstream o;
os.str(L"");
//os << L"帮助\nF1 拉近镜头\nF2 推远镜头\nup,down,left,right\n视角旋转\nw,a,s,d 视线平移\n鼠标点击 选择人物\n鼠标右键 取消选择";
//os << L"帮助：\nF1 拉近镜头\nF2 推远镜头\n↑ ↓ → ← 视角旋转\nW S A D 视线平移\n";
/*if (frame.actors.paused) {
os << L"F4 切换为自动";
} else {
os << L"F4 切换为手动";
}*/
glLoadIdentity();
dstext_small.print(15.0f, (GLfloat)window_height - 120, os.str());
}
glPopMatrix();
/*os.str(L"");
os << frame.actors.list["mage"].winx << L", "
<< frame.actors.list["mage"].winy << L", "
<< frame.actors.list["mage"].winz;
glPushMatrix();
{
glLoadIdentity();
dstext_small.print(5, 400, os.str().c_str());
}
glPopMatrix();*/
glPushMatrix();
{
//glColor3f(0,0,1);
os.str(L"");
os << L"FPS: " << frame.getFPS();
glLoadIdentity();
glScalef(0.5, 0.5, 0.5);
dstext.print(15.0f, (GLfloat)window_height - 80, os.str());
}
glPopMatrix();
glPushMatrix();
{
os.str(L"");
os << L"回合 " << frame.actors.getCurrentRound();
if (frame.actors.round_finished) {
os << L"\nF3 进入下一回合";
}
if (frame.actors.script_playing != 0) {
os << L"\n" << frame.actors.script_playing << L" 个动作正在播放";
}
if (frame.actors.all_finished) {
os << L"\n已结束";
}
glLoadIdentity();
dstext_small.print(15.0f, 220, os.str());
}
glPopMatrix();
glEnable(GL_TEXTURE_2D);
glEnable(GL_LIGHTING);
// 回到透视投影
glMatrixMode(GL_PROJECTION);
}
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
}
int main() {
cfguInit();
CFGU_GetSystemModel(&MODEL_3DS);
FILE * file;
shouldRenderDebug = true;
if ((file = fopen("settings.bin", "r"))) {
fread(&shouldRenderDebug,sizeof(bool),1,file);
fread(&shouldSpeedup,sizeof(bool),1,file);
osSetSpeedupEnable(shouldSpeedup);
fclose(file);
}
sf2d_init();
csndInit();
noItem = newItem(ITEM_NULL, 0);
currentMenu = MENU_TITLE;
currentSelection = 0;
quitGame = false;
icons = sfil_load_PNG_buffer(icons2_png, SF2D_PLACE_RAM);
font = sfil_load_PNG_buffer(Font_png, SF2D_PLACE_RAM);
bottombg = sfil_load_PNG_buffer(bottombg_png, SF2D_PLACE_RAM);
dirtColor[0] = SWAP_UINT32(sf2d_get_pixel(icons, 16, 0));
dirtColor[1] = SWAP_UINT32(sf2d_get_pixel(icons, 16, 1));
dirtColor[2] = SWAP_UINT32(sf2d_get_pixel(icons, 16, 2));
dirtColor[3] = SWAP_UINT32(sf2d_get_pixel(icons, 16, 3));
dirtColor[4] = SWAP_UINT32(sf2d_get_pixel(icons, 16, 4));
loadSound(&snd_playerHurt, "resources/playerhurt.raw");
loadSound(&snd_playerDeath, "resources/playerdeath.raw");
loadSound(&snd_monsterHurt, "resources/monsterhurt.raw");
loadSound(&snd_test, "resources/test.raw");
loadSound(&snd_pickup, "resources/pickup.raw");
loadSound(&snd_bossdeath, "resources/bossdeath.raw");
loadSound(&snd_craft, "resources/craft.raw");
bakeLights();
int i;
for (i = 0; i < 5; ++i) {
minimap[i] = sf2d_create_texture(128, 128, TEXFMT_RGBA8,
SF2D_PLACE_RAM);
sf2d_texture_tile32(minimap[i]);
}
sf2d_set_vblank_wait(true);
sf2d_set_clear_color(0xFF000000);
k_up.input = KEY_DUP | KEY_CPAD_UP | KEY_CSTICK_UP;
k_down.input = KEY_DDOWN | KEY_CPAD_DOWN | KEY_CSTICK_DOWN;
k_left.input = KEY_DLEFT | KEY_CPAD_LEFT | KEY_CSTICK_LEFT;
k_right.input = KEY_DRIGHT | KEY_CPAD_RIGHT | KEY_CSTICK_RIGHT;
k_attack.input = KEY_A | KEY_B | KEY_L | KEY_ZR;
k_menu.input = KEY_X | KEY_Y | KEY_R | KEY_ZL;
k_pause.input = KEY_START;
k_accept.input = KEY_A;
k_decline.input = KEY_B;
k_delete.input = KEY_X;
k_menuNext.input = KEY_R;
k_menuPrev.input = KEY_L;
if ((file = fopen("btnSave.bin", "rb"))) {
fread(&k_up.input, sizeof(int), 1, file);
fread(&k_down.input, sizeof(int), 1, file);
fread(&k_left.input, sizeof(int), 1, file);
fread(&k_right.input, sizeof(int), 1, file);
fread(&k_attack.input, sizeof(int), 1, file);
fread(&k_menu.input, sizeof(int), 1, file);
fread(&k_pause.input, sizeof(int), 1, file);
fread(&k_accept.input, sizeof(int), 1, file);
fread(&k_decline.input, sizeof(int), 1, file);
fread(&k_delete.input, sizeof(int), 1, file);
fread(&k_menuNext.input, sizeof(int), 1, file);
fread(&k_menuPrev.input, sizeof(int), 1, file);
fclose(file);
}
if ((file = fopen("lastTP.bin", "r"))) {
char fnbuf[256];
fgets(fnbuf, 256, file); // get directory to texturepack
loadTexturePack(fnbuf);
fclose(file);
}
tickCount = 0;
initRecipes();
defineTables();
while (aptMainLoop()) {
++tickCount;
hidScanInput();
tickKeys(hidKeysHeld(), hidKeysDown());
if (quitGame) break;
if (initGame > 0) setupGame(initGame == 1 ? true : false);
if (currentMenu == 0) {
tick();
sf2d_start_frame(GFX_TOP, GFX_LEFT);
offsetX = xscr;
offsetY = yscr;
sf2d_draw_rectangle(0, 0, 400, 240, 0xFF0C0C0C); //RGBA8(12, 12, 12, 255)); //You might think "real" black would be better, but it actually looks better that way
renderLightsToStencil();
renderBackground(xscr, yscr);
renderEntities(player.x, player.y, &eManager);
renderPlayer();
resetStencilStuff();
offsetX = 0;
offsetY = 0;
if(shouldRenderDebug){
sprintf(fpsstr, " FPS: %.0f, X:%d, Y:%d, E:%d", sf2d_get_fps(), player.x, player.y, eManager.lastSlot[currentLevel]);
drawText(fpsstr, 2, 225);
}
sf2d_end_frame();
sf2d_start_frame(GFX_BOTTOM, GFX_LEFT);
if(!shouldRenderMap){
sf2d_draw_texture(bottombg, 0, 0);
renderGui();
} else {
renderZoomedMap();
}
sf2d_end_frame();
} else {
tickMenu(currentMenu);
renderMenu(currentMenu, xscr, yscr);
}
sf2d_swapbuffers();
}
freeRecipes();
freeLightBakes();
sf2d_free_texture(icons);
sf2d_free_texture(minimap[0]);
sf2d_free_texture(minimap[1]);
sf2d_free_texture(minimap[2]);
sf2d_free_texture(minimap[3]);
sf2d_free_texture(minimap[4]);
freeSounds();
csndExit();
cfguExit();
sf2d_fini();
return 0;
}
int main(int argc, char* args[])
{
srand(time(NULL));
PLAYER* player = createPlayer();
BACKGROUND* background = createBackground();
LTexture lt;
BANANA* bananaArray[MAX_NUM_OF_BANANA];
BARRIER* barrierArray[MAX_NUM_OF_BARRIER];
int i;
for(i = 0; i < MAX_NUM_OF_BANANA; i++)
{
bananaArray[i] = createBanana();
}
for(i = 0; i < MAX_NUM_OF_BARRIER; i++)
{
barrierArray[i] = createBarrier();
}
if( !init() )
{
printf( "Failed to initialize!\n" );
}
else
{
if( !loadBackground("./media/background.png", &background->background_tex, gRenderer) || !loadPlayer("./media/minion.png", &player->player_tex, gRenderer, gSpriteClips))
{
printf( "Failed to load media!\n" );
}
else
{
for(i = 0; i < MAX_NUM_OF_BANANA; i++)
{
loadBanana("./media/banana.png", &bananaArray[i]->banana_tex, gRenderer);
setPosRectBanana(bananaArray[i]);
}
for(i = 0; i < MAX_NUM_OF_BARRIER; i++)
{
loadBarrier("./media/barrier.png", &barrierArray[i]->barrier_tex, gRenderer);
setPosRectBarrier(barrierArray[i]);
}
bool quit = false;
SDL_Event e;
player->frame = 0;
background->scrollingOffset = 0;
while( !quit )
{
while( SDL_PollEvent( &e ) != 0 )
{
if( e.type == SDL_QUIT )
{
quit = true;
}
if(e.key.type == SDL_KEYDOWN)
{
switch( e.key.keysym.sym )
{
case SDLK_UP:
if(canMoveUp(player))
{
moveUp(player);
}
break;
case SDLK_DOWN:
if(canMoveDown(player))
{
moveDown(player);
}
break;
}
}
}
--(background->scrollingOffset);
if( background->scrollingOffset < -background->background_tex.mWidth )
{
background->scrollingOffset = 0;
}
SDL_Rect* currentClip;
SDL_SetRenderDrawColor( gRenderer, 0xFF, 0xFF, 0xFF, 0xFF );
SDL_RenderClear( gRenderer );
renderBackground(background, background->scrollingOffset, gRenderer);
currentClip = &gSpriteClips[ player->frame / 16 ];
renderPlayer(player, currentClip, gRenderer);
setPosRectPlayer(player);
for (i = 0; i < MAX_NUM_OF_BANANA; i++)
{
if( checkCollision(player->mPlayer, bananaArray[i]->mBanana, background->scrollingOffset))
{
increaseTotalScore();
eraseBanana(bananaArray[i]);
}
renderBanana(bananaArray[i], background->scrollingOffset + bananaArray[i]->posX, gRenderer);
}
for (i = 0; i < MAX_NUM_OF_BARRIER; i++)
{
if( checkCollisionEnd(player->mPlayer, barrierArray[i]->mBarrier, background->scrollingOffset))
{
closeWin(player, background, bananaArray, barrierArray);
return 0;
}
renderBarrier(barrierArray[i], background->scrollingOffset + barrierArray[i]->posX, gRenderer);
}
++player->frame;
if( player->frame / 4 >= WALKING_ANIMATION_FRAMES )
{
player->frame = 0;
}
SDL_RenderPresent(gRenderer);
}
closeWin(player, background, bananaArray, barrierArray);
}
}
return 0;
}
