431a9c00a5
On Linux and macOS, using Clang to compile OpenStarbound produces about 400 MB worth of warnings during the build, making the compiler output unreadable and slowing the build down considerably. 99% of the warnings were unqualified uses of std::move and std::forward, which are now all properly qualified. Fixed a few other minor warnings about non-virtual destructors and some uses of std::move preventing copy elision on temporary objects. Most remaining warnings are now unused parameters.
131 lines
4.0 KiB
C++
131 lines
4.0 KiB
C++
#ifndef STAR_WORLD_CAMERA_HPP
|
|
#define STAR_WORLD_CAMERA_HPP
|
|
|
|
#include "StarWorldGeometry.hpp"
|
|
#include "StarGameTypes.hpp"
|
|
#include "StarInterpolation.hpp"
|
|
|
|
namespace Star {
|
|
|
|
class WorldCamera {
|
|
public:
|
|
void setScreenSize(Vec2U screenSize);
|
|
Vec2U screenSize() const;
|
|
|
|
void setTargetPixelRatio(float targetPixelRatio);
|
|
void setPixelRatio(float pixelRatio);
|
|
float pixelRatio() const;
|
|
|
|
void setWorldGeometry(WorldGeometry geometry);
|
|
WorldGeometry worldGeometry() const;
|
|
|
|
// Set the camera center position (in world space) to as close to the given
|
|
// location as possible while keeping the screen within world bounds.
|
|
// Returns the actual camera position.
|
|
void setCenterWorldPosition(Vec2F const& position);
|
|
Vec2F centerWorldPosition() const;
|
|
|
|
// Transforms world coordinates into one set of screen coordinates. Since
|
|
// the world is non-euclidean, one world coordinate can transform to
|
|
// potentially an infinite number of screen coordinates. This will retrun
|
|
// the closest to the center of the screen.
|
|
Vec2F worldToScreen(Vec2F const& worldCoord) const;
|
|
|
|
// Assumes top left corner of screen is (0, 0) in screen coordinates.
|
|
Vec2F screenToWorld(Vec2F const& screen) const;
|
|
|
|
// Returns screen dimensions in world space.
|
|
RectF worldScreenRect() const;
|
|
|
|
// Returns tile dimensions of the tiles that overlap with the screen
|
|
RectI worldTileRect() const;
|
|
|
|
// Returns the position of the lower left corner of the lower left tile of
|
|
// worldTileRect, in screen coordinates.
|
|
Vec2F tileMinScreen() const;
|
|
|
|
void update(float dt);
|
|
|
|
private:
|
|
WorldGeometry m_worldGeometry;
|
|
Vec2U m_screenSize;
|
|
float m_pixelRatio = 1.0f;
|
|
float m_targetPixelRatio = 1.0f;
|
|
Vec2F m_worldCenter;
|
|
};
|
|
|
|
inline void WorldCamera::setScreenSize(Vec2U screenSize) {
|
|
m_screenSize = screenSize;
|
|
}
|
|
|
|
inline Vec2U WorldCamera::screenSize() const {
|
|
return m_screenSize;
|
|
}
|
|
|
|
inline void WorldCamera::setTargetPixelRatio(float targetPixelRatio) {
|
|
m_targetPixelRatio = targetPixelRatio;
|
|
}
|
|
|
|
inline void WorldCamera::setPixelRatio(float pixelRatio) {
|
|
m_pixelRatio = m_targetPixelRatio = pixelRatio;
|
|
}
|
|
|
|
inline float WorldCamera::pixelRatio() const {
|
|
return m_pixelRatio;
|
|
}
|
|
|
|
inline void WorldCamera::setWorldGeometry(WorldGeometry geometry) {
|
|
m_worldGeometry = std::move(geometry);
|
|
}
|
|
|
|
inline WorldGeometry WorldCamera::worldGeometry() const {
|
|
return m_worldGeometry;
|
|
}
|
|
|
|
inline Vec2F WorldCamera::centerWorldPosition() const {
|
|
return Vec2F(m_worldCenter);
|
|
}
|
|
|
|
inline Vec2F WorldCamera::worldToScreen(Vec2F const& worldCoord) const {
|
|
Vec2F wrappedCoord = m_worldGeometry.nearestTo(Vec2F(m_worldCenter), worldCoord);
|
|
return Vec2F(
|
|
(wrappedCoord[0] - m_worldCenter[0]) * (TilePixels * m_pixelRatio) + m_screenSize[0] / 2.0,
|
|
(wrappedCoord[1] - m_worldCenter[1]) * (TilePixels * m_pixelRatio) + m_screenSize[1] / 2.0
|
|
);
|
|
}
|
|
|
|
inline Vec2F WorldCamera::screenToWorld(Vec2F const& screen) const {
|
|
return Vec2F(
|
|
(screen[0] - m_screenSize[0] / 2.0) / (TilePixels * m_pixelRatio) + m_worldCenter[0],
|
|
(screen[1] - m_screenSize[1] / 2.0) / (TilePixels * m_pixelRatio) + m_worldCenter[1]
|
|
);
|
|
}
|
|
|
|
inline RectF WorldCamera::worldScreenRect() const {
|
|
// screen dimensions in world space
|
|
float w = (float)m_screenSize[0] / (TilePixels * m_pixelRatio);
|
|
float h = (float)m_screenSize[1] / (TilePixels * m_pixelRatio);
|
|
return RectF::withSize(Vec2F(m_worldCenter[0] - w / 2, m_worldCenter[1] - h / 2), Vec2F(w, h));
|
|
}
|
|
|
|
inline RectI WorldCamera::worldTileRect() const {
|
|
RectF screen = worldScreenRect();
|
|
Vec2I min = Vec2I::floor(screen.min());
|
|
Vec2I size = Vec2I::ceil(Vec2F(m_screenSize) / (TilePixels * m_pixelRatio) + (screen.min() - Vec2F(min)));
|
|
return RectI::withSize(min, size);
|
|
}
|
|
|
|
inline Vec2F WorldCamera::tileMinScreen() const {
|
|
RectF screenRect = worldScreenRect();
|
|
RectI tileRect = worldTileRect();
|
|
return (Vec2F(tileRect.min()) - screenRect.min()) * (TilePixels * m_pixelRatio);
|
|
}
|
|
|
|
inline void WorldCamera::update(float dt) {
|
|
m_pixelRatio = lerp(exp(-20.0f * dt), m_targetPixelRatio, m_pixelRatio);
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|