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;
}
}
}
