void ofxWater::update(){ // Calculate the difference between buffers and spread the waving updateFbo.begin(); ofClear(0); updateShader.begin(); updateShader.setUniformTexture("buffer1Sample", pingPong.src->getTextureReference(), 0); updateShader.setUniformTexture("buffer2Sample", pingPong.dst->getTextureReference(), 1); updateShader.setUniform1f("damping", (float)density ); renderFrame(); updateShader.end(); updateFbo.end(); // Blur the waving in order to make it smooth pingPong.src->begin(); blurShader.begin(); blurShader.setUniformTexture("tex", updateFbo.getTextureReference(), 0); blurShader.setUniform1f("fade_const", (float)(blurFade)); renderFrame(); blurShader.end(); pingPong.src->end(); // Use the buffer as a bumpmap to morph the surface of the background texture renderFbo.begin(); ofClear(0); renderShader.begin(); renderShader.setUniformTexture("tex", *texture , 0); renderShader.setUniformTexture("heightMap", updateFbo.getTextureReference(), 1); renderFrame(); renderShader.end(); renderFbo.end(); // Switch buffers pingPong.swap(); }
void Engine::updateFrame(bool interactible, long deltaTime) { if (interactible) { // Each frame, we check to see if the window has resized. While the // various events we get _should_ cover this, in practice, it appears // that the safest move across all platforms and OSes is to check at // the top of each frame checkWindowResized(); // We're "interactible", i.e. focused, so we play the music playLoopedMusic(true); // Time stands still when we're auto-paused, and we don't // automatically render if (getAppUIMode() == MODE_GAMEPLAY) { // only advance the "game" timer in gameplay mode advanceTime(deltaTime); // This will try to set up EGL if it isn't set up // When we first set up EGL completely, we also load our GLES resources // If these are already set up or we succeed at setting them all up now, then // we go ahead and render. renderFrame(true); } else if (isForcedRenderPending()) { // forced rendering when needed for UI, etc renderFrame(true); } } else { // Even if we are not interactible, we may be visible, so we // HAVE to do any forced renderings if we can. We must also // check for resize, since that may have been the point of the // forced render request in the first place! if (isForcedRenderPending() && mEgl.isReadyToRender(false)) { checkWindowResized(); renderFrame(false); } // We're not "interactible", so we'd better stop the music immediately playLoopedMusic(false); } }
static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { switch (uMsg) { case WM_DESTROY: PostQuitMessage(0); break; case WM_ERASEBKGND: return 0; case WM_PAINT: renderFrame(); return 0; case WM_MOUSEMOVE: return mouseEvent(lParam, 0); case WM_LBUTTONDOWN: return mouseEvent(lParam, 1); case WM_LBUTTONUP: return mouseEvent(lParam, -1); case WM_RBUTTONDOWN: return mouseEvent(lParam, 2); case WM_RBUTTONUP: return mouseEvent(lParam, -2); case WM_SIZE: InvalidateRect(hWnd, NULL, FALSE); width = LOWORD(lParam); height = HIWORD(lParam); glViewport(0, 0, width, height); break; default: break; } return DefWindowProc(hWnd, uMsg, wParam, lParam); }
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) { createWindow(hInstance); createGLContext(); imguiRenderGLInit("c:\\windows\\fonts\\calibri.ttf"); timeBeginPeriod(1); ShowWindow(hWnd, SW_SHOW); for (;;) { MSG msg; while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE)) { if (msg.message == WM_QUIT) return 0; TranslateMessage(&msg); DispatchMessage(&msg); } renderFrame(); } timeEndPeriod(1); }
bool LeverControl::process(uint32 deltaTimeInMillis) { if (!_enabled) { return false; } if (_isReturning) { _accumulatedTime += deltaTimeInMillis; while (_accumulatedTime >= ANIMATION_FRAME_TIME) { _accumulatedTime -= ANIMATION_FRAME_TIME; if (_returnRoutesCurrentFrame == *_returnRoutesCurrentProgress) { _returnRoutesCurrentProgress++; } if (_returnRoutesCurrentProgress == _frameInfo[_currentFrame].returnRoute.end()) { _isReturning = false; _currentFrame = _returnRoutesCurrentFrame; return false; } uint toFrame = *_returnRoutesCurrentProgress; if (_returnRoutesCurrentFrame < toFrame) { _returnRoutesCurrentFrame++; } else if (_returnRoutesCurrentFrame > toFrame) { _returnRoutesCurrentFrame--; } _engine->getScriptManager()->setStateValue(_key, _returnRoutesCurrentFrame); renderFrame(_returnRoutesCurrentFrame); } } return false; }
void AVISurface::playCutscene(const Rect &r, uint startFrame, uint endFrame) { bool isDifferent = _movieFrameSurface[0]->w != r.width() || _movieFrameSurface[0]->h != r.height(); startAtFrame(startFrame); _currentFrame = startFrame; while (_currentFrame < (int)endFrame && !g_vm->shouldQuit()) { if (isNextFrame()) { renderFrame(); ++_currentFrame; if (isDifferent) { // Clear the destination area, and use the transBlitFrom method, // which supports arbitrary scaling, to reduce to the desired size g_vm->_screen->fillRect(r, 0); g_vm->_screen->transBlitFrom(*_movieFrameSurface[0], Common::Rect(0, 0, _movieFrameSurface[0]->w, _movieFrameSurface[0]->h), r); } else { g_vm->_screen->blitFrom(*_movieFrameSurface[0], Common::Point(r.left, r.top)); } g_vm->_screen->update(); g_vm->_events->pollEvents(); } // Brief wait, and check at the same time for clicks to abort the clip if (g_vm->_events->waitForPress(10)) break; } stop(); }
int main(int argc, char** argv) { fullscreen = false; grab = false; quit = false; initScreen(); initFrameBuffer(); createGLContext(); createColorMap(); createWindow(); createBlankCursor(); int x = 0; while(x<5000) { renderFrame(); updateWindowTitle(); x++; } /* Cleanup glXDestroyWindow(display, glxwindow); xcb_destroy_window(connection, window); glXDestroyContext(display, context); XCloseDisplay(display); */ return 0; }
static unsigned long twang_draw (Display *dpy, Window window, void *closure) { struct state *st = (struct state *) closure; if (st->img_loader) /* still loading */ { st->img_loader = load_image_async_simple (st->img_loader, 0, 0, 0, 0, 0); if (! st->img_loader) { /* just finished */ grabImage_done (st); } return st->delay; } if (!st->img_loader && st->start_time + st->duration < time ((time_t *) 0)) { XWindowAttributes xgwa; XGetWindowAttributes (st->dpy, st->window, &xgwa); grabImage_start (st, &xgwa); return st->delay; } modelEvents (st); updateModel (st); renderFrame (st); return st->delay; }
bool AVISurface::startAtFrame(int frameNumber) { if (isPlaying()) // If it's already playing, then don't allow it return false; if (frameNumber == -1) // Default to starting frame of first movie range frameNumber = _movieRangeInfo.front()->_startFrame; if (_isReversed && frameNumber == (int)_decoder->getFrameCount()) --frameNumber; // Start the playback _decoder->start(); // Seek to the starting frame seekToFrame(frameNumber); // If we're in reverse playback, set the decoder to play in reverse if (_isReversed) _decoder->setRate(Common::Rational(-1)); renderFrame(); return true; }
void Animation::render(int xaxis, int yaxis, const Graphics::Bitmap &work, double scalex, double scaley){ if (getState().position >= frames.size()){ return; } Mugen::Effects effects = frames[getState().position]->effects; effects.scalex = scalex; effects.scaley = scaley; renderFrame(frames[getState().position], xaxis, yaxis, work, effects); #if 0 // Modify with frame adjustment const int placex = xaxis+frames[position]->xoffset; const int placey = yaxis+frames[position]->yoffset; try{ frames[position]->sprite->render(placex,placey,work,frames[position]->effects); if (showDefense){ renderCollision( frames[position]->defenseCollision, work, xaxis, yaxis, Bitmap::makeColor( 0,255,0 ) ); } if (showOffense){ renderCollision( frames[position]->attackCollision, work, xaxis, yaxis, Bitmap::makeColor( 255,0,0 ) ); } } catch (const LoadException & e){ Global::debug(0) << "Error loading sprite: " << e.getReason() << endl; /* FIXME: do something sensible here */ frames[position]->sprite = 0; } #endif }
void Animation::render(bool facing, bool vfacing, const int xaxis, const int yaxis, const Graphics::Bitmap &work, const double scalex, const double scaley, Graphics::Bitmap::Filter * filter){ if (getState().position >= frames.size()){ return; } Frame * frame = frames[getState().position]; Mugen::Effects effects = frame->effects; effects.scalex = scalex; effects.scaley = scaley; /* FIXME: should horizontal facing follow the same logic as vfacing below? */ effects.facing = facing; /* case 1: explode vfacing is true and frame is normal. vfacing = -1 * case 2: explode vfacing is true and frame is flipped. vfacing = 1 * case 3: explode vfacing is false and frame is normal. vfacing = 1 * case 4: explode vfacing is false and frame is flipped. vfacing = -1 */ /* TODO: verify case 2 */ if (!effects.vfacing && vfacing){ effects.vfacing = true; } else if (effects.vfacing && vfacing){ effects.vfacing = false; } else if (!effects.vfacing && !vfacing){ effects.vfacing = false; } else { effects.vfacing = true; } effects.filter = filter; renderFrame(frame, xaxis, yaxis, work, effects); }
//============================================================================== void run() { { // Allow the message thread to finish setting-up the context before using it.. MessageManagerLock mml (this); if (! mml.lockWasGained()) return; } nativeContext->makeActive(); initialiseOnThread(); #if JUCE_USE_OPENGL_SHADERS && ! JUCE_OPENGL_ES shadersAvailable = OpenGLShaderProgram::getLanguageVersion() > 0; #endif while (! threadShouldExit()) { const uint32 frameRenderStartTime = Time::getMillisecondCounter(); if (renderFrame()) waitForNextFrame (frameRenderStartTime); } shutdownOnThread(); }
LeverControl::LeverControl(ZVision *engine, uint32 key, Common::SeekableReadStream &stream) : Control(engine, key), _frameInfo(0), _frameCount(0), _startFrame(0), _currentFrame(0), _lastRenderedFrame(0), _mouseIsCaptured(false), _isReturning(false), _accumulatedTime(0), _returnRoutesCurrentFrame(0) { // Loop until we find the closing brace Common::String line = stream.readLine(); trimCommentsAndWhiteSpace(&line); while (!stream.eos() && !line.contains('}')) { if (line.matchString("*descfile*", true)) { char levFileName[25]; sscanf(line.c_str(), "%*[^(](%25[^)])", levFileName); parseLevFile(levFileName); } else if (line.matchString("*cursor*", true)) { char cursorName[25]; sscanf(line.c_str(), "%*[^(](%25[^)])", cursorName); _cursorName = Common::String(cursorName); } line = stream.readLine(); trimCommentsAndWhiteSpace(&line); } renderFrame(_currentFrame); }
bool EngineManager::updateUnitily() { updateFrame(); renderFrame(); presentFrame(); return !isExitRequested(); }
bool LeverControl::onMouseMove(const Common::Point &screenSpacePos, const Common::Point &backgroundImageSpacePos) { if (!_enabled) { return false; } bool cursorWasChanged = false; if (_mouseIsCaptured) { // Make sure the square distance between the last point and the current point is greater than 64 // This is a heuristic. This determines how responsive the lever is to mouse movement. // TODO: Fiddle with the heuristic to get a good lever responsiveness 'feel' if (_lastMousePos.sqrDist(backgroundImageSpacePos) >= 64) { int angle = calculateVectorAngle(_lastMousePos, backgroundImageSpacePos); _lastMousePos = backgroundImageSpacePos; for (Common::List<Direction>::iterator iter = _frameInfo[_currentFrame].directions.begin(); iter != _frameInfo[_currentFrame].directions.end(); ++iter) { if (angle >= (int)iter->angle - ANGLE_DELTA && angle <= (int)iter->angle + ANGLE_DELTA) { _currentFrame = iter->toFrame; renderFrame(_currentFrame); break; } } } } else if (_frameInfo[_currentFrame].hotspot.contains(backgroundImageSpacePos)) { _engine->getCursorManager()->changeCursor(_cursorName); cursorWasChanged = true; } return cursorWasChanged; }
bool LeverControl::onMouseMove(const Common::Point &screenSpacePos, const Common::Point &backgroundImageSpacePos) { if (_engine->getScriptManager()->getStateFlag(_key) & Puzzle::DISABLED) return false; bool cursorWasChanged = false; if (_mouseIsCaptured) { // Make sure the square distance between the last point and the current point is greater than 16 // This is a heuristic. This determines how responsive the lever is to mouse movement. if (_lastMousePos.sqrDist(backgroundImageSpacePos) >= 16) { int angle = calculateVectorAngle(_lastMousePos, backgroundImageSpacePos); _lastMousePos = backgroundImageSpacePos; for (Common::List<Direction>::iterator iter = _frameInfo[_currentFrame].directions.begin(); iter != _frameInfo[_currentFrame].directions.end(); ++iter) { if (angle >= (int)iter->angle - ANGLE_DELTA && angle <= (int)iter->angle + ANGLE_DELTA) { _currentFrame = iter->toFrame; renderFrame(_currentFrame); _engine->getScriptManager()->setStateValue(_key, _currentFrame); break; } } } _engine->getCursorManager()->changeCursor(_cursor); cursorWasChanged = true; } else if (_frameInfo[_currentFrame].hotspot.contains(backgroundImageSpacePos)) { _engine->getCursorManager()->changeCursor(_cursor); cursorWasChanged = true; } return cursorWasChanged; }
//extern int g_iHeartTest; void Engine::handleCommand(int cmd) { switch (cmd) { //save player data. case APP_CMD_SAVE_STATE: // The system has asked us to save our current state. Do so. { //this->mApp->savedState = malloc(sizeof(int)); //int*l_pNumHeart = (int*)this->mApp->savedState; //*l_pNumHeart = g_iHeartTest; //mApp->stateSaved = sizeof(int); } break; // The window is being shown, get it ready. // Note that on ICS, the EGL size will often be correct for the new size here // But on HC it will not be. We need to defer checking the new res until the // first render with the new surface! case APP_CMD_INIT_WINDOW: case APP_CMD_WINDOW_RESIZED: mEgl.setWindow(mApp->window); break; case APP_CMD_TERM_WINDOW: // The window is being hidden or closed, clean it up. mEgl.setWindow(NULL); break; case APP_CMD_GAINED_FOCUS: g_bLostFocus = false; mEgl.setWindow(mApp->window); if( cGameApp::m_spSoundParser ) cGameApp::m_spSoundParser->Pause(false); break; case APP_CMD_STOP: case APP_CMD_LOST_FOCUS: if(cGameApp::m_spSoundParser) { //cGameApp::m_spSoundParser->Stop(); cGameApp::m_spSoundParser->Pause(true); } g_bLostFocus = true; break; case APP_CMD_PAUSE: // Move out of gameplay mode if we are in it. But if we are // in another dialog mode, leave it as-is if (mGameplayMode) setGameplayMode(false); break; // ICS does not appear to require this, but on GB phones, // not having this causes rotation changes to be delayed or // ignored when we're in a non-rendering mode like autopause. // The forced renders appear to allow GB to process the rotation case APP_CMD_CONFIG_CHANGED: renderFrame(true); break; } }
void Animation::render(int xaxis, int yaxis, const Graphics::Bitmap & work, const Mugen::Effects & effects){ if (getState().position >= frames.size()){ return; } Mugen::Effects combined = frames[getState().position]->effects + effects; renderFrame(frames[getState().position], xaxis, yaxis, work, combined); }
void Draw(ESContext *esContext) { // renderFrame(); eglSwapBuffers(esContext->eglDisplay, esContext->eglSurface); }
/////////// JNICALL .._step //////////// JNIEXPORT void JNICALL Java_ondrej_platek_bind_NativeRenderer_step(JNIEnv * env, jobject mythis) { AppCtx * c = reinterpret_cast<AppCtx*>(extractInt(env, mythis, "pAppCtx")); if(c == NULL) { LOGE("NativeRender_step context is NULL"); } else { renderFrame(c); } }
//------------------------------------------------------------------------- char runGame() { int offset; char i, willyCollideSprites = ColNoCol; BOOL willyCollideBackground = NO; if(m_keysFound == m_keysToFind) { ++m_keysFound; for(i = level2Sprite[m_level].index ;; ++i) { SpriteData *sprt = &spriteData[i]; if(sprt->spriteClass & SPClass_Door) { sprt->curEnabled = 1; m_doorToggle = 0; break; } else if(sprt->spriteClass & SPClass_Eugene) { sprt->curDirection = 1; sprt->curLocalStorage = 1; } } } else { for(i = 0; i < MaxKeysPerLevel; ++i) { offset = screenRowStart[keyPositions[m_level][i].y]+keyPositions[m_level][i].x ; if(WorldEmpty != SCREEN_RAM[offset]) incColourRamBy(offset, (i+1)); } } if(!--m_airAmount) return ColDie; moveSprites(); if(LEVEL_Solar_Power_Generator == m_level) buildPowerBeamPath(); if(GSTATE_Demo != m_gameState) willyCollideBackground = moveWilly(); renderFrame(); if(willyCollideBackground || (willyCollideSprites = checkSpriteCollisions())) { if(willyCollideSprites & ColDoor) return ColDoor; return ColDie; } return ColNoCol; }
bool AVISurface::handleEvents(CMovieEventList &events) { if (!isPlaying()) return true; CMovieRangeInfo *info = _movieRangeInfo.front(); _priorFrame = _currentFrame; _currentFrame += _isReversed ? -1 : 1; int newFrame = _currentFrame; if ((info->_isReversed && newFrame < info->_endFrame) || (!info->_isReversed && newFrame > info->_endFrame)) { if (info->_isRepeat) { newFrame = info->_startFrame; } else { info->getMovieEnd(events); _movieRangeInfo.remove(info); delete info; if (_movieRangeInfo.empty()) { // No more ranges, so stop playback stop(); } else { // Not empty, so move onto new first one info = _movieRangeInfo.front(); newFrame = info->_startFrame; setReversed(info->_isReversed); } } } if (isPlaying()) { if (newFrame != getFrame()) { // The frame has been changed, so move to new position seekToFrame(newFrame); renderFrame(); } // Get any events for the given position info->getMovieFrame(events, newFrame); return renderFrame(); } else { return false; } }
void MainWindow::doNextFrame() { if (renderFrame()) { frame++; runItTimer->start(); } else close(); QString statusmsg = QString("Rendering photo %1 frame %2").arg(photo).arg(frame); ui->statusBar->showMessage(statusmsg, 5000); }
/** * Just the current frame in the display. */ static void engine_draw_frame(struct engine* engine) { if (engine->display == NULL) { // No display. return; } renderFrame(); eglSwapBuffers(engine->display, engine->surface); }
JNIEXPORT int JNICALL Java_com_fbrs_electraengine_GL2JNILib_step(JNIEnv * env, jobject obj, jfloatArray rotate, jfloatArray translate) { jboolean *isCopy; jfloat * rot = env->GetFloatArrayElements(rotate, isCopy); jfloat * trans = env->GetFloatArrayElements(translate, isCopy); renderFrame(glm::vec3((float)rot[0],(float) rot[1], (float)rot[2]), glm::vec3((float)trans[0], (float)trans[1], (float)trans[2])); env->ReleaseFloatArrayElements(rotate, rot, 0); env->ReleaseFloatArrayElements(translate, trans, 0); return EngineFlag(); }
bool Ppapi::setInterfaces(PP_Instance _instance, const PPB_Instance* _instInterface, const PPB_Graphics3D* _graphicsInterface, PostSwapBuffersFn _postSwapBuffers) { BX_TRACE("PPAPI Interfaces"); m_instance = _instance; m_instInterface = _instInterface; m_graphicsInterface = _graphicsInterface; m_instancedArrays = glGetInstancedArraysInterfacePPAPI(); m_query = glGetQueryInterfacePPAPI(); m_postSwapBuffers = _postSwapBuffers; int32_t attribs[] = { PP_GRAPHICS3DATTRIB_ALPHA_SIZE, 8, PP_GRAPHICS3DATTRIB_DEPTH_SIZE, 24, PP_GRAPHICS3DATTRIB_STENCIL_SIZE, 8, PP_GRAPHICS3DATTRIB_SAMPLES, 0, PP_GRAPHICS3DATTRIB_SAMPLE_BUFFERS, 0, PP_GRAPHICS3DATTRIB_WIDTH, BGFX_DEFAULT_WIDTH, PP_GRAPHICS3DATTRIB_HEIGHT, BGFX_DEFAULT_HEIGHT, PP_GRAPHICS3DATTRIB_NONE }; m_context = m_graphicsInterface->Create(m_instance, 0, attribs); if (0 == m_context) { BX_TRACE("Failed to create context!"); return false; } m_instInterface->BindGraphics(m_instance, m_context); glSetCurrentContextPPAPI(m_context); m_graphicsInterface->SwapBuffers(m_context, naclSwapComplete); if (NULL != m_instancedArrays) { glVertexAttribDivisor = naclVertexAttribDivisor; glDrawArraysInstanced = naclDrawArraysInstanced; glDrawElementsInstanced = naclDrawElementsInstanced; } if (NULL != m_query) { glGenQueries = naclGenQueries; glDeleteQueries = naclDeleteQueries; glBeginQuery = naclBeginQuery; glEndQuery = naclEndQuery; glGetQueryObjectiv = naclGetQueryObjectiv; glGetQueryObjectui64v = naclGetQueryObjectui64v; } // Prevent render thread creation. RenderFrame::Enum result = renderFrame(); return RenderFrame::NoContext == result; }
void AVISurface::seekToFrame(uint frameNumber) { if ((int)frameNumber != getFrame()) { _decoders[0]->seekToFrame(frameNumber); if (_decoders[1]) _decoders[1]->seekToFrame(frameNumber); _currentFrame = (int)frameNumber; } renderFrame(); }
void gameLoop(XStuff* xs, GameState* gs, InputState* is) { checkResize(xs,gs); preFrame(gs); handleInput(gs, is); setUpView(gs); // update world state // depth and picking pre-pass glDepthFunc(GL_LESS); glBindFramebuffer(GL_FRAMEBUFFER, gs->framebuffer); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); depthPrepass(xs, gs, is); glBindFramebuffer(GL_FRAMEBUFFER, 0); glBindFramebuffer(GL_READ_FRAMEBUFFER, gs->framebuffer); checkCursor(gs, is); glBindFramebuffer(GL_FRAMEBUFFER, gs->framebuffer); // clear color buffer for actual rendering //glClear(GL_COLOR_BUFFER_BIT); glerr("pre shader create 1d"); glDepthFunc(GL_LEQUAL); glerr("pre shader create e"); renderFrame(xs, gs, is); glBindFramebuffer(GL_FRAMEBUFFER, 0); glBindFramebuffer(GL_READ_FRAMEBUFFER, gs->framebuffer); // draw to the screen glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); shadingPass(gs); renderUI(xs, gs); gs->screen.resized = 0; glXSwapBuffers(xs->display, xs->clientWin); }
void draw() { //glViewport(0, 0, g_context.width, g_context.height); //glClear(GL_COLOR_BUFFER_BIT); renderFrame(); // glUniform1f(g_context.u_time_loc, glutGet(GLUT_ELAPSED_TIME) / 1000.f); //glDrawArrays(GL_TRIANGLES, 0, 3); glutSwapBuffers(); }
int main(int argc, const char * argv[]) { initGL(); loadShader(); _scene.initialize("current_mesh_texture.ply"); InputHandler inputHandler(_window, _window.GetInput(), &_camera); while (_window.IsOpened()) { inputHandler.handleInput(); renderFrame(); _window.Display(); } return 0; }