FadeInShaderScreenEffect(float fadeDuration = 1.0f)
: timer(fadeDuration)
, fadeDuration(fadeDuration)
{
pixelShader = ScreenEffectsService::FADE_IN_SHADER.get();
if(pixelShader) {
pixelShader->setParameter("texture", sf::Shader::CurrentTexture);
pixelShader->setParameter("fadePercent", (timer / fadeDuration) * 100.0f);
}
}
void Displayer::drawSprite(sf::Shader& shad, vec2 pos, vec2 size, float time)
{
sf::RectangleShape rectangle(size);
sf::RenderStates states;
shad.setParameter("coord", vec2(pos.x, this->_win->getSize().y - pos.y));
shad.setParameter("resolution", size);
shad.setParameter("time", time);
rectangle.move(pos - size / 2.0f);
states.shader = &shad;
this->_texture.draw(rectangle, states);
}
void MapController::LayerDrawable::buildShadow(sf::Shader& blurShader)
{
const sf::Vector2i texSize(480, 270); //TODO link magic numbers to view size
m_shadowTexture = std::make_unique<sf::RenderTexture>();
m_shadowTexture->create(texSize.x, texSize.y);
m_shadowTexture->setSmooth(true);
sf::RenderStates states;
states.transform.scale(0.25f, 0.25f);
m_shadowTexture->clear(sf::Color::White);
for (auto& l : m_layerData)
{
m_shadowTexture->draw(l.second.vertexArray, states);
}
m_shadowTexture->display();
sf::RenderTexture tempRt;
tempRt.create(texSize.x, texSize.y);
for (auto i = 0u; i < 2u; ++i)
{
blurShader.setParameter("u_diffuse", m_shadowTexture->getTexture());
blurShader.setParameter("u_offset", sf::Vector2f(1.f / texSize.x, 0.f));
tempRt.clear(sf::Color::White);
tempRt.draw(sf::Sprite(m_shadowTexture->getTexture()), &blurShader);
tempRt.display();
blurShader.setParameter("u_diffuse", tempRt.getTexture());
blurShader.setParameter("u_offset", sf::Vector2f(0.f, 1.f / texSize.y));
m_shadowTexture->clear(sf::Color::White);
m_shadowTexture->draw(sf::Sprite(tempRt.getTexture()), &blurShader);
m_shadowTexture->display();
}
m_shadowSprite.setTexture(m_shadowTexture->getTexture());
m_shadowSprite.setScale(4.f, 4.f);
}
void Game::init()
{
menu = new Menu(static_cast<sf::Vector2f>(win->getSize()), win);
highscoreMenu = new SubMenu(static_cast<sf::Vector2f>(win->getSize()), win);
shipShootBuffer.loadFromFile("Audio/Shoot.wav");
shipShoot.setBuffer(shipShootBuffer);
asteroidExplosionBuffer.loadFromFile("Audio/Asteroid Explosion.wav");
asteroidExplosion.setBuffer(asteroidExplosionBuffer);
myShader.Vertex;
myShader.setParameter("colour", sf::Color(0, 0, 0));
srand(time(NULL)); // seed the random numbers
lShift = false;
Escape = false;
Tab = false;
Space = false;
Up = false;
Down = false;
LControl = false;
levelMenu = false;
level = 2;
score = 0;
arial.loadFromFile("arial.ttf");
float x = rand() % win->getSize().x;
float y = rand() % win->getSize().y;
ship = new Ship(x, y, win);
particleSystem = new ParticleSystem(win);
asteroidVector.clear();
smAsteroidVector.clear();
for (int i = 0; i < MAX_BULLETS; ++i)
{
bullet[i] = nullptr;
}
build(level);
return;
}
void LightDirectionEmission::render(const sf::View &view, sf::RenderTexture &lightTempTexture, sf::RenderTexture &antumbraTempTexture, const std::vector<QuadtreeOccupant*> &shapes, sf::Shader &unshadowShader, float shadowExtension) {
lightTempTexture.setView(view);
LightSystem::clear(lightTempTexture, sf::Color::White);
// Mask off light shape (over-masking - mask too much, reveal penumbra/antumbra afterwards)
for (int i = 0; i < shapes.size(); i++) {
LightShape* pLightShape = static_cast<LightShape*>(shapes[i]);
// Get boundaries
std::vector<LightSystem::Penumbra> penumbras;
std::vector<int> innerBoundaryIndices;
std::vector<int> outerBoundaryIndices;
std::vector<sf::Vector2f> innerBoundaryVectors;
std::vector<sf::Vector2f> outerBoundaryVectors;
LightSystem::getPenumbrasDirection(penumbras, innerBoundaryIndices, innerBoundaryVectors, outerBoundaryIndices, outerBoundaryVectors, pLightShape->_shape, _castDirection, _sourceRadius, _sourceDistance);
if (innerBoundaryIndices.size() != 2 || outerBoundaryIndices.size() != 2)
continue;
LightSystem::clear(antumbraTempTexture, sf::Color::White);
antumbraTempTexture.setView(view);
sf::ConvexShape maskShape;
float maxDist = 0.0f;
for (int j = 0; j < pLightShape->_shape.getPointCount(); j++)
maxDist = std::max(maxDist, vectorMagnitude(view.getCenter() - pLightShape->_shape.getTransform().transformPoint(pLightShape->_shape.getPoint(j))));
float totalShadowExtension = shadowExtension + maxDist;
maskShape.setPointCount(4);
maskShape.setPoint(0, pLightShape->_shape.getTransform().transformPoint(pLightShape->_shape.getPoint(innerBoundaryIndices[0])));
maskShape.setPoint(1, pLightShape->_shape.getTransform().transformPoint(pLightShape->_shape.getPoint(innerBoundaryIndices[1])));
maskShape.setPoint(2, pLightShape->_shape.getTransform().transformPoint(pLightShape->_shape.getPoint(innerBoundaryIndices[1])) + vectorNormalize(innerBoundaryVectors[1]) * totalShadowExtension);
maskShape.setPoint(3, pLightShape->_shape.getTransform().transformPoint(pLightShape->_shape.getPoint(innerBoundaryIndices[0])) + vectorNormalize(innerBoundaryVectors[0]) * totalShadowExtension);
maskShape.setFillColor(sf::Color::Black);
antumbraTempTexture.draw(maskShape);
sf::VertexArray vertexArray;
vertexArray.setPrimitiveType(sf::PrimitiveType::Triangles);
vertexArray.resize(3);
{
sf::RenderStates states;
states.blendMode = sf::BlendAdd;
states.shader = &unshadowShader;
// Unmask with penumbras
for (int j = 0; j < penumbras.size(); j++) {
unshadowShader.setParameter("lightBrightness", penumbras[j]._lightBrightness);
unshadowShader.setParameter("darkBrightness", penumbras[j]._darkBrightness);
vertexArray[0].position = penumbras[j]._source;
vertexArray[1].position = penumbras[j]._source + vectorNormalize(penumbras[j]._lightEdge) * totalShadowExtension;
vertexArray[2].position = penumbras[j]._source + vectorNormalize(penumbras[j]._darkEdge) * totalShadowExtension;
vertexArray[0].texCoords = sf::Vector2f(0.0f, 1.0f);
vertexArray[1].texCoords = sf::Vector2f(1.0f, 0.0f);
vertexArray[2].texCoords = sf::Vector2f(0.0f, 0.0f);
antumbraTempTexture.draw(vertexArray, states);
}
}
antumbraTempTexture.display();
// Multiply back to lightTempTexture
sf::RenderStates antumbraRenderStates;
antumbraRenderStates.blendMode = sf::BlendMultiply;
sf::Sprite s;
s.setTexture(antumbraTempTexture.getTexture());
lightTempTexture.setView(lightTempTexture.getDefaultView());
lightTempTexture.draw(s, antumbraRenderStates);
lightTempTexture.setView(view);
}
for (int i = 0; i < shapes.size(); i++) {
LightShape* pLightShape = static_cast<LightShape*>(shapes[i]);
if (pLightShape->_renderLightOverShape) {
pLightShape->_shape.setFillColor(sf::Color::White);
lightTempTexture.draw(pLightShape->_shape);
}
}
// Multiplicatively blend the light over the shadows
sf::RenderStates lightRenderStates;
lightRenderStates.blendMode = sf::BlendMultiply;
lightTempTexture.setView(lightTempTexture.getDefaultView());
lightTempTexture.draw(_emissionSprite, lightRenderStates);
lightTempTexture.display();
}
int main(int argc, char** argv)
{
new Engine();
new DirectoryResourceProvider("resources/");
textureManager.setDefaultSmooth(true);
textureManager.setDefaultRepeated(true);
textureManager.setAutoSprite(false);
//Setup the rendering layers.
backgroundLayer = new RenderLayer();
objectLayer = new RenderLayer(backgroundLayer);
effectLayer = new RenderLayer(objectLayer);
hudLayer = new RenderLayer(effectLayer);
mouseLayer = new RenderLayer(hudLayer);
glitchPostProcessor = new PostProcessor("glitch", mouseLayer);
glitchPostProcessor->enabled = false;
defaultRenderLayer = objectLayer;
int width = 1600;
int height = 900;
int fsaa = 0;
bool fullscreen = true;
#ifdef DEBUG
fullscreen = false;
#endif
engine->registerObject("windowManager", new WindowManager(width, height, fullscreen, glitchPostProcessor, fsaa));
engine->registerObject("mouseRenderer", new MouseRenderer());
soundManager.setMusicVolume(50);
randomNebulas();
P<ResourceStream> stream = getResourceStream("sansation.ttf");
mainFont.loadFromStream(**stream);
P<ResourceStream> vertexStream = getResourceStream("objectShader.vert");
P<ResourceStream> fragmentStream = getResourceStream("objectShader.frag");
objectShader.loadFromStream(**vertexStream, **fragmentStream);
vertexStream = getResourceStream("basicShader.vert");
fragmentStream = getResourceStream("basicShader.frag");
basicShader.loadFromStream(**vertexStream, **fragmentStream);
P<ScriptObject> shipTemplatesScript = new ScriptObject("shipTemplates.lua");
shipTemplatesScript->destroy();
factionInfo[0].name = "Neutral";
factionInfo[1].name = "Human";
factionInfo[2].name = "SpaceCow";
factionInfo[3].name = "Sheeple";
factionInfo[4].name = "PirateScorpions";
factionInfo[0].gm_color = sf::Color(128, 128, 128);
factionInfo[1].gm_color = sf::Color(255, 255, 255);
factionInfo[2].gm_color = sf::Color(255, 0, 0);
factionInfo[3].gm_color = sf::Color(255, 128, 0);
factionInfo[4].gm_color = sf::Color(255, 0, 128);
FactionInfo::setState(0, 4, FVF_Enemy);
FactionInfo::setState(1, 2, FVF_Enemy);
FactionInfo::setState(1, 3, FVF_Enemy);
FactionInfo::setState(1, 4, FVF_Enemy);
FactionInfo::setState(2, 3, FVF_Enemy);
FactionInfo::setState(2, 4, FVF_Enemy);
FactionInfo::setState(3, 4, FVF_Enemy);
new MainMenu();
engine->runMainLoop();
delete engine;
return 0;
}
void LightPointEmission::render(const sf::View &view, sf::RenderTexture &lightTempTexture, sf::RenderTexture &emissionTempTexture, sf::RenderTexture &antumbraTempTexture, const std::vector<QuadtreeOccupant*> &shapes, sf::Shader &unshadowShader, sf::Shader &lightOverShapeShader) {
LightSystem::clear(emissionTempTexture, sf::Color::Black);
emissionTempTexture.setView(view);
emissionTempTexture.draw(_emissionSprite);
emissionTempTexture.display();
LightSystem::clear(lightTempTexture, sf::Color::Black);
lightTempTexture.setView(view);
lightTempTexture.draw(_emissionSprite);
sf::Transform t;
t.translate(_emissionSprite.getPosition());
t.rotate(_emissionSprite.getRotation());
t.scale(_emissionSprite.getScale());
sf::Vector2f castCenter = t.transformPoint(_localCastCenter);
float shadowExtension = _shadowOverExtendMultiplier * (getAABB().width + getAABB().height);
struct OuterEdges {
std::vector<int> _outerBoundaryIndices;
std::vector<sf::Vector2f> _outerBoundaryVectors;
};
std::vector<OuterEdges> outerEdges(shapes.size());
// Mask off light shape (over-masking - mask too much, reveal penumbra/antumbra afterwards)
for (unsigned i = 0; i < shapes.size(); i++) {
LightShape* pLightShape = static_cast<LightShape*>(shapes[i]);
// Get boundaries
std::vector<int> innerBoundaryIndices;
std::vector<sf::Vector2f> innerBoundaryVectors;
std::vector<LightSystem::Penumbra> penumbras;
LightSystem::getPenumbrasPoint(penumbras, innerBoundaryIndices, innerBoundaryVectors, outerEdges[i]._outerBoundaryIndices, outerEdges[i]._outerBoundaryVectors, pLightShape->_shape, castCenter, _sourceRadius);
if (innerBoundaryIndices.size() != 2 || outerEdges[i]._outerBoundaryIndices.size() != 2)
continue;
// Render shape
if (!pLightShape->_renderLightOverShape) {
pLightShape->_shape.setFillColor(sf::Color::Black);
lightTempTexture.draw(pLightShape->_shape);
}
sf::RenderStates maskRenderStates;
maskRenderStates.blendMode = sf::BlendNone;
sf::Vector2f as = pLightShape->_shape.getTransform().transformPoint(pLightShape->_shape.getPoint(outerEdges[i]._outerBoundaryIndices[0]));
sf::Vector2f bs = pLightShape->_shape.getTransform().transformPoint(pLightShape->_shape.getPoint(outerEdges[i]._outerBoundaryIndices[1]));
sf::Vector2f ad = outerEdges[i]._outerBoundaryVectors[0];
sf::Vector2f bd = outerEdges[i]._outerBoundaryVectors[1];
sf::Vector2f intersectionOuter;
// Handle antumbras as a seperate case
if (rayIntersect(as, ad, bs, bd, intersectionOuter)) {
sf::Vector2f asi = pLightShape->_shape.getTransform().transformPoint(pLightShape->_shape.getPoint(innerBoundaryIndices[0]));
sf::Vector2f bsi = pLightShape->_shape.getTransform().transformPoint(pLightShape->_shape.getPoint(innerBoundaryIndices[1]));
sf::Vector2f adi = innerBoundaryVectors[0];
sf::Vector2f bdi = innerBoundaryVectors[1];
LightSystem::clear(antumbraTempTexture, sf::Color::White);
antumbraTempTexture.setView(view);
sf::Vector2f intersectionInner;
if (rayIntersect(asi, adi, bsi, bdi, intersectionInner)) {
sf::ConvexShape maskShape;
maskShape.setPointCount(3);
maskShape.setPoint(0, asi);
maskShape.setPoint(1, bsi);
maskShape.setPoint(2, intersectionInner);
maskShape.setFillColor(sf::Color::Black);
antumbraTempTexture.draw(maskShape);
}
else {
sf::ConvexShape maskShape;
maskShape.setPointCount(4);
maskShape.setPoint(0, asi);
maskShape.setPoint(1, bsi);
maskShape.setPoint(2, bsi + vectorNormalize(bdi) * shadowExtension);
maskShape.setPoint(3, asi + vectorNormalize(adi) * shadowExtension);
maskShape.setFillColor(sf::Color::Black);
antumbraTempTexture.draw(maskShape);
}
// Add light back for antumbra/penumbras
sf::VertexArray vertexArray;
vertexArray.setPrimitiveType(sf::PrimitiveType::Triangles);
vertexArray.resize(3);
sf::RenderStates penumbraRenderStates;
penumbraRenderStates.blendMode = sf::BlendAdd;
penumbraRenderStates.shader = &unshadowShader;
// Unmask with penumbras
for (unsigned j = 0; j < penumbras.size(); j++) {
unshadowShader.setParameter("lightBrightness", penumbras[j]._lightBrightness);
unshadowShader.setParameter("darkBrightness", penumbras[j]._darkBrightness);
vertexArray[0].position = penumbras[j]._source;
vertexArray[1].position = penumbras[j]._source + vectorNormalize(penumbras[j]._lightEdge) * shadowExtension;
vertexArray[2].position = penumbras[j]._source + vectorNormalize(penumbras[j]._darkEdge) * shadowExtension;
vertexArray[0].texCoords = sf::Vector2f(0.0f, 1.0f);
vertexArray[1].texCoords = sf::Vector2f(1.0f, 0.0f);
vertexArray[2].texCoords = sf::Vector2f(0.0f, 0.0f);
antumbraTempTexture.draw(vertexArray, penumbraRenderStates);
}
antumbraTempTexture.display();
// Multiply back to lightTempTexture
sf::RenderStates antumbraRenderStates;
antumbraRenderStates.blendMode = sf::BlendMultiply;
sf::Sprite s;
s.setTexture(antumbraTempTexture.getTexture());
lightTempTexture.setView(lightTempTexture.getDefaultView());
lightTempTexture.draw(s, antumbraRenderStates);
lightTempTexture.setView(view);
}
else {
sf::ConvexShape maskShape;
maskShape.setPointCount(4);
maskShape.setPoint(0, as);
maskShape.setPoint(1, bs);
maskShape.setPoint(2, bs + vectorNormalize(bd) * shadowExtension);
maskShape.setPoint(3, as + vectorNormalize(ad) * shadowExtension);
maskShape.setFillColor(sf::Color::Black);
lightTempTexture.draw(maskShape);
sf::VertexArray vertexArray;
vertexArray.setPrimitiveType(sf::PrimitiveType::Triangles);
vertexArray.resize(3);
sf::RenderStates penumbraRenderStates;
penumbraRenderStates.blendMode = sf::BlendMultiply;
penumbraRenderStates.shader = &unshadowShader;
// Unmask with penumbras
for (unsigned j = 0; j < penumbras.size(); j++) {
unshadowShader.setParameter("lightBrightness", penumbras[j]._lightBrightness);
unshadowShader.setParameter("darkBrightness", penumbras[j]._darkBrightness);
vertexArray[0].position = penumbras[j]._source;
vertexArray[1].position = penumbras[j]._source + vectorNormalize(penumbras[j]._lightEdge) * shadowExtension;
vertexArray[2].position = penumbras[j]._source + vectorNormalize(penumbras[j]._darkEdge) * shadowExtension;
vertexArray[0].texCoords = sf::Vector2f(0.0f, 1.0f);
vertexArray[1].texCoords = sf::Vector2f(1.0f, 0.0f);
vertexArray[2].texCoords = sf::Vector2f(0.0f, 0.0f);
lightTempTexture.draw(vertexArray, penumbraRenderStates);
}
}
}
for (unsigned i = 0; i < shapes.size(); i++) {
LightShape* pLightShape = static_cast<LightShape*>(shapes[i]);
if (pLightShape->_renderLightOverShape) {
pLightShape->_shape.setFillColor(sf::Color::White);
lightTempTexture.draw(pLightShape->_shape, &lightOverShapeShader);
}
else {
pLightShape->_shape.setFillColor(sf::Color::Black);
lightTempTexture.draw(pLightShape->_shape);
}
}
lightTempTexture.display();
}
virtual void render(sf::RenderTarget & target) {
pixelShader->setParameter("fadePercent", (timer / fadeDuration) * 100.0f);
target.draw(*inputSprite, pixelShader);
}