static void render_unlit(world_t w, float lerp) { if ( !w->do_shadows ) return; glDisable(GL_LIGHT0); do_render(w, lerp, NULL); }
static void render_lit(world_t w, float lerp) { renderer_t r = w->render; vec3_t cpos; glEnable(GL_LIGHT0); if ( w->do_shadows ) { glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); glDepthMask(GL_TRUE); glStencilFunc(GL_EQUAL, 0x0, 0xff); glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); glEnable(GL_STENCIL_TEST); } do_render(w, lerp, NULL); if ( w->do_shadows ) { glDisable(GL_STENCIL_TEST); } glPushMatrix(); chopper_get_pos(w->apache, lerp, cpos); renderer_translate(r, w->cpos[0], w->cpos[1], w->cpos[2]); renderer_translate(r, -cpos[0], -cpos[1], -cpos[2]); particles_render_all(r, lerp); glPopMatrix(); }
bool MasterRenderer::render() { try { do_render(); return true; } catch (const bad_alloc&) { m_renderer_controller->on_rendering_abort(); RENDERER_LOG_ERROR("rendering failed (ran out of memory)."); return false; } #ifdef NDEBUG catch (const std::exception& e) { m_renderer_controller->on_rendering_abort(); RENDERER_LOG_ERROR("rendering failed (%s).", e.what()); return false; } catch (...) { m_renderer_controller->on_rendering_abort(); RENDERER_LOG_ERROR("rendering failed (unknown exception)."); return false; } #endif }
int main(int argc, char **argv) { int fd; int object_size = OBJECT_WIDTH * OBJECT_HEIGHT * 4; double start_time, end_time; drm_intel_bo *dst_bo; drm_intel_bufmgr *bufmgr; struct intel_batchbuffer *batch; int i; fd = drm_open_any(); bufmgr = drm_intel_bufmgr_gem_init(fd, 4096); drm_intel_bufmgr_gem_enable_reuse(bufmgr); batch = intel_batchbuffer_alloc(bufmgr, intel_get_drm_devid(fd)); dst_bo = drm_intel_bo_alloc(bufmgr, "dst", object_size, 4096); /* Prep loop to get us warmed up. */ for (i = 0; i < 60; i++) { do_render(bufmgr, batch, dst_bo, OBJECT_WIDTH, OBJECT_HEIGHT); } drm_intel_bo_wait_rendering(dst_bo); /* Do the actual timing. */ start_time = get_time_in_secs(); for (i = 0; i < 200; i++) { do_render(bufmgr, batch, dst_bo, OBJECT_WIDTH, OBJECT_HEIGHT); } drm_intel_bo_wait_rendering(dst_bo); end_time = get_time_in_secs(); printf("%d iterations in %.03f secs: %.01f MB/sec\n", i, end_time - start_time, (double)i * OBJECT_WIDTH * OBJECT_HEIGHT * 4 / 1024.0 / 1024.0 / (end_time - start_time)); intel_batchbuffer_free(batch); drm_intel_bufmgr_destroy(bufmgr); close(fd); return 0; }
void render() { glClearColor(0.0, 0.0, 0.1, 1.0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glEnable(GL_DEPTH_TEST); glPolygonOffset(0.0, 0.0); glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); do_render(false); glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); glPolygonOffset(-1.0, -1.0); glLineWidth(2.0f); do_render(true); glutSwapBuffers(); update_fps(); }
// Render the project. MasterRenderer::RenderingResult render() { // RenderingResult is initialized to Failed. RenderingResult result; // Perform basic integrity checks on the scene. if (!check_scene()) return result; // Initialize thread-local variables. Spectrum::set_mode(get_spectrum_mode(m_params)); // Reset the frame's render info. m_project.get_frame()->render_info().clear(); try { // Render. m_stopwatch.start(); result.m_status = do_render(); m_stopwatch.measure(); result.m_render_time = m_stopwatch.get_seconds(); // Insert render time into the frame's render info. // Note that the frame entity may have replaced during rendering. ParamArray& render_info = m_project.get_frame()->render_info(); render_info.insert("render_time", result.m_render_time); // Don't proceed further if rendering failed. if (result.m_status != RenderingResult::Succeeded) return result; // Post-process. m_stopwatch.start(); postprocess(result); m_stopwatch.measure(); result.m_post_processing_time = m_stopwatch.get_seconds(); render_info.insert("post_processing_time", result.m_post_processing_time); } catch (const bad_alloc&) { m_renderer_controller->on_rendering_abort(); RENDERER_LOG_ERROR("rendering failed (ran out of memory)."); result.m_status = RenderingResult::Failed; } #ifdef NDEBUG catch (const exception& e) { m_renderer_controller->on_rendering_abort(); RENDERER_LOG_ERROR("rendering failed (%s).", e.what()); result.m_status = RenderingResult::Failed; } catch (...) { m_renderer_controller->on_rendering_abort(); RENDERER_LOG_ERROR("rendering failed (unknown exception)."); result.m_status = RenderingResult::Failed; } #endif return result; }
void Particles_Engine::render_particles( TFlash *flash, TTile *tile, std::vector<TRasterFxPort *> part_ports, const TRenderSettings &ri, TDimension &p_size, TPointD &p_offset, std::map<int, TRasterFxPort *> ctrl_ports, std::vector<TLevelP> partLevel, float dpi, int curr_frame, int shrink, double startx, double starty, double endx, double endy, std::vector<int> last_frame, unsigned long fxId) { int frame, startframe, intpart = 0, level_n = 0; struct particles_values values; double dpicorr = dpi * 0.01, fractpart = 0, dpicorr_shrinked = 0, opacity_range = 0; bool random_level = false; level_n = part_ports.size(); bool isPrecomputingEnabled = false; { TRenderer renderer(TRenderer::instance()); isPrecomputingEnabled = (renderer && renderer.isPrecomputingEnabled()) ? true : false; } memset(&values, 0, sizeof(values)); /*- 現在のフレームでの各種パラメータを得る -*/ fill_value_struct(values, m_frame); /*- 不透明度の範囲(透明〜不透明を 0〜1 に正規化)-*/ opacity_range = (values.opacity_val.second - values.opacity_val.first) * 0.01; /*- 開始フレーム -*/ startframe = (int)values.startpos_val; if (values.unit_val == ParticlesFx::UNIT_SMALL_INCH) dpicorr_shrinked = dpicorr / shrink; else dpicorr_shrinked = dpi / shrink; std::map<std::pair<int, int>, double> partScales; curr_frame = curr_frame / values.step_val; ParticlesManager *pc = ParticlesManager::instance(); // Retrieve the last rolled frame ParticlesManager::FrameData *particlesData = pc->data(fxId); std::list<Particle> myParticles; TRandom myRandom; values.random_val = &myRandom; myRandom = m_parent->randseed_val->getValue(); int totalparticles = 0; int pcFrame = particlesData->m_frame; if (pcFrame > curr_frame) { // Clear stored particlesData particlesData->clear(); pcFrame = particlesData->m_frame; } else if (pcFrame >= startframe - 1) { myParticles = particlesData->m_particles; myRandom = particlesData->m_random; totalparticles = particlesData->m_totalParticles; } /*- スタートからカレントフレームまでループ -*/ for (frame = startframe - 1; frame <= curr_frame; ++frame) { int dist_frame = curr_frame - frame; /*- * ループ内の現在のフレームでのパラメータを取得。スタートが負ならフレーム=0のときの値を格納 * -*/ fill_value_struct(values, frame < 0 ? 0 : frame * values.step_val); /*- パラメータの正規化 -*/ normalize_values(values, ri); /*- maxnum_valは"birth_rate"のパラメータ -*/ intpart = (int)values.maxnum_val; /*- * /birth_rateが小数だったとき、各フレームの小数部分を足しこんだ結果の整数部分をintpartに渡す。 * -*/ fractpart = fractpart + values.maxnum_val - intpart; if ((int)fractpart) { values.maxnum_val += (int)fractpart; fractpart = fractpart - (int)fractpart; } std::map<int, TTile *> porttiles; // Perform the roll /*- RenderSettingsを複製して現在のフレームの計算用にする -*/ TRenderSettings riAux(ri); riAux.m_affine = TAffine(); riAux.m_bpp = 32; int r_frame; // Useful in case of negative roll frames if (frame < 0) r_frame = 0; else r_frame = frame; /*- 出力画像のバウンディングボックス -*/ TRectD outTileBBox(tile->m_pos, TDimensionD(tile->getRaster()->getLx(), tile->getRaster()->getLy())); /*- Controlに刺さっている各ポートについて -*/ for (std::map<int, TRasterFxPort *>::iterator it = ctrl_ports.begin(); it != ctrl_ports.end(); ++it) { TTile *tmp; /*- ポートが接続されていて、Fx内で実際に使用されていたら -*/ if ((it->second)->isConnected() && port_is_used(it->first, values)) { TRectD bbox; (*(it->second))->getBBox(r_frame, bbox, riAux); /*- 素材が存在する場合、portTilesにコントロール画像タイルを格納 -*/ if (!bbox.isEmpty()) { if (bbox == TConsts::infiniteRectD) // There could be an infinite // bbox - deal with it bbox = ri.m_affine.inv() * outTileBBox; if (frame <= pcFrame) { // This frame will not actually be rolled. However, it was // dryComputed - so, declare the same here. (*it->second)->dryCompute(bbox, r_frame, riAux); } else { tmp = new TTile; if (isPrecomputingEnabled) (*it->second) ->allocateAndCompute(*tmp, bbox.getP00(), convert(bbox).getSize(), 0, r_frame, riAux); else { std::string alias = "CTRL: " + (*(it->second))->getAlias(r_frame, riAux); TRasterImageP rimg = TImageCache::instance()->get(alias, false); if (rimg) { tmp->m_pos = bbox.getP00(); tmp->setRaster(rimg->getRaster()); } else { (*it->second) ->allocateAndCompute(*tmp, bbox.getP00(), convert(bbox).getSize(), 0, r_frame, riAux); addRenderCache(alias, TRasterImageP(tmp->getRaster())); } } porttiles[it->first] = tmp; } } } } if (frame > pcFrame) { // Invoke the actual rolling procedure roll_particles(tile, porttiles, riAux, myParticles, values, 0, 0, frame, curr_frame, level_n, &random_level, 1, last_frame, totalparticles); // Store the rolled data in the particles manager if (!particlesData->m_calculated || particlesData->m_frame + particlesData->m_maxTrail < frame) { particlesData->m_frame = frame; particlesData->m_particles = myParticles; particlesData->m_random = myRandom; particlesData->buildMaxTrail(); particlesData->m_calculated = true; particlesData->m_totalParticles = totalparticles; } } // Render the particles if the distance from current frame is a trail // multiple if (frame >= startframe - 1 && !(dist_frame % (values.trailstep_val > 1.0 ? (int)values.trailstep_val : 1))) { // Store the maximum particle size before the do_render cycle std::list<Particle>::iterator pt; for (pt = myParticles.begin(); pt != myParticles.end(); ++pt) { Particle &part = *pt; int ndx = part.frame % last_frame[part.level]; std::pair<int, int> ndxPair(part.level, ndx); std::map<std::pair<int, int>, double>::iterator it = partScales.find(ndxPair); if (it != partScales.end()) it->second = std::max(part.scale, it->second); else partScales[ndxPair] = part.scale; } if (values.toplayer_val == ParticlesFx::TOP_SMALLER || values.toplayer_val == ParticlesFx::TOP_BIGGER) myParticles.sort(ComparebySize()); if (values.toplayer_val == ParticlesFx::TOP_SMALLER) { std::list<Particle>::iterator pt; for (pt = myParticles.begin(); pt != myParticles.end(); ++pt) { Particle &part = *pt; if (dist_frame <= part.trail && part.scale && part.lifetime > 0 && part.lifetime <= part.genlifetime) // This last... shouldn't always be? { do_render(flash, &part, tile, part_ports, porttiles, ri, p_size, p_offset, last_frame[part.level], partLevel, values, opacity_range, dist_frame, partScales); } } } else { std::list<Particle>::reverse_iterator pt; for (pt = myParticles.rbegin(); pt != myParticles.rend(); ++pt) { Particle &part = *pt; if (dist_frame <= part.trail && part.scale && part.lifetime > 0 && part.lifetime <= part.genlifetime) // Same here..? { do_render(flash, &part, tile, part_ports, porttiles, ri, p_size, p_offset, last_frame[part.level], partLevel, values, opacity_range, dist_frame, partScales); } } } } std::map<int, TTile *>::iterator it; for (it = porttiles.begin(); it != porttiles.end(); ++it) delete it->second; } }
static void render_shadow_volumes(world_t w, float lerp) { if ( !w->do_shadows ) return; do_render(w, lerp, w->light); }
void MatchScene::handle_event_for_all(SDL_Event& e) { if ( is_typing && e.type == SDL_TEXTINPUT ) { /* Add new text onto the end of our text */ chat_message += e.text.text; chat_texture.load_from_rendered_text(chat_message, Fonts::get_instance()->MESSAGE_FONT, Colors::BLACK); chat_texture.set_position_by_screen_factor(0.5, 0.5); } if ( e.type == SDL_KEYDOWN ) { switch ( e.key.keysym.sym ) { case SDLK_ESCAPE: if ( !is_game_over ) { is_meta_menu_up = !is_meta_menu_up; is_action_overlay_up = false; if ( are_saved_matches_up ) { are_saved_matches_up = false; } } break; case SDLK_BACKSPACE: if ( is_typing ) { if ( chat_message.size() > enter_message.size() ) { chat_message = chat_message.substr(0, chat_message.size() - 1); chat_texture.load_from_rendered_text(chat_message, Fonts::get_instance()->MESSAGE_FONT, Colors::BLACK); chat_texture.set_position_by_screen_factor(0.5, 0.5); } } else { need_more_input = false; } break; case SDLK_RETURN: std::string actual_chat_message = ""; if ( is_typing ) { actual_chat_message = chat_message.substr(enter_message.size(), chat_message.size() - enter_message.size()); } if ( is_typing && actual_chat_message != "" ) { if ( actual_chat_message.size() > 3 && actual_chat_message.substr(0, 3).compare("#s ") == 0 ) { int x = 0; save_game_name = actual_chat_message.substr(3, actual_chat_message.size()); size_t p = save_game_name.find_first_not_of(" \t"); save_game_name.erase(0, p); p = save_game_name.find_last_not_of(" \t"); if ( std::string::npos != p ) { save_game_name.erase(p + 1); } if ( save_game_name.empty() ) { save_game_name = "No Name"; } } else { BattleshipsRCP rcp(message_sender); rcp.send_chat(actual_chat_message); } chat_message = ""; chat_texture.load_from_rendered_text(" ", Fonts::get_instance()->MESSAGE_FONT, Colors::BLACK); chat_texture.set_position_by_screen_factor(0.5, 0.5); } if ( is_typing ) { chat_message = ""; SDL_StopTextInput(); } else { chat_message += enter_message; chat_texture.load_from_rendered_text(chat_message, Fonts::get_instance()->MESSAGE_FONT, Colors::BLACK); chat_texture.set_position_by_screen_factor(0.5, 0.5); SDL_StartTextInput(); } is_typing = !is_typing; break; } switch ( e.key.keysym.scancode ) { case SDL_SCANCODE_DOWN: saved_game_cursor = saved_game_cursor + num_saved_games_shown < saved_matches.size() ? saved_game_cursor + num_saved_games_shown : saved_game_cursor; do_render(); break; case SDL_SCANCODE_UP: saved_game_cursor = saved_game_cursor - num_saved_games_shown >= 0 ? saved_game_cursor - num_saved_games_shown : saved_game_cursor; do_render(); break; } } else if ( e.type == SDL_QUIT ) { BattleshipsRCP rcp(message_sender); rcp.quit_game(); Stage::get_instance()->quit_game(); } if ( are_saved_matches_up ) { bool needs_cleanup = false; for ( auto& m : saved_matches ) { m->handle_event(e); if ( m->has_been_clicked() && turn_of == real_side ) { BattleshipsRCP rcp(message_sender); rcp.load_game(m->get_game_id()); is_loading_match = true; needs_cleanup = true; } } if ( needs_cleanup ) { saved_matches.clear(); are_saved_matches_up = false; } } if ( is_meta_menu_up ) { if ( !is_local_play ) { if ( real_side != Player::Side::SPECTATOR && currentPhase != Enums::MatchPhase::WAITING_FOR_OTHER_PLAYER && turn_of == real_side ) { load_game.enable(); } else { load_game.disable(); } if ( real_side != Player::Side::SPECTATOR && currentPhase == Enums::MatchPhase::GAMEPLAY && !is_game_over ) { save_game.enable(); } else { save_game.disable(); } save_game.handle_event(e); load_game.handle_event(e); } quit.handle_event(e); if ( save_game.has_been_clicked() ) { BattleshipsRCP rcp(message_sender); if ( rcp.save_game(save_game_name) ) { Stage::get_instance()->notify("Match saved!", 4000); } else { Stage::get_instance()->notify("Save failed!", 4000); } is_meta_menu_up = false; } else if ( load_game.has_been_clicked() ) { BattleshipsRCP rcp(message_sender); auto matches = rcp.get_saved_games(); if ( matches.size() == 0 ) { Stage::get_instance()->notify("No saved matches with both of you as players to load!", 2000); } else { saved_matches.clear(); saved_game_cursor = 0; double curr = 0.1; double offset = 1.0 / matches.size(); for ( auto & m : matches ) { std::shared_ptr<MatchButton> b(new MatchButton(m.first, m.second)); b->set_position_by_screen_factor(0.5, curr); curr += offset; saved_matches.push_back(b); if ( curr >= num_saved_games_shown * offset + 0.1 ) { curr = 0.1; } } Stage::get_instance()->notify("Pick the match you wish to load.", 4000); Stage::get_instance()->notify("Use the UP and DOWN arrows to navigate through your games.", 8000); Stage::get_instance()->notify("Press Escape to return to the metamenu.", 8000); are_saved_matches_up = true; } is_meta_menu_up = false; } else if ( quit.has_been_clicked() ) { BattleshipsRCP rcp(message_sender); rcp.quit_game(); if ( real_side == Player::Side::SPECTATOR ) { Stage::get_instance()->pop_scene(); } is_meta_menu_up = false; } } }