#include <camera.hpp>
Inherits GameObject, and ScriptInterface.
Public Types | |
enum | CameraMode { NORMAL, AUTOSCROLL, SCROLLTO, MANUAL } |
Public Member Functions | |
Camera (Sector *sector, std::string name="") | |
virtual | ~Camera () |
void | parse (const Reader &reader) |
parse camera mode from lisp file | |
void | reset (const Vector &tuxpos) |
reset camera position | |
const Vector & | get_translation () const |
return camera position | |
virtual void | update (float elapsed_time) |
This function is called once per frame and allows the object to update it's state. | |
virtual void | draw (DrawingContext &) |
The GameObject should draw itself onto the provided DrawingContext if this function is called. | |
virtual void | expose (HSQUIRRELVM vm, SQInteger table_idx) |
virtual void | unexpose (HSQUIRRELVM vm, SQInteger table_idx) |
void | shake (float speed, float x, float y) |
void | set_scrolling (int scroll_x, int scroll_y) |
void | scroll_to (const Vector &goal, float scrolltime) |
scroll the upper left edge of the camera in scrolltime seconds to the position goal | |
void | reload_config () |
Vector | get_center () const |
get the coordinates of the point directly in the center of this camera | |
Public Attributes | |
CameraMode | mode |
Private Types | |
enum | LookaheadMode { LOOKAHEAD_NONE, LOOKAHEAD_LEFT, LOOKAHEAD_RIGHT } |
The camera basically provides lookahead on the left or right side or is undecided. More... | |
Private Member Functions | |
void | update_scroll_normal (float elapsed_time) |
void | update_scroll_autoscroll (float elapsed_time) |
void | update_scroll_to (float elapsed_time) |
void | keep_in_bounds (Vector &vector) |
void | shake () |
Camera (const Camera &) | |
Camera & | operator= (const Camera &) |
Private Attributes | |
Vector | translation |
Sector * | sector |
LookaheadMode | lookahead_mode |
float | changetime |
Vector | lookahead_pos |
Vector | peek_pos |
Vector | cached_translation |
std::auto_ptr< Path > | autoscroll_path |
std::auto_ptr< PathWalker > | autoscroll_walker |
Timer | shaketimer |
float | shakespeed |
float | shakedepth_x |
float | shakedepth_y |
Vector | scroll_from |
Vector | scroll_goal |
float | scroll_to_pos |
float | scrollspeed |
CameraConfig * | config |
Definition at line 33 of file camera.hpp.
enum Camera::CameraMode |
Definition at line 73 of file camera.hpp.
00074 { 00075 NORMAL, AUTOSCROLL, SCROLLTO, MANUAL 00076 };
enum Camera::LookaheadMode [private] |
The camera basically provides lookahead on the left or right side or is undecided.
Definition at line 96 of file camera.hpp.
00096 { 00097 LOOKAHEAD_NONE, LOOKAHEAD_LEFT, LOOKAHEAD_RIGHT 00098 };
Camera::Camera | ( | Sector * | sector, | |
std::string | name = "" | |||
) |
Definition at line 114 of file camera.cpp.
References config, and reload_config().
00114 : 00115 mode(NORMAL), 00116 translation(), 00117 sector(newsector), 00118 lookahead_mode(LOOKAHEAD_NONE), 00119 changetime(), 00120 lookahead_pos(), 00121 peek_pos(), 00122 cached_translation(), 00123 autoscroll_path(), 00124 autoscroll_walker(), 00125 shaketimer(), 00126 shakespeed(), 00127 shakedepth_x(), 00128 shakedepth_y(), 00129 scroll_from(), 00130 scroll_goal(), 00131 scroll_to_pos(), 00132 scrollspeed(), 00133 config() 00134 { 00135 this->name = name; 00136 config = new CameraConfig(); 00137 reload_config(); 00138 }
Camera::~Camera | ( | ) | [virtual] |
Camera::Camera | ( | const Camera & | ) | [private] |
void Camera::parse | ( | const Reader & | reader | ) |
parse camera mode from lisp file
Definition at line 172 of file camera.cpp.
References AUTOSCROLL, autoscroll_path, autoscroll_walker, lisp::Lisp::get(), lisp::Lisp::get_lisp(), MANUAL, mode, and NORMAL.
Referenced by Sector::parse_object().
00173 { 00174 std::string modename; 00175 00176 reader.get("mode", modename); 00177 if(modename == "normal") { 00178 mode = NORMAL; 00179 } else if(modename == "autoscroll") { 00180 mode = AUTOSCROLL; 00181 00182 const lisp::Lisp* pathLisp = reader.get_lisp("path"); 00183 if(pathLisp == NULL) 00184 throw std::runtime_error("No path specified in autoscroll camera."); 00185 00186 autoscroll_path.reset(new Path()); 00187 autoscroll_path->read(*pathLisp); 00188 autoscroll_walker.reset(new PathWalker(autoscroll_path.get())); 00189 } else if(modename == "manual") { 00190 mode = MANUAL; 00191 } else { 00192 std::stringstream str; 00193 str << "invalid camera mode '" << modename << "'found in worldfile."; 00194 throw std::runtime_error(str.str()); 00195 } 00196 }
void Camera::reset | ( | const Vector & | tuxpos | ) |
reset camera position
Definition at line 199 of file camera.cpp.
References cached_translation, keep_in_bounds(), SCREEN_HEIGHT, SCREEN_WIDTH, shakespeed, shaketimer, Timer::stop(), translation, Vector::x, and Vector::y.
Referenced by Sector::activate(), TitleScreen::make_tux_jump(), and FlipLevelTransformer::transform_sector().
00200 { 00201 translation.x = tuxpos.x - SCREEN_WIDTH/2; 00202 translation.y = tuxpos.y - SCREEN_HEIGHT/2; 00203 00204 shakespeed = 0; 00205 shaketimer.stop(); 00206 keep_in_bounds(translation); 00207 00208 cached_translation = translation; 00209 }
const Vector & Camera::get_translation | ( | ) | const |
return camera position
Definition at line 166 of file camera.cpp.
References translation.
Referenced by Sector::draw(), Player::draw(), Sector::get_active_region(), SpriteParticle::update(), RainParticleSystem::update(), Particles::update(), MagicBlock::update(), Fireworks::update(), CometParticleSystem::update(), and Bullet::update().
00167 { 00168 return translation; 00169 }
void Camera::update | ( | float | elapsed_time | ) | [virtual] |
This function is called once per frame and allows the object to update it's state.
The elapsed_time is the time since the last frame in seconds and should be the base for all timed calculations (don't use SDL_GetTicks directly as this will fail in pause mode)
Implements GameObject.
Definition at line 236 of file camera.cpp.
References AUTOSCROLL, mode, NORMAL, SCROLLTO, shake(), update_scroll_autoscroll(), update_scroll_normal(), and update_scroll_to().
00237 { 00238 switch(mode) { 00239 case NORMAL: 00240 update_scroll_normal(elapsed_time); 00241 break; 00242 case AUTOSCROLL: 00243 update_scroll_autoscroll(elapsed_time); 00244 break; 00245 case SCROLLTO: 00246 update_scroll_to(elapsed_time); 00247 break; 00248 default: 00249 break; 00250 } 00251 shake(); 00252 }
void Camera::draw | ( | DrawingContext & | ) | [virtual] |
The GameObject should draw itself onto the provided DrawingContext if this function is called.
Implements GameObject.
Definition at line 161 of file camera.cpp.
void Camera::expose | ( | HSQUIRRELVM | vm, | |
SQInteger | table_idx | |||
) | [virtual] |
Implements ScriptInterface.
Definition at line 146 of file camera.cpp.
References scripting::expose_object(), and GameObject::name.
00147 { 00148 if(name.empty()) return; 00149 scripting::Camera* _this = new scripting::Camera(this); 00150 expose_object(vm, table_idx, _this, name, true); 00151 }
void Camera::unexpose | ( | HSQUIRRELVM | vm, | |
SQInteger | table_idx | |||
) | [virtual] |
Implements ScriptInterface.
Definition at line 154 of file camera.cpp.
References GameObject::name, and scripting::unexpose_object().
00155 { 00156 if(name.empty()) return; 00157 scripting::unexpose_object(vm, table_idx, name); 00158 }
void Camera::shake | ( | float | speed, | |
float | x, | |||
float | y | |||
) |
Definition at line 212 of file camera.cpp.
References shakedepth_x, shakedepth_y, shakespeed, shaketimer, and Timer::start().
Referenced by Player::collision_solid(), IceCrusher::collision_solid(), and Yeti::drop_stalactite().
00213 { 00214 shaketimer.start(time); 00215 shakedepth_x = x; 00216 shakedepth_y = y; 00217 shakespeed = M_PI/2 / time; 00218 }
void Camera::set_scrolling | ( | int | scroll_x, | |
int | scroll_y | |||
) | [inline] |
Definition at line 59 of file camera.hpp.
References translation, Vector::x, and Vector::y.
00060 { 00061 translation.x = scroll_x; 00062 translation.y = scroll_y; 00063 }
void Camera::scroll_to | ( | const Vector & | goal, | |
float | scrolltime | |||
) |
scroll the upper left edge of the camera in scrolltime seconds to the position goal
Definition at line 221 of file camera.cpp.
References keep_in_bounds(), mode, scroll_from, scroll_goal, scroll_to_pos, scrollspeed, SCROLLTO, and translation.
00222 { 00223 scroll_from = translation; 00224 scroll_goal = goal; 00225 keep_in_bounds(scroll_goal); 00226 00227 scroll_to_pos = 0; 00228 scrollspeed = 1.0 / scrolltime; 00229 mode = SCROLLTO; 00230 }
void Camera::reload_config | ( | ) |
Definition at line 255 of file camera.cpp.
References config, CameraConfig::load(), log_debug, and log_info.
Referenced by Camera().
00256 { 00257 if(PHYSFS_exists("camera.cfg")) { 00258 try { 00259 config->load("camera.cfg"); 00260 log_info << "Loaded camera.cfg." << std::endl; 00261 } catch(std::exception &e) { 00262 log_debug << "Couldn't load camera.cfg, using defaults (" 00263 << e.what() << ")" << std::endl; 00264 } 00265 } 00266 }
Vector Camera::get_center | ( | ) | const |
get the coordinates of the point directly in the center of this camera
Definition at line 632 of file camera.cpp.
References SCREEN_HEIGHT, SCREEN_WIDTH, and translation.
Referenced by GameSession::update(), and AmbientSound::update().
00632 { 00633 return translation + Vector(SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2); 00634 }
void Camera::update_scroll_normal | ( | float | elapsed_time | ) | [private] |
Definition at line 304 of file camera.cpp.
References cached_translation, CAMERA_EPSILON, changetime, clamp(), CameraConfig::clamp_x, CameraConfig::clamp_y, config, Player::dir, CameraConfig::dirchange_time, DOWN, CameraConfig::dynamic_max_speed_x, CameraConfig::dynamic_speed_sm, CameraConfig::edge_x, Player::fall_mode, Player::FALLING, game_time, MovingObject::get_bbox(), Rectf::get_bottom(), Rectf::get_height(), Sector::get_height(), Rectf::get_middle(), Sector::get_width(), Player::is_dying(), Player::JUMPING, keep_in_bounds(), CameraConfig::kirby_rectsize_x, CameraConfig::kirby_rectsize_y, Player::last_ground_y, LEFT, LOOKAHEAD_LEFT, lookahead_mode, LOOKAHEAD_NONE, lookahead_pos, LOOKAHEAD_RIGHT, CameraConfig::max_speed_x, CameraConfig::max_speed_y, Rectf::p2, PEEK_ARRIVE_RATIO, peek_pos, Player::peeking_direction_x(), Player::peeking_direction_y(), Sector::player, RIGHT, SCREEN_HEIGHT, SCREEN_WIDTH, sector, CameraConfig::sensitive_x, CameraConfig::target_x, CameraConfig::target_y, Player::TRAMPOLINE_JUMP, translation, UP, Vector::x, CameraConfig::xmode, Vector::y, and CameraConfig::ymode.
Referenced by update().
00305 { 00306 const CameraConfig& config = *(this->config); 00307 Player* player = sector->player; 00308 // TODO: co-op mode needs a good camera 00309 Vector player_pos(player->get_bbox().get_middle().x, 00310 player->get_bbox().get_bottom()); 00311 static Vector last_player_pos = player_pos; 00312 Vector player_delta = player_pos - last_player_pos; 00313 last_player_pos = player_pos; 00314 00315 // check that we don't have division by zero later 00316 if(elapsed_time < CAMERA_EPSILON) 00317 return; 00318 00319 /****** Vertical Scrolling part ******/ 00320 int ymode = config.ymode; 00321 00322 if(player->is_dying() || sector->get_height() == 19*32) { 00323 ymode = 0; 00324 } 00325 if(ymode == 1) { 00326 cached_translation.y = player_pos.y - SCREEN_HEIGHT * config.target_y; 00327 } 00328 if(ymode == 2) { 00329 // target_y is the high we target our scrolling at. This is not always the 00330 // high of the player, but if he is jumping upwards we should use the 00331 // position where he last touched the ground. (this probably needs 00332 // exceptions for trampolines and similar things in the future) 00333 float target_y; 00334 if(player->fall_mode == Player::JUMPING) 00335 target_y = player->last_ground_y + player->get_bbox().get_height(); 00336 else 00337 target_y = player->get_bbox().p2.y; 00338 target_y -= SCREEN_HEIGHT * config.target_y; 00339 00340 // delta_y is the distance we'd have to travel to directly reach target_y 00341 float delta_y = cached_translation.y - target_y; 00342 // speed is the speed the camera would need to reach target_y in this frame 00343 float speed_y = delta_y / elapsed_time; 00344 00345 // limit the camera speed when jumping upwards 00346 if(player->fall_mode != Player::FALLING 00347 && player->fall_mode != Player::TRAMPOLINE_JUMP) { 00348 speed_y = clamp(speed_y, -config.max_speed_y, config.max_speed_y); 00349 } 00350 00351 // scroll with calculated speed 00352 cached_translation.y -= speed_y * elapsed_time; 00353 } 00354 if(ymode == 3) { 00355 float halfsize = config.kirby_rectsize_y * 0.5f; 00356 cached_translation.y = clamp(cached_translation.y, 00357 player_pos.y - SCREEN_HEIGHT * (0.5f + halfsize), 00358 player_pos.y - SCREEN_HEIGHT * (0.5f - halfsize)); 00359 } 00360 if(ymode == 4) { 00361 float upperend = SCREEN_HEIGHT * config.edge_x; 00362 float lowerend = SCREEN_HEIGHT * (1 - config.edge_x); 00363 00364 if (player_delta.y < -CAMERA_EPSILON) { 00365 // walking left 00366 lookahead_pos.y -= player_delta.y * config.dynamic_speed_sm; 00367 00368 if(lookahead_pos.y > lowerend) { 00369 lookahead_pos.y = lowerend; 00370 } 00371 } else if (player_delta.y > CAMERA_EPSILON) { 00372 // walking right 00373 lookahead_pos.y -= player_delta.y * config.dynamic_speed_sm; 00374 if(lookahead_pos.y < upperend) { 00375 lookahead_pos.y = upperend; 00376 } 00377 } 00378 00379 // adjust for level ends 00380 if (player_pos.y < upperend) { 00381 lookahead_pos.y = upperend; 00382 } 00383 if (player_pos.y > sector->get_width() - upperend) { 00384 lookahead_pos.y = lowerend; 00385 } 00386 00387 cached_translation.y = player_pos.y - lookahead_pos.y; 00388 } 00389 00390 translation.y = cached_translation.y; 00391 00392 if(ymode != 0) { 00393 float top_edge, bottom_edge; 00394 if(config.clamp_y <= 0) { 00395 top_edge = 0; 00396 bottom_edge = SCREEN_HEIGHT; 00397 } else { 00398 top_edge = SCREEN_HEIGHT*config.clamp_y; 00399 bottom_edge = SCREEN_HEIGHT*(1-config.clamp_y); 00400 } 00401 00402 float peek_to = 0; 00403 float translation_compensation = player_pos.y - translation.y; 00404 00405 if(player->peeking_direction_y() == ::UP) { 00406 peek_to = bottom_edge - translation_compensation; 00407 } else if(player->peeking_direction_y() == ::DOWN) { 00408 peek_to = top_edge - translation_compensation; 00409 } 00410 00411 float peek_move = (peek_to - peek_pos.y) * PEEK_ARRIVE_RATIO; 00412 if(fabs(peek_move) < 1.0) { 00413 peek_move = 0.0; 00414 } 00415 00416 peek_pos.y += peek_move; 00417 00418 translation.y -= peek_pos.y; 00419 00420 if(config.clamp_y > 0) { 00421 translation.y = clamp(translation.y, 00422 player_pos.y - SCREEN_HEIGHT * (1-config.clamp_y), 00423 player_pos.y - SCREEN_HEIGHT * config.clamp_y); 00424 cached_translation.y = clamp(cached_translation.y, 00425 player_pos.y - SCREEN_HEIGHT * (1-config.clamp_y), 00426 player_pos.y - SCREEN_HEIGHT * config.clamp_y); 00427 } 00428 } 00429 00430 /****** Horizontal scrolling part *******/ 00431 int xmode = config.xmode; 00432 00433 if(player->is_dying()) 00434 xmode = 0; 00435 00436 if(xmode == 1) { 00437 cached_translation.x = player_pos.x - SCREEN_WIDTH * config.target_x; 00438 } 00439 if(xmode == 2) { 00440 // our camera is either in leftscrolling, rightscrolling or 00441 // nonscrollingmode. 00442 // 00443 // when suddenly changing directions while scrolling into the other 00444 // direction abort scrolling, since tux might be going left/right at a 00445 // relatively small part of the map (like when jumping upwards) 00446 00447 // Find out direction in which the player moves 00448 LookaheadMode walkDirection; 00449 if (player_delta.x < -CAMERA_EPSILON) walkDirection = LOOKAHEAD_LEFT; 00450 else if (player_delta.x > CAMERA_EPSILON) walkDirection = LOOKAHEAD_RIGHT; 00451 else if (player->dir == ::LEFT) walkDirection = LOOKAHEAD_LEFT; 00452 else walkDirection = LOOKAHEAD_RIGHT; 00453 00454 float LEFTEND, RIGHTEND; 00455 if(config.sensitive_x > 0) { 00456 LEFTEND = SCREEN_WIDTH * config.sensitive_x; 00457 RIGHTEND = SCREEN_WIDTH * (1-config.sensitive_x); 00458 } else { 00459 LEFTEND = SCREEN_WIDTH; 00460 RIGHTEND = 0; 00461 } 00462 00463 if(lookahead_mode == LOOKAHEAD_NONE) { 00464 /* if we're undecided then look if we crossed the left or right 00465 * "sensitive" area */ 00466 if(player_pos.x < cached_translation.x + LEFTEND) { 00467 lookahead_mode = LOOKAHEAD_LEFT; 00468 } else if(player_pos.x > cached_translation.x + RIGHTEND) { 00469 lookahead_mode = LOOKAHEAD_RIGHT; 00470 } 00471 /* at the ends of a level it's obvious which way we will go */ 00472 if(player_pos.x < SCREEN_WIDTH*0.5) { 00473 lookahead_mode = LOOKAHEAD_RIGHT; 00474 } else if(player_pos.x >= sector->get_width() - SCREEN_WIDTH*0.5) { 00475 lookahead_mode = LOOKAHEAD_LEFT; 00476 } 00477 00478 changetime = -1; 00479 } else if(lookahead_mode != walkDirection) { 00480 /* player changed direction while camera was scrolling... 00481 * he has to do this for a certain time to add robustness against 00482 * sudden changes */ 00483 if(changetime < 0) { 00484 changetime = game_time; 00485 } else if(game_time - changetime > config.dirchange_time) { 00486 if(lookahead_mode == LOOKAHEAD_LEFT && 00487 player_pos.x > cached_translation.x + RIGHTEND) { 00488 lookahead_mode = LOOKAHEAD_RIGHT; 00489 } else if(lookahead_mode == LOOKAHEAD_RIGHT && 00490 player_pos.x < cached_translation.x + LEFTEND) { 00491 lookahead_mode = LOOKAHEAD_LEFT; 00492 } else { 00493 lookahead_mode = LOOKAHEAD_NONE; 00494 } 00495 } 00496 } else { 00497 changetime = -1; 00498 } 00499 00500 LEFTEND = SCREEN_WIDTH * config.edge_x; 00501 RIGHTEND = SCREEN_WIDTH * (1-config.edge_x); 00502 00503 // calculate our scroll target depending on scroll mode 00504 float target_x; 00505 if(lookahead_mode == LOOKAHEAD_LEFT) 00506 target_x = player_pos.x - RIGHTEND; 00507 else if(lookahead_mode == LOOKAHEAD_RIGHT) 00508 target_x = player_pos.x - LEFTEND; 00509 else 00510 target_x = cached_translation.x; 00511 00512 // that's the distance we would have to travel to reach target_x 00513 float delta_x = cached_translation.x - target_x; 00514 // the speed we'd need to travel to reach target_x in this frame 00515 float speed_x = delta_x / elapsed_time; 00516 00517 // limit our speed 00518 float player_speed_x = player_delta.x / elapsed_time; 00519 float maxv = config.max_speed_x + (fabsf(player_speed_x * config.dynamic_max_speed_x)); 00520 speed_x = clamp(speed_x, -maxv, maxv); 00521 00522 // apply scrolling 00523 cached_translation.x -= speed_x * elapsed_time; 00524 } 00525 if(xmode == 3) { 00526 float halfsize = config.kirby_rectsize_x * 0.5f; 00527 cached_translation.x = clamp(cached_translation.x, 00528 player_pos.x - SCREEN_WIDTH * (0.5f + halfsize), 00529 player_pos.x - SCREEN_WIDTH * (0.5f - halfsize)); 00530 } 00531 if(xmode == 4) { 00532 float LEFTEND = SCREEN_WIDTH * config.edge_x; 00533 float RIGHTEND = SCREEN_WIDTH * (1 - config.edge_x); 00534 00535 if (player_delta.x < -CAMERA_EPSILON) { 00536 // walking left 00537 lookahead_pos.x -= player_delta.x * config.dynamic_speed_sm; 00538 if(lookahead_pos.x > RIGHTEND) { 00539 lookahead_pos.x = RIGHTEND; 00540 } 00541 00542 } else if (player_delta.x > CAMERA_EPSILON) { 00543 // walking right 00544 lookahead_pos.x -= player_delta.x * config.dynamic_speed_sm; 00545 if(lookahead_pos.x < LEFTEND) { 00546 lookahead_pos.x = LEFTEND; 00547 } 00548 } 00549 00550 // adjust for level ends 00551 if (player_pos.x < LEFTEND) { 00552 lookahead_pos.x = LEFTEND; 00553 } 00554 if (player_pos.x > sector->get_width() - LEFTEND) { 00555 lookahead_pos.x = RIGHTEND; 00556 } 00557 00558 cached_translation.x = player_pos.x - lookahead_pos.x; 00559 } 00560 00561 translation.x = cached_translation.x; 00562 00563 if(xmode != 0) { 00564 float left_edge, right_edge; 00565 if(config.clamp_x <= 0) { 00566 left_edge = 0; 00567 right_edge = SCREEN_WIDTH; 00568 } else { 00569 left_edge = SCREEN_WIDTH*config.clamp_x; 00570 right_edge = SCREEN_WIDTH*(1-config.clamp_x); 00571 } 00572 00573 float peek_to = 0; 00574 float translation_compensation = player_pos.x - translation.x; 00575 00576 if(player->peeking_direction_x() == ::LEFT) { 00577 peek_to = right_edge - translation_compensation; 00578 } else if(player->peeking_direction_x() == ::RIGHT) { 00579 peek_to = left_edge - translation_compensation; 00580 } 00581 00582 float peek_move = (peek_to - peek_pos.x) * PEEK_ARRIVE_RATIO; 00583 if(fabs(peek_move) < 1.0) { 00584 peek_move = 0.0; 00585 } 00586 00587 peek_pos.x += peek_move; 00588 00589 translation.x -= peek_pos.x; 00590 00591 if(config.clamp_x > 0) { 00592 translation.x = clamp(translation.x, 00593 player_pos.x - SCREEN_WIDTH * (1-config.clamp_x), 00594 player_pos.x - SCREEN_WIDTH * config.clamp_x); 00595 00596 cached_translation.x = clamp(cached_translation.x, 00597 player_pos.x - SCREEN_WIDTH * (1-config.clamp_x), 00598 player_pos.x - SCREEN_WIDTH * config.clamp_x); 00599 } 00600 } 00601 00602 keep_in_bounds(translation); 00603 keep_in_bounds(cached_translation); 00604 }
void Camera::update_scroll_autoscroll | ( | float | elapsed_time | ) | [private] |
Definition at line 607 of file camera.cpp.
References autoscroll_walker, Player::is_dying(), keep_in_bounds(), Sector::player, sector, and translation.
Referenced by update().
00608 { 00609 Player* player = sector->player; 00610 if(player->is_dying()) 00611 return; 00612 00613 translation = autoscroll_walker->advance(elapsed_time); 00614 00615 keep_in_bounds(translation); 00616 }
void Camera::update_scroll_to | ( | float | elapsed_time | ) | [private] |
Definition at line 619 of file camera.cpp.
References MANUAL, mode, scroll_from, scroll_goal, scroll_to_pos, scrollspeed, and translation.
Referenced by update().
00620 { 00621 scroll_to_pos += elapsed_time * scrollspeed; 00622 if(scroll_to_pos >= 1.0) { 00623 mode = MANUAL; 00624 translation = scroll_goal; 00625 return; 00626 } 00627 00628 translation = scroll_from + (scroll_goal - scroll_from) * scroll_to_pos; 00629 }
void Camera::keep_in_bounds | ( | Vector & | vector | ) | [private] |
Definition at line 279 of file camera.cpp.
References clamp(), Sector::get_height(), Sector::get_width(), SCREEN_HEIGHT, SCREEN_WIDTH, sector, translation, Vector::x, and Vector::y.
Referenced by reset(), scroll_to(), update_scroll_autoscroll(), and update_scroll_normal().
00280 { 00281 float width = sector->get_width(); 00282 float height = sector->get_height(); 00283 00284 // don't scroll before the start or after the level's end 00285 translation.x = clamp(translation.x, 0, width - SCREEN_WIDTH); 00286 translation.y = clamp(translation.y, 0, height - SCREEN_HEIGHT); 00287 00288 if (height < SCREEN_HEIGHT) 00289 translation.y = height/2.0 - SCREEN_HEIGHT/2.0; 00290 if (width < SCREEN_WIDTH) 00291 translation.x = width/2.0 - SCREEN_WIDTH/2.0; 00292 }
void Camera::shake | ( | ) | [private] |
Definition at line 295 of file camera.cpp.
References Timer::get_timegone(), shakedepth_x, shakedepth_y, shakespeed, shaketimer, Timer::started(), translation, Vector::x, and Vector::y.
Referenced by update().
00296 { 00297 if(shaketimer.started()) { 00298 translation.x -= sin(shaketimer.get_timegone() * shakespeed) * shakedepth_x; 00299 translation.y -= sin(shaketimer.get_timegone() * shakespeed) * shakedepth_y; 00300 } 00301 }
Definition at line 77 of file camera.hpp.
Referenced by parse(), scroll_to(), update(), and update_scroll_to().
Vector Camera::translation [private] |
Definition at line 101 of file camera.hpp.
Referenced by get_center(), get_translation(), keep_in_bounds(), reset(), scroll_to(), set_scrolling(), shake(), update_scroll_autoscroll(), update_scroll_normal(), and update_scroll_to().
Sector* Camera::sector [private] |
Definition at line 103 of file camera.hpp.
Referenced by keep_in_bounds(), update_scroll_autoscroll(), and update_scroll_normal().
LookaheadMode Camera::lookahead_mode [private] |
float Camera::changetime [private] |
Vector Camera::lookahead_pos [private] |
Vector Camera::peek_pos [private] |
Vector Camera::cached_translation [private] |
std::auto_ptr<Path> Camera::autoscroll_path [private] |
std::auto_ptr<PathWalker> Camera::autoscroll_walker [private] |
Timer Camera::shaketimer [private] |
float Camera::shakespeed [private] |
float Camera::shakedepth_x [private] |
float Camera::shakedepth_y [private] |
Vector Camera::scroll_from [private] |
Vector Camera::scroll_goal [private] |
float Camera::scroll_to_pos [private] |
float Camera::scrollspeed [private] |
CameraConfig* Camera::config [private] |
Definition at line 128 of file camera.hpp.
Referenced by Camera(), reload_config(), update_scroll_normal(), and ~Camera().