void Printer::flowRender()
{
// add extra padding at the bottom to pages with height not divisible by view port
int paddingBottom = pageSize.height() - (webView->page()->mainFrame()->contentsSize().height() % pageSize.height());
QString styleString = QString::fromUtf8("padding-bottom: ") + QString::number(paddingBottom) + "px;";
webView->page()->mainFrame()->findFirstElement("body").setAttribute("style", styleString);
// render the Qwebview
QPainter painter;
QRect viewPort(0, 0, 0, 0);
painter.begin(paintDevice);
painter.setRenderHint(QPainter::Antialiasing);
painter.setRenderHint(QPainter::SmoothPixmapTransform);
// get all references to dontbreak divs
int start = 0, end = 0;
int fullPageResolution = webView->page()->mainFrame()->contentsSize().height();
QWebElementCollection dontbreak = webView->page()->mainFrame()->findAllElements(".dontbreak");
foreach (QWebElement dontbreakElement, dontbreak) {
if ((dontbreakElement.geometry().y() + dontbreakElement.geometry().height()) - start < pageSize.height()) {
// One more element can be placed
end = dontbreakElement.geometry().y() + dontbreakElement.geometry().height();
} else {
// fill the page with background color
QRect fullPage(0, 0, pageSize.width(), pageSize.height());
QBrush fillBrush(templateOptions->color_palette.color1);
painter.fillRect(fullPage, fillBrush);
QRegion reigon(0, 0, pageSize.width(), end - start);
viewPort.setRect(0, start, pageSize.width(), end - start);
// render the base Html template
webView->page()->mainFrame()->render(&painter, QWebFrame::ContentsLayer, reigon);
// scroll the webview to the next page
webView->page()->mainFrame()->scroll(0, dontbreakElement.geometry().y() - start);
// rendering progress is 4/5 of total work
emit(progessUpdated((end * 80.0 / fullPageResolution) + done));
// add new pages only in print mode, while previewing we don't add new pages
if (printMode == Printer::PRINT)
static_cast<QPrinter*>(paintDevice)->newPage();
else {
painter.end();
return;
}
start = dontbreakElement.geometry().y();
}
}
// render the remianing page
QRect fullPage(0, 0, pageSize.width(), pageSize.height());
QBrush fillBrush(templateOptions->color_palette.color1);
painter.fillRect(fullPage, fillBrush);
QRegion reigon(0, 0, pageSize.width(), end - start);
webView->page()->mainFrame()->render(&painter, QWebFrame::ContentsLayer, reigon);
painter.end();
}
QPointF PageItem::bookmarkPosition(const QString &bookmark) const
{
Okular::DocumentViewport viewPort(KUrl(bookmark).htmlRef());
if (viewPort.pageNumber != m_viewPort.pageNumber) {
return QPointF(-1, -1);
}
return QPointF(qMax((qreal)0, width() - m_flickable.data()->width()) * viewPort.rePos.normalizedX,
qMax((qreal)0, height() - m_flickable.data()->height()) * viewPort.rePos.normalizedY);
}
void PageItem::goToBookmark(const QString &bookmark)
{
Okular::DocumentViewport viewPort(KUrl(bookmark).htmlRef());
setPageNumber(viewPort.pageNumber);
//Are we in a flickable?
if (m_flickable) {
//normalizedX is a proportion, so contentX will be the difference between document and viewport times normalizedX
m_flickable.data()->setProperty("contentX", qMax((qreal)0, width() - m_flickable.data()->width()) * viewPort.rePos.normalizedX);
m_flickable.data()->setProperty("contentY", qMax((qreal)0, height() - m_flickable.data()->height()) * viewPort.rePos.normalizedY);
}
}
void PageItem::setBookmarkAtPos(qreal x, qreal y)
{
Okular::DocumentViewport viewPort(m_viewPort);
viewPort.rePos.normalizedX = x;
viewPort.rePos.normalizedY = y;
m_documentItem.data()->document()->bookmarkManager()->addBookmark(viewPort);
if (!m_bookmarked) {
m_bookmarked = true;
emit bookmarkedChanged();
}
emit bookmarksChanged();
}
void PageItem::removeBookmarkAtPos(qreal x, qreal y)
{
Okular::DocumentViewport viewPort(m_viewPort);
viewPort.rePos.enabled = true;
viewPort.rePos.normalizedX = x;
viewPort.rePos.normalizedY = y;
m_documentItem.data()->document()->bookmarkManager()->addBookmark(viewPort);
if (m_bookmarked && m_documentItem.data()->document()->bookmarkManager()->bookmarks(m_viewPort.pageNumber).count() == 0) {
m_bookmarked = false;
emit bookmarkedChanged();
}
emit bookmarksChanged();
}
sf::View CroppingViewFactory::createView(const sf::RenderTarget& renderTarget,
const sf::Vector2f& position,
const sf::Vector2f& size) const
{
sf::View view({position.x, position.y, size.x, size.y});
sf::FloatRect viewPort({
position.x / renderTarget.getSize().x,
position.y / renderTarget.getSize().y,
size.x / renderTarget.getSize().x,
size.y / renderTarget.getSize().y
});
view.setViewport(viewPort);
return view;
}
void CWinRenderer::RenderPS(CD3DTexture* target)
{
if (m_bUseHQScaler)
target = &m_IntermediateTarget;
CD3D11_VIEWPORT viewPort(0.0f, 0.0f, static_cast<float>(target->GetWidth()), static_cast<float>(target->GetHeight()));
if (m_bUseHQScaler)
DX::Windowing()->ResetScissors();
// reset view port
DX::DeviceResources::Get()->GetD3DContext()->RSSetViewports(1, &viewPort);
// select destination rectangle
CPoint destPoints[4];
if (m_renderOrientation)
{
for (size_t i = 0; i < 4; i++)
destPoints[i] = m_rotatedDestCoords[i];
}
else
{
CRect destRect = m_bUseHQScaler ? m_sourceRect : CServiceBroker::GetWinSystem()->GetGfxContext().StereoCorrection(m_destRect);
destPoints[0] = { destRect.x1, destRect.y1 };
destPoints[1] = { destRect.x2, destRect.y1 };
destPoints[2] = { destRect.x2, destRect.y2 };
destPoints[3] = { destRect.x1, destRect.y2 };
}
CRenderBuffer& buf = m_renderBuffers[m_iYV12RenderBuffer];
// set params
m_outputShader->SetDisplayMetadata(buf.hasDisplayMetadata, buf.displayMetadata, buf.hasLightMetadata, buf.lightMetadata);
m_outputShader->SetToneMapParam(m_videoSettings.m_ToneMapParam);
m_colorShader->SetParams(m_videoSettings.m_Contrast, m_videoSettings.m_Brightness, DX::Windowing()->UseLimitedColor());
m_colorShader->SetColParams(buf.color_space, buf.bits, !buf.full_range, buf.texBits);
// render video frame
m_colorShader->Render(m_sourceRect, destPoints, &buf, target);
// Restore our view port.
DX::Windowing()->RestoreViewPort();
}
void CWinRenderer::RenderPS(CD3DTexture* target)
{
if (m_bUseHQScaler)
target = &m_IntermediateTarget;
CD3D11_VIEWPORT viewPort(0.0f, 0.0f, static_cast<float>(target->GetWidth()), static_cast<float>(target->GetHeight()));
if (m_bUseHQScaler)
DX::Windowing().ResetScissors();
// reset view port
DX::DeviceResources::Get()->GetD3DContext()->RSSetViewports(1, &viewPort);
// select destination rectangle
CPoint destPoints[4];
if (m_renderOrientation)
{
for (size_t i = 0; i < 4; i++)
destPoints[i] = m_rotatedDestCoords[i];
}
else
{
CRect destRect = m_bUseHQScaler ? m_sourceRect : g_graphicsContext.StereoCorrection(m_destRect);
destPoints[0] = { destRect.x1, destRect.y1 };
destPoints[1] = { destRect.x2, destRect.y1 };
destPoints[2] = { destRect.x2, destRect.y2 };
destPoints[3] = { destRect.x1, destRect.y2 };
}
// render video frame
m_colorShader->Render(m_sourceRect, destPoints,
m_videoSettings.m_Contrast,
m_videoSettings.m_Brightness,
&m_renderBuffers[m_iYV12RenderBuffer], target);
// Restore our view port.
DX::Windowing().RestoreViewPort();
}
void Printer::render(int Pages = 0)
{
// keep original preferences
QPointer<ProfileWidget2> profile = MainWindow::instance()->graphics();
int profileFrameStyle = profile->frameStyle();
int animationOriginal = prefs.animation_speed;
double fontScale = profile->getFontPrintScale();
double printFontScale = 1.0;
// apply printing settings to profile
profile->setFrameStyle(QFrame::NoFrame);
profile->setPrintMode(true, !printOptions->color_selected);
profile->setToolTipVisibile(false);
prefs.animation_speed = 0;
// render the Qwebview
QPainter painter;
QRect viewPort(0, 0, pageSize.width(), pageSize.height());
painter.begin(paintDevice);
painter.setRenderHint(QPainter::Antialiasing);
painter.setRenderHint(QPainter::SmoothPixmapTransform);
// get all refereces to diveprofile class in the Html template
QWebElementCollection collection = webView->page()->mainFrame()->findAllElements(".diveprofile");
QSize originalSize = profile->size();
if (collection.count() > 0) {
printFontScale = (double)collection.at(0).geometry().size().height() / (double)profile->size().height();
profile->resize(collection.at(0).geometry().size());
}
profile->setFontPrintScale(printFontScale);
int elemNo = 0;
for (int i = 0; i < Pages; i++) {
// render the base Html template
webView->page()->mainFrame()->render(&painter, QWebFrame::ContentsLayer);
// render all the dive profiles in the current page
while (elemNo < collection.count() && collection.at(elemNo).geometry().y() < viewPort.y() + viewPort.height()) {
// dive id field should be dive_{{dive_no}} se we remove the first 5 characters
QString diveIdString = collection.at(elemNo).attribute("id");
int diveId = diveIdString.remove(0, 5).toInt(0, 10);
putProfileImage(collection.at(elemNo).geometry(), viewPort, &painter, get_dive_by_uniq_id(diveId), profile);
elemNo++;
}
// scroll the webview to the next page
webView->page()->mainFrame()->scroll(0, pageSize.height());
viewPort.adjust(0, pageSize.height(), 0, pageSize.height());
// rendering progress is 4/5 of total work
emit(progessUpdated((i * 80.0 / Pages) + done));
if (i < Pages - 1 && printMode == Printer::PRINT)
static_cast<QPrinter*>(paintDevice)->newPage();
}
painter.end();
// return profle settings
profile->setFrameStyle(profileFrameStyle);
profile->setPrintMode(false);
profile->setFontPrintScale(fontScale);
profile->setToolTipVisibile(true);
profile->resize(originalSize);
prefs.animation_speed = animationOriginal;
//replot the dive after returning the settings
profile->plotDive(0, true);
}
int main(void) {
sf::ContextSettings settings;
settings.depthBits = 8;
settings.stencilBits = 0;
settings.antialiasingLevel = 0;
settings.majorVersion = 3;
settings.minorVersion = 3;
sf::Window window(sf::VideoMode(1440, 900), "A Game", sf::Style::Default, settings);
window.setFramerateLimit(60);
glewInit();
glEnable(GL_DEPTH_TEST);
EventQueue eventQueue;
QuadTree quadTree(eventQueue, 2048);
Renderer renderer({32, 32, 32, 32, 2048}, 512, 1440, 900);
sf::Image img1;
img1.loadFromFile("res/textures/test.png");
Texture tex1;
tex1.loadFromImage(img1);
sf::Image img2;
img2.loadFromFile("res/textures/test2.png");
Texture tex2;
tex2.loadFromImage(img2);
std::vector<Platform> platforms_;
std::vector<std::unique_ptr<GameObject>> gameObjects_;
for (auto i=0u; i<10; ++i) {
platforms_.emplace_back(quadTree, renderer,
Vector2Glf(i*32.0f, 0.0f), Vector2Glf(32.0f, 32.0f),
tex1, Vector2Glf(0.25f, 0.25f), 4);
}
sf::Image charImg;
charImg.loadFromFile("res/textures/testChar.png");
Texture charTex;
charTex.loadFromImage(charImg);
gameObjects_.push_back(make_unique<Character>(quadTree, renderer,
Vector2Glf(64.0f, 0.0f), Vector2Glf(64.0f, 64.0f),
charTex, Vector2Glf(1.0f, 1.0f), 4));
/*for (auto j=0; j<4; ++j) {
for (auto i=0; i<30; ++i) {
Sprite& spr = renderer.getSpriteReference();
spr.setTexture(&tex2);
spr.setPosition({ 128.0f*i, 128.0f*j - 256.0f });
spr.setDepth(0.5f);
}
}*/
/*for (auto i=0; i<10; ++i) {
Sprite& spr = renderer.getSpriteReference();
spr.setTexture(&tex1);
spr.setType(Sprite::TYPE_SOLID);
spr.setScale({ 0.5f, 0.5f });
spr.setPosition({ 128.0f*i, 0.0f });
}*/
ParallaxBackground bg(renderer);
bg.addLayer("res/textures/cityBackground4.png", 0, 0.2f, { 1000.0f, 0.0f });
bg.addLayer("res/textures/cityBackground3.png", 1, 0.3f, { 1000.0f, -600.0f });
bg.addLayer("res/textures/cityBackground2.png", 2, 0.6f, { 6000.0f, 40.0f });
bg.addLayer("res/textures/cityBackground1.png", 3, 0.75f, { 4500.0f, 50.0f });
Shader shader("shaders/VS_Sprite.glsl", "shaders/FS_Sprite.glsl");
ViewPort viewPort(1440.0f, 900.0f, Vector2Glf(0.0f, 0.0f));
viewPort.setPosition({ 512.0f, 0.0f });
float t = 0.0f;
// The main loop - ends as soon as the window is closed
while (window.isOpen()) {
// Event processing
sf::Event event;
while (window.pollEvent(event)) {
// Request for closing the window
if (event.type == sf::Event::Closed)
window.close();
}
// Activate the window for OpenGL rendering
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
/*for (auto& o : gameObjects_) {
o->update();
}*/
viewPort.setPosition({2160.0f+1440.0f*cos(t*PI*0.1 + PI), 0.0f});
bg.update(viewPort);
renderer.render(viewPort, shader, t);
window.display();
t += 1.0f/60.0f;
}
return 0;
}
int main(int argc, char* argv[])
{
START_EASYLOGGINGPP(argc, argv);
Py_Initialize();
PyRun_SimpleString("print pow(2, 3)");
Py_Finalize();
el::Configurations conf("config/logging.cfg");
el::Loggers::reconfigureAllLoggers(conf);
startLog();
LOG(INFO) << "Initialising SFML Render Window with a resolution of " << windowWidth << "x" << windowHeight;
LOG(INFO) << "IGNORE OPENGL MISSING EXTENSION!";
sf::RenderWindow window(sf::VideoMode(windowWidth, windowHeight), windowTitle, sf::Style::Close, settings);
window.setVerticalSyncEnabled(false); // vsync messes with updates
sf::View viewPort(sf::Vector2f(windowWidth / 2, windowHeight / 2), sf::Vector2f(windowWidth, windowHeight));
// Initialise physics
//b2Vec2 gravity(0.0f, 0.0f);
//b2World world(gravity);
// scripting init here!
/*script::FalconEngine scripting;
// load resource paths
try
{
scripting.embed("resources.fal");
}
catch (Falcon::Error *err)
{
Falcon::AutoCString edesc(err->toString());
LOG(FATAL) << edesc.c_str() << std::endl;
err->decref();
return 1;
}
try
{
scripting.embed("test.fal");
}
catch (Falcon::Error *err)
{
Falcon::AutoCString edesc(err->toString());
LOG(FATAL) << edesc.c_str() << std::endl;
err->decref();
return 1;
}*/
texture.loadFromFile("data/abstract liquify thing.png");
sprite.setTexture(texture);
int testMusic = loadMusic("data/audio/music/Three_Days_Grace_-_The_High_Road_(mp3.pm).ogg");
int channel2 = loadMusic("data/audio/music/Kygo - Firestone (feat. Conrad).ogg");
int channel3 = loadMusic("data/audio/music/Seether - Broken (Featuring Amy Lee).ogg");
int channel4 = loadMusic("data/audio/music/New Found Glory - This Disaster.ogg");
int channel5 = loadMusic("data/audio/music/Story of the Year - Until the Day I Die.ogg");
Player player(sf::Vector2f(windowWidth / 2, windowHeight / 2));
FriendlyTrader test(sf::Vector2f(64, 128));
sf::Clock clock;
sf::Clock seconds;
while (window.isOpen())
{
sf::Time elapsed = clock.getElapsedTime();
bool fadeCompleted;
if (elapsed.asMicroseconds() >= updateRate.asMicroseconds())
{
clock.restart();
update(&window, &player, &viewPort);
if (!getFadeCompleted())
{
fadeCompleted = true;
//windowFade = fadeOut(&window);
}
test.Update();
}
elapsed = seconds.getElapsedTime();
if (elapsed.asSeconds() >= 1)
{
UPS = tick;
FPS = frame;
//#ifdef _DEBUG
char windowTitle[128] = "SFML and Box2D";
char buffer[8];
strcat_s(windowTitle, " | ");
_itoa_s(UPS, buffer, 10);
strcat_s(windowTitle, "UPS: ");
strcat_s(windowTitle, buffer);
strcat_s(windowTitle, ", FPS: ");
_itoa_s(FPS, buffer, 10);
strcat_s(windowTitle, buffer);
window.setTitle(windowTitle);
//#endif
//std::cout << "UPS: " << UPS << ", FPS: " << FPS << std::endl;
tick = 0;
frame = 0;
seconds.restart();
}
render(&window, viewPort);
}
LOG(INFO) << "Unloading SFML";
sf::sleep(sf::seconds(0.5));
//LogWhiteSpace();
endLog();
std::cout << std::endl;
return 0;
}
void RenderManager::prepareBackground() {
_backgroundDirtyRect.clip(_backgroundWidth, _backgroundHeight);
RenderTable::RenderState state = _renderTable.getRenderState();
if (state == RenderTable::PANORAMA) {
// Calculate the visible portion of the background
Common::Rect viewPort(_workingWidth, _workingHeight);
viewPort.translate(-(_screenCenterX - _backgroundOffset), 0);
Common::Rect drawRect = _backgroundDirtyRect;
drawRect.clip(viewPort);
// Render the visible portion
if (!drawRect.isEmpty()) {
blitSurfaceToSurface(_currentBackgroundImage, drawRect, _backgroundSurface, _screenCenterX - _backgroundOffset + drawRect.left, drawRect.top);
}
// Mark the dirty portion of the surface
_backgroundSurfaceDirtyRect = _backgroundDirtyRect;
_backgroundSurfaceDirtyRect.translate(_screenCenterX - _backgroundOffset, 0);
// Panorama mode allows the user to spin in circles. Therefore, we need to render
// the portion of the image that wrapped to the other side of the screen
if (_backgroundOffset < _screenCenterX) {
viewPort.moveTo(-(_screenCenterX - (_backgroundOffset + _backgroundWidth)), 0);
drawRect = _backgroundDirtyRect;
drawRect.clip(viewPort);
if (!drawRect.isEmpty())
blitSurfaceToSurface(_currentBackgroundImage, drawRect, _backgroundSurface, _screenCenterX - (_backgroundOffset + _backgroundWidth) + drawRect.left, drawRect.top);
Common::Rect tmp = _backgroundDirtyRect;
tmp.translate(_screenCenterX - (_backgroundOffset + _backgroundWidth), 0);
if (!tmp.isEmpty())
_backgroundSurfaceDirtyRect.extend(tmp);
} else if (_backgroundWidth - _backgroundOffset < _screenCenterX) {
viewPort.moveTo(-(_screenCenterX + _backgroundWidth - _backgroundOffset), 0);
drawRect = _backgroundDirtyRect;
drawRect.clip(viewPort);
if (!drawRect.isEmpty())
blitSurfaceToSurface(_currentBackgroundImage, drawRect, _backgroundSurface, _screenCenterX + _backgroundWidth - _backgroundOffset + drawRect.left, drawRect.top);
Common::Rect tmp = _backgroundDirtyRect;
tmp.translate(_screenCenterX + _backgroundWidth - _backgroundOffset, 0);
if (!tmp.isEmpty())
_backgroundSurfaceDirtyRect.extend(tmp);
}
} else if (state == RenderTable::TILT) {
// Tilt doesn't allow wrapping, so we just do a simple clip
Common::Rect viewPort(_workingWidth, _workingHeight);
viewPort.translate(0, -(_screenCenterY - _backgroundOffset));
Common::Rect drawRect = _backgroundDirtyRect;
drawRect.clip(viewPort);
if (!drawRect.isEmpty())
blitSurfaceToSurface(_currentBackgroundImage, drawRect, _backgroundSurface, drawRect.left, _screenCenterY - _backgroundOffset + drawRect.top);
// Mark the dirty portion of the surface
_backgroundSurfaceDirtyRect = _backgroundDirtyRect;
_backgroundSurfaceDirtyRect.translate(0, _screenCenterY - _backgroundOffset);
} else {
if (!_backgroundDirtyRect.isEmpty())
blitSurfaceToSurface(_currentBackgroundImage, _backgroundDirtyRect, _backgroundSurface, _backgroundDirtyRect.left, _backgroundDirtyRect.top);
_backgroundSurfaceDirtyRect = _backgroundDirtyRect;
}
// Clear the dirty rect since everything is clean now
_backgroundDirtyRect = Common::Rect();
_backgroundSurfaceDirtyRect.clip(_workingWidth, _workingHeight);
}
