Based on my previous question, I have implemented all the recommendations received. In addition, i have implemented new features and completed road geometries.
Here is a summary of the improvements:
- Rewritten the
Colorsclass again instead of old class which is used hierarchy design. - Added curve for the road
- Added hills for the road
- Added fake fog effect to the scene (no Opengl used)
I would like to know how can I improve it further.
#define _USE_MATH_DEFINES
#include <SFML/Graphics.hpp>
#include <vector>
#include <array>
#include <memory>
#include <cmath>
#include <random>
#include <stdexcept>
#include <iostream>
#ifndef M_PI
#define M_PI 3.141592653589793238462643383
#endif
#ifndef M_E
#define M_E 2.71828182845904523536
#endif
namespace
{
float increase(float start, float increment, float max)
{
auto result = start + increment;
while (result >= max)
result -= max;
while (result < 0)
result += max;
return result;
}
float limit(float value, float min, float max)
{
return std::max(min, std::min(value, max));
}
float rumbleWidth(float projectedRoadWidth, std::size_t lanes)
{
return projectedRoadWidth / std::max(6u, 2 * lanes);
}
float laneMarkerWidth(float projectedRoadWidth, std::size_t lanes)
{
return projectedRoadWidth / std::max(32u, 8 * lanes);
}
float exponentialFog(float distance, float density)
{
return static_cast<float>(1 / std::pow(M_E, (distance * distance * density)));
}
float easeIn(float a, float b, float percent)
{
return a + (b - a) * std::pow(percent, 2.f);
}
float easeOut(float a, float b, float percent)
{
return a + (b - a) * (1 - std::pow(1.f - percent, 2.f));
}
float easeInOut(float a, float b, float percent)
{
return a + (b - a) * (static_cast<float>(-std::cos(percent * M_PI) / 2.f) + 0.5f);
}
float interpolate(float a, float b, float percent)
{
return a + (b - a)*percent;
}
float percentRemaining(float n, float total)
{
return (static_cast<int>(n) % static_cast<int>(total)) / total;
}
}
class Polygon final : public sf::Drawable, public sf::Transformable, sf::NonCopyable
{
public:
Polygon() : mVertices(sf::Quads, 4u) {}
void setVertices(float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4, sf::Color color)
{
mVertices[0].position = sf::Vector2f(x1, y1);
mVertices[1].position = sf::Vector2f(x2, y2);
mVertices[2].position = sf::Vector2f(x3, y3);
mVertices[3].position = sf::Vector2f(x4, y4);
mVertices[0].color = mVertices[1].color = mVertices[2].color = mVertices[3].color = color;
}
private:
void draw(sf::RenderTarget& target, sf::RenderStates states) const override
{
states.transform *= getTransform();
target.draw(mVertices, states);
}
private:
sf::VertexArray mVertices;
};
struct Point
{
struct Screen
{
float x{};
float y{};
float w{};
}screen{};
sf::Vector3f world{};
sf::Vector3f camera{};
void project(float cameraX, float cameraY, float cameraZ, float cameraDepth, float width, float height, float roadWidth)
{
camera.x = world.x - cameraX;
camera.y = world.y - cameraY;
camera.z = world.z - cameraZ;
auto scale = cameraDepth / camera.z;
screen.x = width / 2.f + scale * camera.x * width / 2.f;
screen.y = height / 2.f - scale * camera.y * height / 2.f;
screen.w = scale * roadWidth * width / 2.f;
}
};
class Colors
{
struct ColorsData
{
sf::Color road{};
sf::Color grass{};
sf::Color rumble{};
sf::Color lanes{};
};
using ColorsContainer = std::vector<ColorsData>;
public:
enum Type
{
Light,
Dark,
Start,
Finish,
TypeCount
};
public:
Colors(Type type = Colors::Light)
: mType(type)
, mData(Colors::TypeCount)
{
mData[Colors::Light].road = { 100, 100, 100 };
mData[Colors::Light].grass = { 16, 170, 16 };
mData[Colors::Light].rumble = { 85, 85 , 85 };
mData[Colors::Light].lanes = sf::Color::White;
mData[Colors::Dark].road = { 100, 100, 100 };
mData[Colors::Dark].grass = { 0, 154, 0 };
mData[Colors::Dark].rumble = { 187,187, 187 };
mData[Colors::Dark].lanes = { 100, 100, 100 };
mData[Colors::Start].road = sf::Color::White;
mData[Colors::Start].grass = { 16, 170, 16 };
mData[Colors::Start].rumble = sf::Color::White;
mData[Colors::Start].lanes = sf::Color::White;
mData[Colors::Finish].road = {};
mData[Colors::Finish].grass = { 16, 170, 16 };
mData[Colors::Finish].rumble = {};
mData[Colors::Finish].lanes = {};
}
void setType(Type type) { mType = type;}
sf::Color getRoad() const { return mData[mType].road;}
sf::Color getGrass() const { return mData[mType].grass;}
sf::Color getRumble() const { return mData[mType].rumble;}
sf::Color getLane() const { return mData[mType].lanes;}
private:
Type mType;
ColorsContainer mData;
};
class Segment final : public sf::Drawable, public sf::Transformable, sf::NonCopyable
{
public:
using Ptr = std::unique_ptr<Segment>;
public:
void setCurve(float i) { mCurve = i; }
float getCurve() const { return mCurve; }
Point& getPoint1() { return mPoint1; }
Point& getPoint2() { return mPoint2; }
const Point& getPoint1() const { return mPoint1; }
const Point& getPoint2() const { return mPoint2; }
void setSegmentColors(Colors::Type c) { mColors.setType(c); }
void setIndex(std::size_t i) { mIndex = i; }
std::size_t getIndex() const { return mIndex; }
void setGrounds(float width, float fog)
{
auto lanes = 3u;
// Landscape
mLandscape.setSize({ width, mPoint1.screen.y - mPoint2.screen.y });
mLandscape.setPosition(0, mPoint2.screen.y);
mLandscape.setFillColor(mColors.getGrass());
// Rumble sides
auto rumbleWidth1 = rumbleWidth(mPoint1.screen.w, lanes);
auto rumbleWidth2 = rumbleWidth(mPoint2.screen.w, lanes);
mRumbleSide1.setVertices(mPoint1.screen.x - mPoint1.screen.w - rumbleWidth1, mPoint1.screen.y,
mPoint1.screen.x - mPoint1.screen.w, mPoint1.screen.y,
mPoint2.screen.x - mPoint2.screen.w, mPoint2.screen.y,
mPoint2.screen.x - mPoint2.screen.w - rumbleWidth2, mPoint2.screen.y, mColors.getRumble());
mRumbleSide2.setVertices(mPoint1.screen.x + mPoint1.screen.w + rumbleWidth1, mPoint1.screen.y,
mPoint1.screen.x + mPoint1.screen.w, mPoint1.screen.y,
mPoint2.screen.x + mPoint2.screen.w, mPoint2.screen.y,
mPoint2.screen.x + mPoint2.screen.w + rumbleWidth2, mPoint2.screen.y, mColors.getRumble());
// Main Road
mMainRoad.setVertices(mPoint1.screen.x - mPoint1.screen.w, mPoint1.screen.y,
mPoint1.screen.x + mPoint1.screen.w, mPoint1.screen.y,
mPoint2.screen.x + mPoint2.screen.w, mPoint2.screen.y,
mPoint2.screen.x - mPoint2.screen.w, mPoint2.screen.y, mColors.getRoad());
// Lanes
auto laneMarkerWidth1 = laneMarkerWidth(mPoint1.screen.w, lanes);
auto laneMarkerWidth2 = laneMarkerWidth(mPoint2.screen.w, lanes);
auto lanew1 = mPoint1.screen.w * 2 / lanes;
auto lanew2 = mPoint2.screen.w * 2 / lanes;
auto lanex1 = mPoint1.screen.x - mPoint1.screen.w + lanew1;
auto lanex2 = mPoint2.screen.x - mPoint2.screen.w + lanew2;
for (auto lane = 1u; lane < lanes; lanex1 += lanew1 + 1, lanex2 += lanew2 + 1, lane++)
{
if (lane == 1)
mLanes1.setVertices(lanex1 - laneMarkerWidth1 / 2, mPoint1.screen.y,
lanex1 + laneMarkerWidth1 / 2, mPoint1.screen.y,
lanex2 + laneMarkerWidth2 / 2, mPoint2.screen.y,
lanex2 - laneMarkerWidth2 / 2, mPoint2.screen.y, mColors.getLane());
else
mLanes2.setVertices(lanex1 - laneMarkerWidth1 / 2, mPoint1.screen.y,
lanex1 + laneMarkerWidth1 / 2, mPoint1.screen.y,
lanex2 + laneMarkerWidth2 / 2, mPoint2.screen.y,
lanex2 - laneMarkerWidth2 / 2, mPoint2.screen.y, mColors.getLane());
}
// Fog effect
mFog.setSize({ width, mPoint1.screen.y - mPoint2.screen.y });
mFog.setPosition(0, mPoint1.screen.y);
mFog.setFillColor(sf::Color(255, 255, 255, 255 - static_cast<unsigned char>(fog * 255)));
}
private:
void draw(sf::RenderTarget& target, sf::RenderStates states) const override
{
states.transform *= getTransform();
target.draw(mLandscape, states);
target.draw(mRumbleSide1, states);
target.draw(mRumbleSide2, states);
target.draw(mMainRoad, states);
target.draw(mLanes1, states);
target.draw(mLanes2, states);
target.draw(mFog, states);
}
private:
Point mPoint1{};
Point mPoint2{};
Polygon mRumbleSide1{};
Polygon mRumbleSide2{};
Polygon mLanes1{};
Polygon mLanes2{};
Polygon mMainRoad{};
sf::RectangleShape mLandscape{};
sf::RectangleShape mFog{};
Colors mColors{};
std::size_t mIndex{};
float mCurve{};
};
struct Road
{
struct Length
{
const float shorty = 25.f;
const float medium = 50.f;
const float longy = 100.f;
} length;
struct Curve
{
const float easy = 2.f;
const float medium = 4.f;
const float hard = 6.f;
} curve;
struct Hill
{
const float none = 0.f;
const float low = 20.f;
const float medium = 40.f;
const float high = 60.f;
}hill;
}road;
class Game
{
using SegmentContainer = std::vector<Segment::Ptr>;
public:
Game()
: mWindow(sf::VideoMode(640, 480), "test")
, mSegments()
, mSegmentLength(200.f)
, mPlayerX(0.f)
, mCameraDepth(1 / std::atan((100.f / 2.f)))
, mCameraHeight(1000.f)
, mPlayerZ((mCameraHeight * mCameraDepth))
, mPosition(0.f)
, mRumbleLength(3u)
, mTrackLength(0.f)
, mSpeed(0.f)
{
// build road
addStraight(road.length.shorty / 2);
addHill(road.length.shorty, road.hill.low);
addLowRollingHills();
addCurve(road.length.medium, road.curve.medium, road.hill.low);
addLowRollingHills();
addCurve(road.length.longy, road.curve.medium, road.hill.medium);
addStraight();
addCurve(road.length.longy, -road.curve.medium, road.hill.medium);
addHill(road.length.longy, road.hill.high);
addCurve(road.length.longy, road.curve.medium, -road.hill.low);
addHill(road.length.longy, -road.curve.medium);
addStraight();
addDownhillToEnd();
// setup start and finish of road
mSegments[mSegments[static_cast<std::size_t>(std::floor(mPlayerZ / mSegmentLength)) % mSegments.size()]->getIndex() + 2]->setSegmentColors(Colors::Start);
mSegments[mSegments[static_cast<std::size_t>(std::floor(mPlayerZ / mSegmentLength)) % mSegments.size()]->getIndex() + 3]->setSegmentColors(Colors::Start);
for (auto n = 0u; n < mRumbleLength; n++)
{
mSegments[mSegments.size() - 1 - n]->setSegmentColors(Colors::Finish);
}
mTrackLength = mSegments.size() * mSegmentLength;
}
void run()
{
sf::Clock clock;
auto timeSinceLastUpdate = sf::Time::Zero;
while (mWindow.isOpen())
{
auto elapsedTime = clock.restart();
timeSinceLastUpdate += elapsedTime;
while (timeSinceLastUpdate > TimePerFrame)
{
timeSinceLastUpdate -= TimePerFrame;
processEvents();
update(TimePerFrame);
}
render();
}
}
private:
void processEvents()
{
sf::Event event;
while (mWindow.pollEvent(event))
{
if (event.type == sf::Event::Closed)
mWindow.close();
}
}
void update(sf::Time TimePerFrame)
{
auto dt = TimePerFrame.asSeconds();
auto step = 1 / 60.f;
auto maxSpeed = mSegmentLength / step;
auto accel = maxSpeed / 5.f;
auto breaking = -maxSpeed;
auto decel = -maxSpeed / 5.f;
auto offRoadDecel = -maxSpeed / 2.f;
auto offRoadLimit = maxSpeed / 4.f;
auto centrifugal = 0.3f;
const auto& playerSegment = *mSegments[static_cast<std::size_t>(std::floor((mPosition + mPlayerZ) / mSegmentLength)) % mSegments.size()];
auto speedPercent = mSpeed / maxSpeed;
auto dx = dt * speedPercent;
if (sf::Keyboard::isKeyPressed(sf::Keyboard::Left))
mPlayerX -= dx;
if (sf::Keyboard::isKeyPressed(sf::Keyboard::Right))
mPlayerX += dx;
mPlayerX -= (dx * speedPercent * playerSegment.getCurve() * centrifugal);
if (sf::Keyboard::isKeyPressed(sf::Keyboard::Up))
mSpeed += accel * dt;
else
mSpeed += decel * dt;
if (sf::Keyboard::isKeyPressed(sf::Keyboard::Down))
mSpeed += breaking * dt;
if (((mPlayerX < -1.f) || (mPlayerX > 1.f)) && (mSpeed > offRoadLimit))
mSpeed += offRoadDecel * dt;
mPlayerX = limit(mPlayerX, -2.f, 2.f);
mSpeed = limit(mSpeed, 0, maxSpeed);
mPosition = increase(mPosition, dt * mSpeed, mTrackLength);
}
void render()
{
auto width = 640.f;
auto height = 480.f;
auto roadWidth = 2000.f;
auto drawDistance = 500u;
auto fogDensity = 5.f;
const auto& baseSegment = *mSegments[static_cast<std::size_t>(std::floor(mPosition / mSegmentLength)) % mSegments.size()];
auto basePercent = percentRemaining(mPosition, mSegmentLength);
const auto& playerSegment = *mSegments[static_cast<std::size_t>(std::floor((mPosition + mPlayerZ) / mSegmentLength)) % mSegments.size()];
auto playerPercent = percentRemaining(mPosition + mPlayerZ, mSegmentLength);
auto playerY = interpolate(playerSegment.getPoint1().world.y, playerSegment.getPoint2().world.y, playerPercent);
auto x = 0.f;
auto dx = -(baseSegment.getCurve() * basePercent);
auto maxy = height;
mWindow.clear();
for (auto n = 0u; n < drawDistance; ++n)
{
auto& segment = *mSegments[(baseSegment.getIndex() + n) % mSegments.size()];
bool looped = segment.getIndex() < baseSegment.getIndex();
auto fog = exponentialFog(n / (drawDistance * 1.f), fogDensity);
auto camX = mPlayerX * roadWidth;
auto camY = playerY + mCameraHeight;
auto camZ = mPosition - (looped ? mTrackLength : 0.f);
auto& point1 = segment.getPoint1();
auto& point2 = segment.getPoint2();
point1.project(camX - x, camY, camZ, mCameraDepth, width, height, roadWidth);
point2.project(camX - x - dx, camY, camZ, mCameraDepth, width, height, roadWidth);
x += dx;
dx += segment.getCurve();
if ((point1.camera.z <= mCameraDepth) || (point2.screen.y >= maxy || point2.screen.y >= point1.screen.y))
continue;
segment.setGrounds(width, fog);
mWindow.draw(segment);
maxy = point2.screen.y;
}
mWindow.display();
}
void addSegment(float curve, float y)
{
auto n = mSegments.size();
auto segment = std::make_unique<Segment>();
segment->setIndex(n);
segment->setCurve(curve);
segment->getPoint1().world.y = lastY();
segment->getPoint2().world.y = y;
segment->getPoint1().world.z = n * mSegmentLength;
segment->getPoint2().world.z = (n + 1) * mSegmentLength;
if (static_cast<std::size_t>(std::floor(n / mRumbleLength)) % 2)
segment->setSegmentColors(Colors::Light);
else
segment->setSegmentColors(Colors::Dark);
mSegments.push_back(std::move(segment));
}
void addRoad(float enter, float hold, float leave, float curve, float y)
{
auto startY = lastY();
auto endY = startY + (y * mSegmentLength);
auto total = enter + hold + leave;
for (auto n = 0.f; n < enter; ++n)
addSegment(easeIn(0, curve, n / enter), easeInOut(startY, endY, n / total));
for (auto n = 0.f; n < hold; ++n)
addSegment(curve, easeInOut(startY, endY, (enter + n) / total));
for (auto n = 0.f; n < leave; ++n)
addSegment(easeInOut(curve, 0, n / leave), easeInOut(startY, endY, (enter + hold + n) / total));
}
void addStraight(float n = 0)
{
auto num = (n == 0) ? road.length.medium : n;
addRoad(num, num, num, 0, 0);
}
void addHill(float n = 0, float h = 0)
{
auto num = (n == 0) ? road.length.medium : n;
auto height = (h == 0) ? road.hill.medium : h;
addRoad(num, num, num, 0, height);
}
void addCurve(float n = 0, float c = 0, float h = 0)
{
auto num = (n == 0) ? road.length.medium : n;
auto curve = (c == 0) ? road.curve.medium : c;
auto height = (h == 0) ? road.hill.none : h;
addRoad(num, num, num, curve, height);
}
void addDownhillToEnd(float n = 0)
{
auto num = (n == 0) ? 200 : n;
addRoad(num, num, num, -road.curve.easy, -lastY() / mSegmentLength);
}
void addSCurves()
{
addRoad(road.length.medium, road.length.medium, road.length.medium, -road.curve.easy, road.hill.none);
addRoad(road.length.medium, road.length.medium, road.length.medium, road.curve.medium, road.hill.medium);
addRoad(road.length.medium, road.length.medium, road.length.medium, road.curve.easy, -road.hill.low);
addRoad(road.length.medium, road.length.medium, road.length.medium, -road.curve.easy, road.hill.medium);
addRoad(road.length.medium, road.length.medium, road.length.medium, -road.curve.medium, -road.hill.medium);
}
void addLowRollingHills(float n = 0, float h = 0)
{
auto num = (n == 0) ? road.length.shorty : n;
auto height = (h == 0) ? road.hill.low : h;
addRoad(num, num, num, 0, height / 2);
addRoad(num, num, num, 0, -height);
addRoad(num, num, num, 0, height);
addRoad(num, num, num, 0, 0);
addRoad(num, num, num, 0, height / 2);
addRoad(num, num, num, 0, 0);
}
float lastY()
{
return (mSegments.size() == 0) ? 0 : mSegments[mSegments.size() - 1]->getPoint2().world.y;
}
private:
sf::RenderWindow mWindow;
const static sf::Time TimePerFrame;
SegmentContainer mSegments;
std::size_t mRumbleLength;
float mSegmentLength;
float mPlayerX;
float mCameraDepth;
float mCameraHeight;
float mPlayerZ;
float mPosition;
float mTrackLength;
float mSpeed;
};
const sf::Time Game::TimePerFrame = sf::seconds(1 / 60.f);
int main()
{
try
{
Game game;
game.run();
}
catch (std::exception& e)
{
std::cout << "\nEXCEPTION: " << e.what() << std::endl;
}
}
Output:
