void run()
{
while (m_window.isOpen())
{
sf::Event event;
while (m_window.pollEvent(event))
{
if (event.type == sf::Event::Closed)
m_window.close();
}
// Update the position of the 'flashlight' to the current mouse position
m_pos = static_cast<sf::Vector2f>(sf::Mouse::getPosition(m_window));
m_flashlight.setPosition(m_pos);
// Stance-out the 'flashlight' circle
m_layer.clear();
m_layer.draw(m_flashlight, sf::BlendMultiply);
m_layer.display();
m_window.clear(sf::Color::Blue);
// Draw the layer sprite on top of the 'scene'
m_window.draw(m_rect);
m_window.draw(m_sprite);
m_window.display();
}
}
void BloomEffect::filterBright(const sf::RenderTexture& input, sf::RenderTexture& output)
{
sf::Shader& brightness = mShaders.get(Shaders::BrightnessPass);
brightness.setParameter("source", input.getTexture());
applyShader(brightness, output);
output.display();
}
void renderString(sf::RenderTexture& tex, sf::Font& font, const wstring& str, int x, int y, int fitInto = 0) {
if (fitInto) {
sf::Text text;
text.setFont(font);
text.setString(str);
int s = 100;
text.setCharacterSize(s);
while (text.getLocalBounds().height > fitInto)
text.setCharacterSize(--s);
text.setString(sf::String(str));
text.setColor(sf::Color::White);
text.setPosition(x, y);
tex.draw(text);
}
else {
sf::Text text;
text.setFont(font);
text.setString(sf::String(str));
text.setCharacterSize(100);
text.setColor(sf::Color::White);
text.setPosition(x, y);
tex.draw(text);
}
}
void draw(sf::RenderTarget &tg)
{
if (first)
{
rt.clear();
rt.draw(sprite);
rt.draw(logo);
if (logo.getPosition().y == 0.0)rt.draw(press);
if (check && timer.getElapsedTime().asSeconds() < 1)
{
if ((int)(rand() % 10) == 3) rt.clear(sf::Color::White);
}
}
else
{
rt.clear(sf::Color::White);
rt.draw(system);
rt.draw(back2);
rt.draw(pointer);
}
rt.display();
sm.draw(rt, tg);
if (first) tg.draw(v);
};
void BloomEffect::add(const sf::RenderTexture& source, const sf::RenderTexture& bloom, sf::RenderTarget& output)
{
sf::Shader& adder = mShaders.get(Shaders::AddPass);
adder.setParameter("source", source.getTexture());
adder.setParameter("bloom", bloom.getTexture());
applyShader(adder, output);
}
void BloomEffect::downsample(const sf::RenderTexture& input, sf::RenderTexture& output)
{
sf::Shader& downSampler = mShaders.get(Shaders::DownSamplePass);
downSampler.setParameter("source", input.getTexture());
downSampler.setParameter("sourceSize", sf::Vector2f(input.getSize()));
applyShader(downSampler, output);
output.display();
}
void BloomEffect::blur(const sf::RenderTexture& input, sf::RenderTexture& output, sf::Vector2f offsetFactor)
{
sf::Shader& gaussianBlur = mShaders.get(Shaders::GaussianBlurPass);
gaussianBlur.setParameter("source", input.getTexture());
gaussianBlur.setParameter("offsetFactor", offsetFactor);
applyShader(gaussianBlur, output);
output.display();
}
void PostBloom::add(const sf::RenderTexture& src, const sf::RenderTexture& bloom, sf::RenderTarget& dst)
{
auto& shader = m_shaderResource.get(Shader::AdditiveBlend);
shader.setUniform("u_sourceTexture", src.getTexture());
shader.setUniform("u_bloomTexture", bloom.getTexture());
applyShader(shader, dst);
}
void PostBloom::filterBright(const sf::RenderTexture& src, sf::RenderTexture& dst)
{
auto& shader = m_shaderResource.get(Shader::BrightnessExtract);
shader.setUniform("u_sourceTexture", src.getTexture());
applyShader(shader, dst);
dst.display();
}
//public
void PostChromeAb::apply(const sf::RenderTexture& src, sf::RenderTarget& dst)
{
float windowRatio = static_cast<float>(dst.getSize().y) / static_cast<float>(src.getSize().y);
m_shader.setUniform("u_sourceTexture", src.getTexture());
m_shader.setUniform("u_time", accumulatedTime * (10.f * windowRatio));
m_shader.setUniform("u_lineCount", windowRatio * scanlineCount);
applyShader(m_shader, dst);
}
void PostBloom::blur(const sf::RenderTexture& src, sf::RenderTexture& dst, const sf::Vector2f& offset)
{
auto& shader = m_shaderResource.get(Shader::GaussianBlur);
shader.setUniform("u_sourceTexture", src.getTexture());
shader.setUniform("u_offset", offset);
applyShader(shader, dst);
dst.display();
}
void PostBloom::downSample(const sf::RenderTexture& src, sf::RenderTexture& dst)
{
auto& shader = m_shaderResource.get(Shader::DownSample);
shader.setUniform("u_sourceTexture", src.getTexture());
shader.setUniform("u_sourceSize", sf::Vector2f(src.getSize()));
applyShader(shader, dst);
dst.display();
}
bool AppState::render(sf::RenderTexture& texture, int frame)
{
texture.clear();
if (m_preDesktopRenderFunctor) m_preDesktopRenderFunctor(texture, frame);
the_desktop.render(texture, frame);
if (m_postDesktopRenderFunctor) m_postDesktopRenderFunctor(texture, frame);
texture.display();
return true;
}
//public
void PostChromeAb::apply(const sf::RenderTexture& src, sf::RenderTarget& dst)
{
float windowRatio = static_cast<float>(dst.getSize().y) / static_cast<float>(src.getSize().y);
auto& shader = m_shaderResource.get(Shader::Type::PostChromeAb);
shader.setParameter("u_sourceTexture", src.getTexture());
shader.setParameter("u_time", accumulatedTime * (10.f * windowRatio));
shader.setParameter("u_lineCount", windowRatio * scanlineCount);
applyShader(shader, dst);
}
void Layer::MakeTexture(sf::RenderTexture& textureImage) const {
if (WidthPixels == textureImage.getSize().x && HeightPixels == textureImage.getSize().y) { //layer is big enough to support creating a textured background from... if not, the texture will be left fully black
VertexVector vertices[NUMBEROFTILESETTEXTURES]; //don't reuse Layer::Vertices, in case this layer needs to get drawn soon
for (int x = 0; x < Width; ++x)
for (int y = 0; y < Height; ++y)
DrawTileToVertexArrays(vertices, x,y);
for (int i = 0; i < NUMBEROFTILESETTEXTURES; ++i)
if (!vertices[i].empty())
textureImage.draw(vertices[i].data(), vertices[i].size(), OpenGLPrimitive, LevelPtr->TilesetPtr->TileImages[i]);
}
textureImage.display();
}
//writes frames to file
//directory must already exist
void record(sf::RenderTexture& in, int frameskip, std::string directory) {
static int frame = 0;
if(frameskip > 0 && frame % frameskip == 0) {
in.display();
sf::Texture outTx = in.getTexture();
sf::Image outImg = outTx.copyToImage();
std::stringstream ugh;
ugh << directory << "/" << frame << ".png";
outImg.saveToFile(ugh.str());
}
frame++;
}
void Champion::draw(sf::RenderTexture &texture)
{
sf::CircleShape championShape(10);
championShape.setPosition(_location.x - 10, _location.y - 10);
championShape.setFillColor(sf::Color(99, 184, 255));
texture.draw(championShape);
}
void generateSpot()
{
m_flashlightTexture.clear();
// Draw 6 circles with increasing transparency
for (unsigned int i = 0; i < 6; ++i)
{
sf::CircleShape temp(30.f - (i*2.f));
temp.setOrigin(sf::Vector2f(30.f - (i*2.f), 30.f - (i*2.f)));
temp.setFillColor(sf::Color(255, 255, 255, 101 - (i * 20)));
temp.setPosition(sf::Vector2f(30.f, 30.f));
m_flashlightTexture.draw(temp, sf::BlendNone);
}
//m_flashlightTexture.display();
}
void displaySnake(Node &node)
{
draw.setPosition(sf::Vector2f(node.x * (640/SIZE), node.y * (640/SIZE)));
draw.setFillColor(sf::Color::White);
//draw.setFillColor(sf::Color::Black);
renderTexture.draw(draw);
if(node.next != nullptr)
displaySnake(*node.next);
}
void Light::render( sf::RenderTexture& target )
{
if (mOnOff == true)
{
if(mDirection == RIGHT)
mSprite.setTextureRect(sf::IntRect (mRect.width*(int)mAnimationTimer, mAnimationPicY * mRect.height,mRect.width,mRect.height));
else if(mDirection == LEFT)
mSprite.setTextureRect(sf::IntRect(mRect.width*((int)mAnimationTimer+1),mAnimationPicY * mRect.height,-mRect.width,mRect.height));
if(mAddBlend)
{
target.draw( mSprite, sf::BlendAdd );
}
else
{
target.draw( mSprite );
}
}
}
void ShaderManager::draw(sf::RenderTexture &rt, sf::RenderTarget &target)
{
sf::Sprite sprite(rt.getTexture());
sf::RenderTexture tempRenderTexture;
tempRenderTexture.create(WIDTH, HEIGHT);
if (mWorking)
{
mShader.setParameter("texture", rt.getTexture());
tempRenderTexture.draw(sprite, &mVingette);
sf::Sprite tempSpr(tempRenderTexture.getTexture());
target.draw(tempSpr, &mShader);
}
else
{
mVingette.setParameter("texture", rt.getTexture());
target.draw(sprite, &mVingette);
}
}
void BloomEffect::apply(const sf::RenderTexture& input, sf::RenderTarget& output)
{
prepareTextures(input.getSize());
filterBright(input, mBrightnessTexture);
downsample(mBrightnessTexture, mFirstPassTextures[0]);
blurMultipass(mFirstPassTextures);
downsample(mFirstPassTextures[0], mSecondPassTextures[0]);
blurMultipass(mSecondPassTextures);
add(mFirstPassTextures[0], mSecondPassTextures[0], mFirstPassTextures[1]);
mFirstPassTextures[1].display();
add(input, mFirstPassTextures[1], output);
}
void GuiElement::adjustRenderTexture(sf::RenderTexture& texture)
{
P<WindowManager> window_manager = engine->getObject("windowManager");
//Hack the rectangle for this element so it sits perfectly on pixel boundaries.
sf::Vector2f half_pixel = (window_manager->mapPixelToCoords(sf::Vector2i(1, 1)) - window_manager->mapPixelToCoords(sf::Vector2i(0, 0))) / 2.0f;
sf::Vector2f top_left = window_manager->mapPixelToCoords(window_manager->mapCoordsToPixel(sf::Vector2f(rect.left, rect.top) + half_pixel));
sf::Vector2f bottom_right = window_manager->mapPixelToCoords(window_manager->mapCoordsToPixel(sf::Vector2f(rect.left + rect.width, rect.top + rect.height) + half_pixel));
rect.left = top_left.x;
rect.top = top_left.y;
rect.width = bottom_right.x - top_left.x;
rect.height = bottom_right.y - top_left.y;
sf::Vector2i texture_size = window_manager->mapCoordsToPixel(sf::Vector2f(rect.width, rect.height) + half_pixel) - window_manager->mapCoordsToPixel(sf::Vector2f(0, 0));
unsigned int sx = powerOfTwo(texture_size.x);
unsigned int sy = powerOfTwo(texture_size.y);
if (texture.getSize().x != sx && texture.getSize().y != sy)
{
texture.create(sx, sy, false);
}
//Set the view so it covers this elements normal rect. So we can draw exactly the same on this texture as no the normal screen.
sf::View view(rect);
view.setViewport(sf::FloatRect(0, 0, float(texture_size.x) / float(sx), float(texture_size.y) / float(sy)));
texture.setView(view);
}
Application() :
m_window(sf::VideoMode(300, 300), "Flashlight!"),
m_layer(),
m_rect(sf::Vector2f(100.f, 100.f)),
m_pos(0.f, 0.f)
{
m_window.setFramerateLimit(60);
m_window.setMouseCursorVisible(false);
m_layer.create(300, 300);
m_flashlightTexture.create(60, 60);
// We want to have semi-transparent edges.
generateSpot();
m_flashlight.setTexture(m_flashlightTexture.getTexture(), true);
m_flashlight.setPosition(150.f, 150.f);
m_flashlight.setOrigin(30.f, 30.f);
m_rect.setFillColor(sf::Color::Red);
m_rect.setPosition(100.f, 100.f);
m_sprite.setTexture(m_layer.getTexture());
}
void BloomEffect::Apply( const sf::RenderTexture& input, sf::RenderTarget& output )
{
pImpl->PrepareTextures( input.getSize() );
pImpl->FilterBright( input, pImpl->mBrightnessTexture );
pImpl->Downsample( pImpl->mBrightnessTexture, pImpl->mFirstPassTextures[ 0 ] );
pImpl->BlurMultipass( pImpl->mFirstPassTextures );
pImpl->Downsample( pImpl->mFirstPassTextures[ 0 ], pImpl->mSecondPassTextures[ 0 ] );
pImpl->BlurMultipass( pImpl->mSecondPassTextures );
pImpl->Add( pImpl->mFirstPassTextures[ 0 ], pImpl->mSecondPassTextures[ 0 ], pImpl->mFirstPassTextures[ 1 ] );
pImpl->mFirstPassTextures[ 1 ].display();
pImpl->Add( input, pImpl->mFirstPassTextures[ 1 ], output );
}
void GuiElement::drawRenderTexture(sf::RenderTexture& texture, sf::RenderTarget& window, sf::Color color, const sf::RenderStates& states)
{
texture.display();
sf::Sprite sprite(texture.getTexture());
sprite.setTextureRect(sf::IntRect(0, 0, texture.getSize().x * texture.getView().getViewport().width, texture.getSize().y * texture.getView().getViewport().height));
sprite.setColor(color);
sprite.setPosition(rect.left, rect.top);
sprite.setScale(rect.width / float(texture.getSize().x * texture.getView().getViewport().width), rect.height / float(texture.getSize().y * texture.getView().getViewport().height));
window.draw(sprite, states);
}
//public
void PostBloom::apply(const sf::RenderTexture& src, sf::RenderTarget& dest)
{
initTextures(src.getSize());
filterBright(src, m_brightnessTexture);
downSample(m_brightnessTexture, m_firstPassTextures[0]);
blurMultipass(m_firstPassTextures);
downSample(m_firstPassTextures[0], m_secondPassTextures[0]);
blurMultipass(m_secondPassTextures);
add(m_firstPassTextures[0], m_secondPassTextures[0], m_firstPassTextures[1]);
m_firstPassTextures[1].display();
add(src, m_firstPassTextures[1], dest);
}
ThermalScannerApp()
: readingsTree(
0.0, 0.0, 360.0, thermalObservedPitchRange, 4
)
, scannerThread(&ThermalScannerApp::scannerThreadFunc, this)
, httpdThread(&ThermalScannerApp::httpdThreadFunc, this)
, wsdThread(&ThermalScannerApp::wsdThreadFunc, this)
{
isRunning = true;
viewPitch = thermalViewPitchRange/2.0;
viewYaw = 180.0;
isViewLockedToDeviceOrientation = false;
prevThermalUpdateTime = 0.0;
viewImage.create(windowWidth, windowHeight);
for(int i = 0; i < 0; i++) {
RectTree<SensorReading>::Rect rect(
(double)rand()/(double)RAND_MAX*360.0,
(double)rand()/(double)RAND_MAX*thermalObservedPitchRange,
(double)rand()/(double)RAND_MAX*50.0,
(double)rand()/(double)RAND_MAX*50.0,
SensorReading((double)rand()/(double)RAND_MAX*30.0, 5)
);
readingsTree.add(rect);
}
if(!font.loadFromFile("Arial Black.ttf")) {
throw std::runtime_error("Unable to load font!");
}
sensorUpdateDelay = 35;
scannerThread.launch();
httpdThread.launch();
//wsdThread.launch();
wsdThread.launch();
}
void draw (sf::RenderTarget & target, sf::RenderStates states = sf::RenderStates::Default) const
{
lightBuffer.clear();
texture.display();
states.texture = &texture.getTexture();
for (const auto & light : lights)
{
light.draw(lightBuffer, getView(), states);
}
sf::Vector2f dimensions = sf::Vector2f(texture.getSize());
sf::VertexArray vertices(sf::Quads, 4);
vertices[0] = sf::Vertex(sf::Vector2f(0.f, 0.f), sf::Color(255, 255, 255, minAlpha), sf::Vector2f(0.f, 0.f));
vertices[1] = sf::Vertex(sf::Vector2f(dimensions.x, 0.f), sf::Color(255, 255, 255, minAlpha), sf::Vector2f(dimensions.x, 0.f));
vertices[2] = sf::Vertex(dimensions, sf::Color(255, 255, 255, minAlpha), dimensions);
vertices[3] = sf::Vertex(sf::Vector2f(0.f, dimensions.y), sf::Color(255, 255, 255, minAlpha), sf::Vector2f(0.f, dimensions.y));
lightBuffer.draw(vertices, states);
lightBuffer.display();
target.draw(sf::Sprite(lightBuffer.getTexture()));
}
void BGForced::draw( sf::RenderTexture &screen )
{
if ( Background::pos_ready && Background::spd_ready )
{
if ( Background::speed_x != 0 )
{
// recalculate the pos_x
// reset back if overflow
// OUTSIDE of screen only, the value must be <= 0
Background::draw_x += Background::speed_x;
while ( Background::draw_x > 0 )
Background::draw_x -= Background::tex_w;
while ( Background::draw_x < ( Background::tex_w * -1 ) )
Background::draw_x += Background::tex_w;
}
if ( Background::speed_y != 0 )
{
// recalculate the pos_y
// reset back if overflow
// OUTSIDE of screen only, the value must be <= 0
Background::draw_y += Background::speed_y;
while ( Background::draw_y > 0 )
Background::draw_y -= Background::tex_h;
while ( Background::draw_y < ( Background::tex_h * -1 ) )
Background::draw_y += Background::tex_h;
}
//printf("draw x %i y %i\n", Background::draw_x, Background::draw_y);
sf::Sprite SPR;
SPR.setTexture( Background::texture );
SPR.setTextureRect( sf::IntRect(0, 0, Background::draw_w, Background::draw_h) );
SPR.setPosition( Background::draw_x, Background::draw_y );
screen.draw( SPR );
}
}
