QImage QSGSoftwareRenderLoop::grab(QQuickWindow *window)
{
//If the window was never shown, create a new backing store
if (!m_backingStores.contains(window)) {
m_backingStores[window] = new QBackingStore(window);
// Call create on window to make sure platform window is created
window->create();
}
//If there is no WindowData, add one
if (!m_windows.contains(window)) {
WindowData data;
data.updatePending = false;
m_windows[window] = data;
}
m_windows[window].grabOnly = true;
renderWindow(window);
QImage grabbed = grabContent;
grabbed.detach();
grabContent = QImage();
return grabbed;
}
void QSGSoftwareRenderLoop::exposureChanged(QQuickWindow *window)
{
if (window->isExposed()) {
m_windows[window].updatePending = true;
renderWindow(window, true);
}
}
/******************************************************************************
* Renders the image in a rectangle given in viewport coordinates.
******************************************************************************/
void DefaultImagePrimitive::renderViewport(SceneRenderer* renderer, const Point2& pos, const Vector2& size)
{
QSize imageSize = renderer->outputSize();
Point2 windowPos((pos.x() + 1.0f) * imageSize.width() / 2, (-(pos.y() + size.y()) + 1.0) * imageSize.height() / 2);
Vector2 windowSize(size.x() * imageSize.width() / 2, size.y() * imageSize.height() / 2);
renderWindow(renderer, windowPos, windowSize);
}
bool CanvasExporterPS::write()
{
QString format("PostScript (%1)");
int vtkPSFormat = -1;
if (outputFormat() == format.arg("PS"))
vtkPSFormat = vtkGL2PSExporter::PS_FILE;
else if (outputFormat() == format.arg("EPS"))
vtkPSFormat = vtkGL2PSExporter::EPS_FILE;
else if (outputFormat() == format.arg("PDF"))
vtkPSFormat = vtkGL2PSExporter::PDF_FILE;
else if (outputFormat() == format.arg("TEX"))
vtkPSFormat = vtkGL2PSExporter::TEX_FILE;
else if (outputFormat() == format.arg("SVG"))
vtkPSFormat = vtkGL2PSExporter::SVG_FILE;
else
return false;
// vtkGL2PSExporter always appends a file extensions, so we should cut it if it already exists
QString fileName = outputFileName();
QString ext = fileExtension();
QFileInfo info(fileName);
if (info.suffix().toLower() == ext)
{
fileName.truncate(fileName.length() - ext.length() - 1); // cut ".EXT"
}
m_exporter->SetFilePrefix(fileName.toUtf8().data());
m_exporter->SetFileFormat(vtkPSFormat);
m_exporter->SetRenderWindow(renderWindow());
m_exporter->Write();
return true;
}
CClientGameEngine::CClientGameEngine(boost::program_options::variables_map vm) : CGameEngine(false), m_syncTime(0.f)
{
boost::shared_ptr<CSFMLLog> logger = CSFMLLog::init();
boost::shared_ptr<CSoundEngine> soundEngine(new CSoundEngine());
setSoundEngine(soundEngine);
UInt16 width = vm["width"].as<UInt16>();
UInt16 height = vm["height"].as<UInt16>();
getLevel()->setScreenSize(sf::Vector2i(800,height+1));
boost::shared_ptr<sf::RenderWindow> renderWindow(new sf::RenderWindow(sf::VideoMode(width,height,32),"Tour devel 0.1b"));
boost::shared_ptr<CRenderEngine> renderEngine = boost::shared_ptr<CRenderEngine>(new CRenderEngine(renderWindow, logger));
setRenderEngine(renderEngine);
m_inputEngine = boost::shared_ptr<CInputEngine>(new CInputEngine(renderWindow));
boost::shared_ptr<CClientSession> session(new CClientSession());
boost::shared_ptr<CClientEventEngine> eventEngine = boost::shared_ptr<CClientEventEngine>(new CClientEventEngine(session));
setEventEngine(eventEngine);
m_clientSession = session;
m_clientEventEngine = eventEngine;
std::string host = vm["h"].as<std::string>();
std::string port = vm["p"].as<std::string>();;
session->connect(host,port);
CLog::debug("Client started");
}
void AbstractRenderView::initializeForFirstPaint()
{
if (m_onFirstPaintInitialized)
{
return;
}
m_onFirstPaintInitialized = true;
// let the subclass create a context first
initializeRenderContext();
auto updateRenWinDpi = [this] () -> void
{
auto renWin = renderWindow();
auto nativeParent = nativeParentWidget();
if (!renWin || !nativeParent)
{
return;
}
const auto dpi = static_cast<int>(nativeParent->windowHandle()->screen()->logicalDotsPerInch());
if (dpi != renWin->GetDPI())
{
renWin->SetDPI(dpi);
}
};
if (auto nativeParent = nativeParentWidget())
{
connect(nativeParent->windowHandle(), &QWindow::screenChanged, updateRenWinDpi);
}
updateRenWinDpi();
}
void SMDLEDShield::message(const char *_text, bool store) {
int i, j;
int temp;
//save a private copy of the text string
strcpy(text, _text);
//save to eeprom
if (store)
eeprom_write_block(text, _store, strlen(text)+1);
buffer_width = strlen(_text)*4 + 16;
memset(buffer,0,128*8);
//Preprocess the message into font indeces
for(i=0; i< strlen(text); i++) {
if((64 < text[i]) && (text[i] < 91))//upper case
temp = text[i] - 65;
else if((96 < text[i]) && (text[i] < 123))//lower case
temp = text[i] - 97;
else //unmapped
temp = -1;
//Render the buffer
for(j=0; j<8; j++) {
buffer[j][(i/2)+1] |= (temp > -1)?pgm_read_byte(&(charset[(int)temp][j])) << 4*(i%2):0;
}
}
left_bit = 0;
//Render the initial window buffer
renderWindow();
}
int main()
{
sf::RenderWindow renderWindow(sf::VideoMode(800u, 600u), "TMX Loader");
//create map loader and load map
tmx::MapLoader ml("maps/");
ml.Load("desert.tmx");
sf::Clock deltaClock, frameClock;
//-----------------------------------//
while(renderWindow.isOpen())
{
//poll input
sf::Event event;
while(renderWindow.pollEvent(event))
{
if (event.type == sf::Event::Closed)
renderWindow.close();
}
//allow moving of view
sf::View view = renderWindow.getView();
sf::Vector2f movement;
if(sf::Keyboard::isKeyPressed(sf::Keyboard::Left))
movement.x = -1.f;
else if(sf::Keyboard::isKeyPressed(sf::Keyboard::Right))
movement.x = 1.f;
if(sf::Keyboard::isKeyPressed(sf::Keyboard::Up))
movement.y = -1.f;
else if(sf::Keyboard::isKeyPressed(sf::Keyboard::Down))
movement.y = 1.f;
float dt = deltaClock.restart().asSeconds();
movement = Helpers::Vectors::Normalize(movement) * 300.f * dt;
view.move(movement);
renderWindow.setView(view);
frameClock.restart();
//draw
renderWindow.clear();
renderWindow.draw(ml);
renderWindow.display();
const float time = 1.f / frameClock.getElapsedTime().asSeconds();
std::stringstream stream;
stream << "Use the cursor keys to move the view. Current fps: " << time << std::endl;
renderWindow.setTitle(stream.str());
}
return 0;
}
int main()
{
sf::RenderWindow renderWindow(sf::VideoMode(800u, 600u), "TMX Loader");
sf::Font font = loadFont();
sf::Text fpsText = getFpsText(font);
//set the debugging output mode
tmx::setLogLevel(tmx::Logger::Info | tmx::Logger::Error);
//create map loader and load map
tmx::MapLoader ml("maps/");
ml.load("desert.tmx");
sf::Clock deltaClock, frameClock;
const float dt = 0.01f;
float previousUpdateTime = deltaClock.getElapsedTime().asSeconds();
float accumulator = 0.f;
while(renderWindow.isOpen())
{
handleWindowEvent(renderWindow);
//update
float currentTime = deltaClock.getElapsedTime().asSeconds();
float frameTime = currentTime - previousUpdateTime;
previousUpdateTime = currentTime;
accumulator += frameTime;
sf::Vector2f movement;
while ( accumulator >= dt )
{
movement = getViewMovement(dt);
accumulator -= dt;
}
//allow moving of view
sf::View view = renderWindow.getView();
view.move(movement);
renderWindow.setView(view);
//show fps
float fpsCount = (1.f / frameClock.restart().asSeconds());
fpsText.setString( "FPS: " + (std::to_string(fpsCount)));
fpsText.move(movement);
//draw
renderWindow.clear();
renderWindow.draw(ml);
renderWindow.draw(fpsText);
renderWindow.display();
}
return 0;
}
QImage QQuickTrivialWindowManager::grab(QQuickWindow *window)
{
if (!m_windows.contains(window))
return QImage();
m_windows[window].grabOnly = true;
renderWindow(window);
QImage grabbed = grabContent;
grabContent = QImage();
return grabbed;
}
void MainCanvas::renderTree()
{
preRender();
DisplayEngine* pDisplayEngine = getPlayer()->getDisplayEngine();
unsigned numWindows = pDisplayEngine->getNumWindows();
for (unsigned i=0; i<numWindows; ++i) {
ScopeTimer Timer(RootRenderProfilingZone);
WindowPtr pWindow = pDisplayEngine->getWindow(i);
IntRect viewport = pWindow->getViewport();
renderWindow(pWindow, MCFBOPtr(), viewport);
}
GLContextManager::get()->reset();
}
bool QQuickTrivialWindowManager::event(QEvent *e)
{
if (e->type() == QEvent::User) {
eventPending = false;
for (QHash<QQuickWindow *, WindowData>::const_iterator it = m_windows.constBegin();
it != m_windows.constEnd(); ++it) {
const WindowData &data = it.value();
if (data.updatePending)
renderWindow(it.key());
}
return true;
}
return QObject::event(e);
}
int main()
{
sf::RenderWindow renderWindow(sf::VideoMode(800u, 600u), "TMX Loader");
renderWindow.setVerticalSyncEnabled(true);
//create map loader and load map
tmx::MapLoader ml("maps/");
ml.Load("isometric_grass_and_water.tmx");
//adjust the view to centre on map
sf::View view = renderWindow.getView();
view.setCenter(0.f, 300.f);
renderWindow.setView(view);
//to toggle debug output
bool debug = false;
//-----------------------------------//
while(renderWindow.isOpen())
{
//poll input
sf::Event event;
while(renderWindow.pollEvent(event))
{
if (event.type == sf::Event::Closed)
renderWindow.close();
if(event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::D)
debug = !debug;
}
//draw map
renderWindow.clear();
renderWindow.draw(ml);
if(debug)ml.Draw(renderWindow, tmx::MapLayer::Debug);
renderWindow.display();
//print mouse coords to orthographic (screen) coords and world (isometric) coords
sf::Vector2f mousePosScreen = renderWindow.mapPixelToCoords(sf::Mouse::getPosition(renderWindow));
sf::Vector2f mousePosWorld = ml.OrthogonalToIsometric(mousePosScreen);
std::stringstream stream;
stream << "Mouse Position: "<< mousePosScreen.x << ", " << mousePosScreen.y << " World Position: " << mousePosWorld.x << ", " << mousePosWorld.y;
renderWindow.setTitle(stream.str());
}
return 0;
}
bool CanvasExporterPS::openGLContextSupported()
{
#if WIN32 && VTK_RENDERING_BACKEND == 1
auto openGLContext = vtkOpenGLRenderWindow::SafeDownCast(renderWindow());
assert(openGLContext);
auto extensionManager = openGLContext->GetExtensionManager();
if (extensionManager->DriverIsIntel())
{
return false;
}
#endif
return CanvasExporter::openGLContextSupported();
}
void D3dDrawManager::drawAllPipes()
{
vprDEBUG_OutputGuard(vrjDBG_DRAW_MGR, vprDBG_HVERB_LVL,
"vrj::GLDrawManager::drawAllPipes()\n",
"vrj::GLDrawManager::drawAllPipes() done.\n");
checkForNewWindows();
for (unsigned int i = 0; i < mOpenWins.size(); i++)
{
D3dWindow* win = mOpenWins[i];
win->checkEvents();
renderWindow(win);
swapWindowBuffers(win);
}
}
void runGame()
{
hideCursor();
initWorld();
unsigned long curtime = ccTimeMilliseconds();
double acctime = 0.0;
while(true){
ccEvent event = updateWindow();
if(event.type == CC_EVENT_WINDOW_QUIT){
break;
}else if(event.type == CC_EVENT_KEY_DOWN){
handleKeyDownWorld(event.keyCode);
}else if(event.type == CC_EVENT_KEY_UP){
handleKeyUpWorld(event.keyCode);
}
unsigned long newtime = ccTimeMilliseconds();
double frametime = (newtime - curtime) * 0.001;
curtime = newtime;
if(frametime > FRAME_CAP){
frametime = FRAME_CAP;
}
acctime += frametime;
bool redraw = false;
while(acctime >= FRAME_DELTA){
acctime -= FRAME_DELTA;
redraw = updateWorld();
}
if(redraw){
renderWorld(2, 1, getWidth() - getGuiWidth() - 3, getHeight() - 8);
renderGui(getWidth() - getGuiWidth(), 0);
}
renderWindow(2);
}
}
void mainLoop()
{
try
{
while (running)
{
setupWindow(width, height, "raycar");
Asset::init(GLContext::context());
SceneGraph::init(GLContext::context());
loadScene("content/raycar.scn");
resetTimer();
double now = 0;
while (sceneRunning && running)
{
pollInput();
double next = timer();
if (active)
{
if (next > now + maxStepTime)
{ // falling behind
now = next - maxStepTime;
}
while (now < next)
{
stepScene();
now += stepTime;
}
}
else
{
now = next;
}
renderWindow();
}
}
}
catch (std::exception const &x)
{
error(x.what());
}
}
void main(int argc, char * argv[]){
glutInit(&argc, argv);
Vector3D *v1 = new Vector3D(2, 3, 5);
Vector3D *v2 = new Vector3D(4, 2, 1);
printf("Dot product: %f\n", v1->dotProduct(*v2));
printf("Magnitude v1: %f\n", v1->magnitude());
printf("Magnitude v2: %f\n", v2->magnitude());
printf("Angle between: %f\n", v1->theta(*v2));
VERTEX3D v[] = { { 0, 0, 0 }, { 1, 0, 0 }, { 0, 1, 0 } };
LINE l[] = { { 0, 1 }, { 1, 2 }, { 0, 2 } };
//Step 1: Initialize GLUT
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
glutInitWindowSize(800, 600);
//Step 2: Create window
mainWindow = glutCreateWindow("3D Solar System");
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
renderWindow();
Object3D *cube = new Object3D(v, VECTOR_SIZE(v));
Object3D *line = new Object3D(v, l, VECTOR_SIZE(v), VECTOR_SIZE(l));
RenderManager *rmg = RenderManager::getInstance();
rmg->RegisterObject(cube);
rmg->RegisterObject(line);
//Step 3: Handlers Functions
glutDisplayFunc(Display);
glutReshapeFunc(Reshape);
glutIdleFunc(Display);
glutKeyboardFunc(keyPressed); // Tell GLUT to use the method "keyPressed" for key presses
//glutKeyboardFunc(keyUp);
glutMainLoop();
}
int main()
{
sf::RenderWindow renderWindow(sf::VideoMode(800u, 600u), "TMX Loader");
//create map loader and load map
tmx::MapLoader ml("maps/");
ml.Load("desert.tmx");
//-----------------------------------//
while(renderWindow.isOpen())
{
//poll input
sf::Event event;
while(renderWindow.pollEvent(event))
{
if (event.type == sf::Event::Closed)
renderWindow.close();
}
//build quad tree by querying visible region
ml.UpdateQuadTree(sf::FloatRect(0.f, 0.f, 800.f, 600.f));
//get a vector of MapObjects contained in the quads intersected by query area
sf::Vector2f mousePos = renderWindow.mapPixelToCoords(sf::Mouse::getPosition(renderWindow));
//NOTE quad tree MUST be updated before attempting to query it
std::vector<tmx::MapObject*> objects = ml.QueryQuadTree(sf::FloatRect(mousePos.x - 10.f, mousePos.y - 10.f, 20.f, 20.f));
//do stuff with returned objects
std::stringstream stream;
stream << "Query object count: " << objects.size();
renderWindow.setTitle(stream.str());
//draw
renderWindow.clear();
renderWindow.draw(ml);
ml.Draw(renderWindow, tmx::MapLayer::Debug); //draw with debug information shown
renderWindow.display();
}
return 0;
}
int displayWelcome()
{
renderWindow("\30" "\31" " Select option\t<ENTER> Accept selected option",
"WELCOME",
OPTION_WIDTH, WELCOME_OPT_COUNT,
&startX, &startY);
drawOptions();
while (1)
{
uint8_t c;
if (read(0, &c, 1) != 1) continue;
if (c == 0x8B)
{
// up arrow
if (selected != 0)
{
selected--;
drawOptions();
};
}
else if (c == 0x8C)
{
// down arrow
if (selected != (WELCOME_OPT_COUNT-1))
{
selected++;
drawOptions();
};
}
else if (c == '\n')
{
break;
};
};
return selected;
};
int main(int argv, char** argc) {
std::vector<Screen*> screens;
int currentScreen = 1;
const unsigned int WIDTH = sf::VideoMode::getDesktopMode().width * 2 / 3;
const unsigned int HEIGHT = std::max(WIDTH / 3, sf::VideoMode::getDesktopMode().height * 2 / 3);
sf::RenderWindow renderWindow(sf::VideoMode(WIDTH, HEIGHT), "Demo Game");
MenuScreen menuScreen;
GameScreen gameScreen;
screens.push_back(&menuScreen);
screens.push_back(&gameScreen);
while (currentScreen >= 0) {
currentScreen = screens[currentScreen]->Run(renderWindow);
}
return EXIT_SUCCESS;
}
/*
* Go through all windows we control and render them in turn.
* Then tick animations if active.
*/
void QSGWindowsRenderLoop::render()
{
RLDEBUG("render");
bool rendered = false;
foreach (const WindowData &wd, m_windows) {
if (wd.pendingUpdate) {
const_cast<WindowData &>(wd).pendingUpdate = false;
renderWindow(wd.window);
rendered = true;
}
}
if (!rendered) {
RLDEBUG("no changes, sleep");
QThread::msleep(m_vsyncDelta);
}
if (m_animationDriver->isRunning()) {
RLDEBUG("advancing animations");
QSG_LOG_TIME_SAMPLE(time_start);
Q_QUICK_SG_PROFILE_START(QQuickProfiler::SceneGraphWindowsAnimations);
m_animationDriver->advance();
RLDEBUG("animations advanced");
qCDebug(QSG_LOG_TIME_RENDERLOOP,
"animations ticked in %dms",
int((qsg_render_timer.nsecsElapsed() - time_start)/1000000));
Q_QUICK_SG_PROFILE_END(QQuickProfiler::SceneGraphWindowsAnimations);
// It is not given that animations triggered another maybeUpdate()
// and thus another render pass, so to keep things running,
// make sure there is another frame pending.
maybePostUpdateTimer();
emit timeToIncubate();
}
}
/*
* Go through all windows we control and render them in turn.
* Then tick animations if active.
*/
void QSGWindowsRenderLoop::render()
{
RLDEBUG("render");
foreach (const WindowData &wd, m_windows) {
if (wd.pendingUpdate) {
const_cast<WindowData &>(wd).pendingUpdate = false;
renderWindow(wd.window);
}
}
if (m_animationDriver->isRunning()) {
RLDEBUG("advancing animations");
QSG_RENDER_TIMING_SAMPLE(time_start);
m_animationDriver->advance();
RLDEBUG("animations advanced");
#ifndef QSG_NO_RENDER_TIMING
if (qsg_render_timing) {
qDebug("WindowsRenderLoop: animations=%d ms",
int((qsg_render_timer.nsecsElapsed() - time_start)/1000000));
}
if (QQmlProfilerService::Enabled) {
QQmlProfilerService::sceneGraphFrame(
QQmlProfilerService::SceneGraphWindowsAnimations,
qsg_render_timer.nsecsElapsed() - time_start);
}
#endif
// It is not given that animations triggered another maybeUpdate()
// and thus another render pass, so to keep things running,
// make sure there is another frame pending.
maybePostUpdateTimer();
emit timeToIncubate();
}
}
int main()
{
OpenConsole();
Screen::setScreenSize(Vector2(1280, 720));
sf::RenderWindow renderWindow(sf::VideoMode(Screen::getScreenSize().x, Screen::getScreenSize().y, 32), "RayMarch Renderer", sf::Style::Titlebar | sf::Style::Close);
renderWindow.setActive();
GUI gui = GUI(&renderWindow);
renderWindow.resetGLStates();
//Graphics::setImageSize(Vector2(1280, 720));
Graphics::Init();
Camera camera = Camera(Vector3(0, 4, -6), Vector3(0, -3, 6).normalized(), Graphics::getImageSize().x / Graphics::getImageSize().y, PI / 4);
int samples = 128;
int currentSample = 0;
int gridWidth = 4;
int gridHeight = 4;
int chunkWidth = Graphics::getImageSize().x / gridWidth;
int chunkHeight = Graphics::getImageSize().y / gridHeight;
int x = ceil((float)gridWidth / 2.0) - 1;
int y = ceil((float)gridHeight / 2.0) - 1;
Vector2 dir = Vector2(-1, 0);
int squaresPassed = 0;
int lastSquaresPassed = 0;
int distCount = 0;
bool willSave = false;
bool wasRendering = false;
bool rendering = false;
bool sDown = false;
bool wasSDown = false;
double renderStartTime = 0;
double renderEndTime = 0;
double oldTime = 0;
double newTime = 0;
clock_t t = clock();
while (renderWindow.isOpen())
{
sf::Event windowEvent;
while (renderWindow.pollEvent(windowEvent))
{
gui.handleEvent(windowEvent);
switch (windowEvent.type)
{
case sf::Event::Closed:
renderWindow.close();
break;
}
}
sDown = sf::Keyboard::isKeyPressed(sf::Keyboard::S);
rendering = gui.getRendering();
if (gui.getReload())
{
// Reload
samples = gui.getSamples();
currentSample = 0;
gridWidth = gui.getGridSize().x;
gridHeight = gui.getGridSize().y;
chunkWidth = Graphics::getImageSize().x / gridWidth;
chunkHeight = Graphics::getImageSize().y / gridHeight;
x = ceil((float)gridWidth / 2.0) - 1;
y = ceil((float)gridHeight / 2.0) - 1;
dir = Vector2(-1, 0);
squaresPassed = 0;
lastSquaresPassed = 0;
distCount = 0;
Graphics::Reload();
camera.setAspect(Graphics::getImageSize().x / Graphics::getImageSize().y);
camera.calculateRays();
renderStartTime = (double)(clock() - t) / (double)CLOCKS_PER_SEC;
renderEndTime = 0;
}
if (rendering)
{
if (samples == 0)
{
if (squaresPassed < gridWidth * gridHeight)
{
if (sf::Keyboard::isKeyPressed(sf::Keyboard::Escape))
{
rendering = false;
renderEndTime = (double)(clock() - t) / (double)CLOCKS_PER_SEC;
std::cout << "Render Time: " << renderEndTime - renderStartTime << std::endl;
gui.stopRendering();
}
Vector2 min = Vector2(x * chunkWidth, y * chunkHeight);
Vector2 max = Vector2((x + 1) * chunkWidth, (y + 1) * chunkHeight);
Graphics::Render(newTime, min, max, currentSample);
std::cout << currentSample << std::endl;
x -= gridWidth / 2;
y -= gridHeight / 2;
if (distCount * 2 == squaresPassed - lastSquaresPassed)
{
distCount++;
lastSquaresPassed = squaresPassed;
dir = Vector2(dir.y, -dir.x);
}
else if (distCount == squaresPassed - lastSquaresPassed)
{
dir = Vector2(dir.y, -dir.x);
}
squaresPassed++;
x += dir.x;
y += dir.y;
x += gridWidth / 2;
y += gridHeight / 2;
}
else
{
x = ceil((float)gridWidth / 2.0) - 1;
y = ceil((float)gridHeight / 2.0) - 1;
dir = Vector2(-1, 0);
squaresPassed = 0;
lastSquaresPassed = 0;
distCount = 0;
currentSample++;
}
}
else
{
if (squaresPassed < gridWidth * gridHeight)
{
if (sf::Keyboard::isKeyPressed(sf::Keyboard::Escape))
{
rendering = false;
renderEndTime = (double)(clock() - t) / (double)CLOCKS_PER_SEC;
std::cout << "Render Time: " << renderEndTime - renderStartTime << std::endl;
gui.stopRendering();
}
if (currentSample < samples)
{
Vector2 min = Vector2(x * chunkWidth, y * chunkHeight);
Vector2 max = Vector2((x + 1) * chunkWidth, (y + 1) * chunkHeight);
Graphics::Render(newTime, min, max, currentSample);
currentSample++;
//std::cout << currentSample << "/" << samples << std::endl;
}
else
{
x -= gridWidth / 2;
y -= gridHeight / 2;
if (distCount * 2 == squaresPassed - lastSquaresPassed)
{
distCount++;
lastSquaresPassed = squaresPassed;
dir = Vector2(dir.y, -dir.x);
}
else if (distCount == squaresPassed - lastSquaresPassed)
{
dir = Vector2(dir.y, -dir.x);
}
squaresPassed++;
x += dir.x;
y += dir.y;
x += gridWidth / 2;
y += gridHeight / 2;
currentSample = 0;
}
}
else
{
if (willSave)
{
save();
willSave = false;
}
rendering = false;
renderEndTime = (double)(clock() - t) / (double)CLOCKS_PER_SEC;
std::cout << "Render Time: " << renderEndTime - renderStartTime << std::endl;
gui.stopRendering();
}
}
}
else
{
if (sDown && !wasSDown)
{
save();
}
}
//*/
gui.update(newTime);
renderWindow.clear();
gui.display(renderWindow);
renderWindow.display();
wasSDown = sDown;
oldTime = newTime;
newTime = (double)(clock() - t) / (double)CLOCKS_PER_SEC;
Screen::setDeltaTime(newTime - oldTime);
}
//Graphics::Cleanup();
}
/******************************************************************************
* Renders the text string at the given location given in normalized
* viewport coordinates ([-1,+1] range).
******************************************************************************/
void DefaultTextPrimitive::renderViewport(SceneRenderer* renderer, const Point2& pos, int alignment)
{
QSize imageSize = renderer->outputSize();
Point2 windowPos((pos.x() + 1.0f) * imageSize.width() / 2, (-pos.y() + 1.0f) * imageSize.height() / 2);
renderWindow(renderer, windowPos, alignment);
}
int main(int argc, char** argv) {
sf::RenderWindow renderWindow(sf::VideoMode(300, 300), "Click on Sprite demo");
sf::Event event;
bool player = false;
bool A1IsClicked = false;
bool A2IsClicked = false;
bool A3IsClicked = false;
bool B1IsClicked = false;
bool B2IsClicked = false;
bool B3IsClicked = false;
bool C1IsClicked = false;
bool C2IsClicked = false;
bool C3IsClicked = false;
sf::Texture crossTexture;
crossTexture.loadFromFile("images/cross.png");
sf::Texture circleTexture;
circleTexture.loadFromFile("images/circle.png");
sf::Texture emptyTexture;
emptyTexture.loadFromFile("images/empty.png");
sf::Sprite spriteA1(emptyTexture);
spriteA1.setPosition(0.0f, 0.0f);
sf::Sprite spriteA2(emptyTexture);
spriteA2.setPosition(0.0f, 100.0f);
sf::Sprite spriteA3(emptyTexture);
spriteA3.setPosition(0.0f, 200.0f);
sf::Sprite spriteB1(emptyTexture);
spriteB1.setPosition(100.0f, 0.0f);
sf::Sprite spriteB2(emptyTexture);
spriteB2.setPosition(100.0f, 100.0f);
sf::Sprite spriteB3(emptyTexture);
spriteB3.setPosition(100.0f, 200.0f);
sf::Sprite spriteC1(emptyTexture);
spriteC1.setPosition(200.0f, 0.0f);
sf::Sprite spriteC2(emptyTexture);
spriteC2.setPosition(200.0f, 100.0f);
sf::Sprite spriteC3(emptyTexture);
spriteC3.setPosition(200.0f, 200.0f);
sf::RectangleShape rectangleA1(sf::Vector2f(100, 100));
rectangleA1.setPosition(0.0f, 0.0f);
rectangleA1.setFillColor(sf::Color(204, 255, 255));
sf::RectangleShape rectangleA2(sf::Vector2f(100, 100));
rectangleA2.setPosition(0.0f, 100.0f);
rectangleA2.setFillColor(sf::Color(255, 255, 255));
sf::RectangleShape rectangleA3(sf::Vector2f(100, 100));
rectangleA3.setPosition(0.0f, 200.0f);
rectangleA3.setFillColor(sf::Color(204, 255, 255));
sf::RectangleShape rectangleB1(sf::Vector2f(100, 100));
rectangleB1.setPosition(100.0f, 0.0f);
rectangleB1.setFillColor(sf::Color(255, 255, 255));
sf::RectangleShape rectangleB2(sf::Vector2f(100, 100));
rectangleB2.setPosition(100.0f, 100.0f);
rectangleB2.setFillColor(sf::Color(204, 255, 255));
sf::RectangleShape rectangleB3(sf::Vector2f(100, 100));
rectangleB3.setPosition(100.0f, 200.0f);
rectangleB3.setFillColor(sf::Color(255, 255, 255));
sf::RectangleShape rectangleC1(sf::Vector2f(100, 100));
rectangleC1.setPosition(200.0f, 0.0f);
rectangleC1.setFillColor(sf::Color(204, 255, 255));
sf::RectangleShape rectangleC2(sf::Vector2f(100, 100));
rectangleC2.setPosition(200.0f, 100.0f);
rectangleC2.setFillColor(sf::Color(255, 255, 255));
sf::RectangleShape rectangleC3(sf::Vector2f(100, 100));
rectangleC3.setPosition(200.0f, 200.0f);
rectangleC3.setFillColor(sf::Color(204, 255, 255));
while (renderWindow.isOpen()) {
while (renderWindow.pollEvent(event)) {
if (event.type == sf::Event::EventType::Closed) {
renderWindow.close();
}
if (event.type == sf::Event::EventType::MouseButtonPressed) {
//Check if you pressed a mousebutton
if (event.mouseButton.button == sf::Mouse::Left) {
//Check if that mousebutton is the left mousebutton
click(rectangleA1, spriteA1, A1IsClicked, player, crossTexture, circleTexture, event);
click(rectangleB1, spriteB1, B1IsClicked, player, crossTexture, circleTexture, event);
click(rectangleC1, spriteC1, C1IsClicked, player, crossTexture, circleTexture, event);
click(rectangleA2, spriteA2, A2IsClicked, player, crossTexture, circleTexture, event);
click(rectangleB2, spriteB2, B2IsClicked, player, crossTexture, circleTexture, event);
click(rectangleC2, spriteC2, C2IsClicked, player, crossTexture, circleTexture, event);
click(rectangleA3, spriteA3, A3IsClicked, player, crossTexture, circleTexture, event);
click(rectangleB3, spriteB3, B3IsClicked, player, crossTexture, circleTexture, event);
click(rectangleC3, spriteC3, C3IsClicked, player, crossTexture, circleTexture, event);
}
}
}
renderWindow.clear(sf::Color(100, 100, 100));
renderWindow.draw(rectangleA1);
renderWindow.draw(rectangleA2);
renderWindow.draw(rectangleA3);
renderWindow.draw(rectangleB1);
renderWindow.draw(rectangleB2);
renderWindow.draw(rectangleB3);
renderWindow.draw(rectangleC1);
renderWindow.draw(rectangleC2);
renderWindow.draw(rectangleC3);
renderWindow.draw(spriteA1);
renderWindow.draw(spriteA2);
renderWindow.draw(spriteA3);
renderWindow.draw(spriteB1);
renderWindow.draw(spriteB2);
renderWindow.draw(spriteB3);
renderWindow.draw(spriteC1);
renderWindow.draw(spriteC2);
renderWindow.draw(spriteC3);
renderWindow.display();
}
}
int main()
{
sf::RenderWindow renderWindow(sf::VideoMode(800u, 600u), "TMX Loader");
renderWindow.setVerticalSyncEnabled(true);
//create map loader and load map
tmx::MapLoader ml("maps\\");
ml.Load("desert.tmx");
//update the quad tree once so we can see it whe drawing debug
ml.UpdateQuadTree(sf::FloatRect(0.f, 0.f, 800.f, 600.f));
bool showDebug = false;
sf::Clock frameClock;
//-----------------------------------//
while(renderWindow.isOpen())
{
//poll input
sf::Event event;
while(renderWindow.pollEvent(event))
{
if (event.type == sf::Event::Closed)
renderWindow.close();
if(event.type == sf::Event::KeyReleased)
{
switch(event.key.code)
{
case sf::Keyboard::D:
showDebug = !showDebug;
break;
default: break;
}
}
}
//move objects about
std::vector<tmx::MapLayer>& layers = ml.GetLayers();
for(auto& l : layers)
{
if(l.type == tmx::ObjectGroup)
{
for(auto& o : l.objects)
{
o.Move(0.f, 1.f);
if(o.GetPosition().y > 600.f)
{
o.SetPosition(o.GetPosition().x, 0.f);
}
}
}
}
ml.UpdateQuadTree(sf::FloatRect(0.f, 0.f, 800.f, 600.f));
//draw
frameClock.restart();
renderWindow.clear();
renderWindow.draw(ml);
if(showDebug) ml.Draw(renderWindow, tmx::MapLayer::Debug);//draw with debug information shown
renderWindow.display();
renderWindow.setTitle("Press D to Toggle debug shapes. " + std::to_string(1.f / frameClock.getElapsedTime().asSeconds()));
}
return 0;
}
void SMDLEDShield::scroll(direction d) {
shiftWindow(d);
renderWindow();
}
/**
* @brief frameStarted gets called after every rendered frame by ogre3d.
* Method calls the graphic dispatcher used by OgreTile and the signal signalFrame().
* @param evt Contains timeSinceLastFrame
* @return Returns false if render window got closed.
*/
bool frameStarted(const Ogre::FrameEvent &evt)
{
Ogre::RenderWindow *renderWindow(Ogre::Root::getSingletonPtr()->getAutoCreatedWindow());
if (renderWindow->isClosed())
{
return false;
}
keyboard->capture();
mouse->capture();
{
blub::real speed(5.);
if (m_fast)
{speed = 20.;}
if (m_forward)
{
camera->moveRelative(Ogre::Vector3::NEGATIVE_UNIT_Z*speed*evt.timeSinceLastFrame);
}
if (m_backwards)
{
camera->moveRelative(Ogre::Vector3::UNIT_Z*speed*evt.timeSinceLastFrame);
}
if (m_left)
{
camera->moveRelative(Ogre::Vector3::NEGATIVE_UNIT_X*speed*evt.timeSinceLastFrame);
}
if (m_right)
{
camera->moveRelative(Ogre::Vector3::UNIT_X*speed*evt.timeSinceLastFrame);
}
}
{
const blub::real lookSpeed = (blub::math::piHalf/2.) * evt.timeSinceLastFrame;
if (m_lookLeft)
{
m_lookVert += lookSpeed;
}
if (m_lookRight)
{
m_lookVert -= lookSpeed;
}
if (m_lookUp)
{
m_lookHor += lookSpeed;
}
if (m_lookDown)
{
m_lookHor -= lookSpeed;
}
m_lookHor = blub::math::clamp<blub::real>(m_lookHor, -blub::math::piHalf, blub::math::piHalf);
const blub::quaternion rotVert(0, blub::math::sin(m_lookVert / 2.0), 0, blub::math::cos(m_lookVert / 2.0));
const blub::quaternion rotHor(blub::math::sin(m_lookHor / 2.0), 0, 0, blub::math::cos(m_lookHor / 2.0));
blub::quaternion rot(rotVert*rotHor);
camera->setOrientation(rot);
}
m_sigFrame(evt.timeSinceLastFrame);
graphicDispatcher.start();
return true;
}
//##Documentation
//## @brief Use several views to explore data
//##
//## As in Step2 and Step3, load one or more data sets (many image,
//## surface and other formats), but create 3 views on the data.
//## The QmitkRenderWindow is used for displaying a 3D view as in Step3,
//## but without volume-rendering.
//## Furthermore, we create two 2D views for slicing through the data.
//## We use the class QmitkSliceWidget, which is based on the class
//## QmitkRenderWindow, but additionally provides sliders
//## to slice through the data. We create two instances of
//## QmitkSliceWidget, one for axial and one for sagittal slicing.
//## The two slices are also shown at their correct position in 3D as
//## well as intersection-line, each in the other 2D view.
int main(int argc, char* argv[])
{
QApplication qtapplication( argc, argv );
if(argc<2)
{
fprintf( stderr, "Usage: %s [filename1] [filename2] ...\n\n", itksys::SystemTools::GetFilenameName(argv[0]).c_str() );
return 1;
}
// Register Qmitk-dependent global instances
QmitkRegisterClasses();
//*************************************************************************
// Part I: Basic initialization
//*************************************************************************
// Create a DataStorage
mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New();
//*************************************************************************
// Part II: Create some data by reading files
//*************************************************************************
int i;
for(i=1; i<argc; ++i)
{
// For testing
if(strcmp(argv[i], "-testing")==0) continue;
// Create a DataNodeFactory to read a data format supported
// by the DataNodeFactory (many image formats, surface formats, etc.)
mitk::DataNodeFactory::Pointer nodeReader=mitk::DataNodeFactory::New();
const char * filename = argv[i];
try
{
nodeReader->SetFileName(filename);
nodeReader->Update();
//*********************************************************************
//Part III: Put the data into the datastorage
//*********************************************************************
// Since the DataNodeFactory directly creates a node,
// use the datastorage to add the read node
mitk::DataNode::Pointer node = nodeReader->GetOutput();
ds->Add(node);
}
catch(...)
{
fprintf( stderr, "Could not open file %s \n\n", filename );
exit(2);
}
}
//*************************************************************************
// Part IV: Create windows and pass the tree to it
//*************************************************************************
// Create toplevel widget with horizontal layout
QWidget toplevelWidget;
QHBoxLayout layout;
layout.setSpacing(2);
layout.setMargin(0);
toplevelWidget.setLayout(&layout);
//*************************************************************************
// Part IVa: 3D view
//*************************************************************************
// Create a renderwindow
QmitkRenderWindow renderWindow(&toplevelWidget);
layout.addWidget(&renderWindow);
// Tell the renderwindow which (part of) the datastorage to render
renderWindow.GetRenderer()->SetDataStorage(ds);
// Use it as a 3D view
renderWindow.GetRenderer()->SetMapperID(mitk::BaseRenderer::Standard3D);
// *******************************************************
// ****************** START OF NEW PART ******************
// *******************************************************
//*************************************************************************
// Part IVb: 2D view for slicing axially
//*************************************************************************
// Create QmitkSliceWidget, which is based on the class
// QmitkRenderWindow, but additionally provides sliders
QmitkSliceWidget view2(&toplevelWidget);
layout.addWidget(&view2);
view2.SetLevelWindowEnabled(true);
// Tell the QmitkSliceWidget which (part of) the tree to render.
// By default, it slices the data axially
view2.SetDataStorage(ds);
mitk::DataStorage::SetOfObjects::ConstPointer rs = ds->GetAll();
view2.SetData(rs->Begin(),mitk::SliceNavigationController::Axial);
// We want to see the position of the slice in 2D and the
// slice itself in 3D: add it to the datastorage!
ds->Add(view2.GetRenderer()->GetCurrentWorldGeometry2DNode());
//*************************************************************************
// Part IVc: 2D view for slicing sagitally
//*************************************************************************
// Create QmitkSliceWidget, which is based on the class
// QmitkRenderWindow, but additionally provides sliders
QmitkSliceWidget view3(&toplevelWidget);
layout.addWidget(&view3);
view3.SetDataStorage(ds);
// Tell the QmitkSliceWidget which (part of) the datastorage to render
// and to slice sagitally
view3.SetData(rs->Begin(), mitk::SliceNavigationController::Sagittal);
// We want to see the position of the slice in 2D and the
// slice itself in 3D: add it to the datastorage!
ds->Add(view3.GetRenderer()->GetCurrentWorldGeometry2DNode());
// *******************************************************
// ******************* END OF NEW PART *******************
// *******************************************************
//*************************************************************************
// Part V: Qt-specific initialization
//*************************************************************************
toplevelWidget.show();
// for testing
#include "QtTesting.h"
if(strcmp(argv[argc-1], "-testing")!=0)
return qtapplication.exec();
else
return QtTesting();
}
