void HexagonGame::drawText()
{
ostringstream s;
s << "time: " << toStr(currentTime).substr(0, 5) << endl;
if(hasDied) s << "press r to restart" << endl;
vector<Vector2f> offsets{{-1,-1},{-1,1},{1,-1},{1,1}};
Text timeText(s.str(), getFont("imagine"), 25 / getZoomFactor());
timeText.setPosition(15, 3);
timeText.setColor(getColorMain());
for(auto offset : offsets)
{
Text timeOffsetText(s.str(), getFont("imagine"), timeText.getCharacterSize());
timeOffsetText.setPosition(timeText.getPosition() + offset);
timeOffsetText.setColor(getColorB());
drawOnWindow(timeOffsetText);
}
drawOnWindow(timeText);
for (Text* textPtr : messageTextPtrs)
{
for(auto offset : offsets)
{
Text textPtrOffset{textPtr->getString(), getFont("imagine"), textPtr->getCharacterSize()};
textPtrOffset.setPosition(textPtr->getPosition() + offset);
textPtrOffset.setOrigin(textPtrOffset.getGlobalBounds().width / 2, 0);
textPtrOffset.setColor(getColorB());
drawOnWindow(textPtrOffset);
}
textPtr->setColor(getColorMain());
drawOnWindow(*textPtr);
}
}
void MagnifyingGlassTool::updateCamera()
{
if (!m_magnifiedCamera)
{
m_magnifiedCamera = vtkSmartPointer<vtkCamera>::New();
m_magnifiedRenderer->SetActiveCamera(m_magnifiedCamera);
}
vtkCamera *viewerCamera = m_2DViewer->getRenderer()->GetActiveCamera();
m_magnifiedCamera->DeepCopy(viewerCamera);
// Ajustem la càmera a la mateixa proporció que el renderer principal
// Cal prendre la proporció del viewport magnificat respecte el viewer en sí
double viewportsProportion;
double viewportPoints[4];
m_magnifiedRenderer->GetViewport(viewportPoints);
viewportsProportion = fabs(viewportPoints[3] - viewportPoints[1]);
// Fixem el mateix zoom que en el renderer principal
if (viewerCamera->GetParallelProjection())
{
m_magnifiedCamera->SetParallelScale(viewerCamera->GetParallelScale() * viewportsProportion);
}
else
{
m_magnifiedCamera->SetViewAngle(viewerCamera->GetViewAngle() * viewportsProportion);
}
// Apliquem el factor de magnificació
m_magnifiedCamera->Zoom(getZoomFactor());
}
void HexagonGame::recreateTextures()
{
gameTexture.create(getSizeX(), getSizeY(), 32);
gameTexture.setView(View{Vector2f{0,0}, Vector2f{getSizeX() * getZoomFactor(), getSizeY() * getZoomFactor()}});
gameTexture.setSmooth(true);
gameSprite.setTexture(gameTexture.getTexture(), false);
gameSprite.setOrigin(getSizeX()/ 2, getSizeY()/ 2);
gameSprite.setPosition(window.getWidth() / 2, window.getHeight() / 2);
}
void HexagonGame::addMessage(const string& mMessage, float mDuration)
{
Text* text{new Text(mMessage, getFont("imagine.ttf"), 40 / getZoomFactor())};
text->setPosition(Vector2f(getWidth() / 2, getHeight() / 6));
text->setOrigin(text->getGlobalBounds().width / 2, 0);
messageTimeline.append<Do>([&, text, mMessage]{ playSound("beep.ogg"); messageTextPtr = text; });
messageTimeline.append<Wait>(mDuration);
messageTimeline.append<Do>([=]{ messageTextPtr = nullptr; delete text; });
}
void HexagonGame::addMessage(string mMessage, float mDuration)
{
Text* text = new Text(mMessage, getFont("imagine"), 40 / getZoomFactor());
text->setPosition(Vector2f(getWidth() / 2, getHeight() / 6));
text->setOrigin(text->getGlobalBounds().width / 2, 0);
messagesTimeline.add(new Do{ [&, text, mMessage]{ messageTextPtrs.push_back(text); }});
messagesTimeline.add(new Wait{mDuration});
messagesTimeline.add(new Do{ [=]{ messageTextPtrs.clear(); delete text; }});
}
void ChannelRenderArea::wheelEvent(QWheelEvent *event)
{
uint64_t sampleStartNew, sampleEndNew;
float zoomFactorNew;
/* FIXME: Make this constant user-configurable. */
zoomFactorNew = getZoomFactor()
+ 0.01 * (event->delta() / WHEEL_DELTA);
if (zoomFactorNew < 0)
zoomFactorNew = 0;
if (zoomFactorNew > 2)
zoomFactorNew = 2; /* FIXME: Don't hardcode. */
setZoomFactor(zoomFactorNew);
sampleStartNew = 0; /* FIXME */
sampleEndNew = getNumSamples() * zoomFactorNew;
if (sampleEndNew > getNumSamples())
sampleEndNew = getNumSamples();
setSampleStart(sampleStartNew);
setSampleEnd(sampleEndNew);
#if 0
uint64_t sampleStartNew, sampleEndNew;
sampleStartNew = getSampleStart() + event->delta() / WHEEL_DELTA;
sampleEndNew = getSampleEnd() + event->delta() / WHEEL_DELTA;
/* TODO: More checks. */
#if 1
if (sampleStartNew < 0 || sampleEndNew < 0)
return;
if (sampleStartNew > 512 * 1000 || sampleEndNew > 512 * 1000 /* FIXME */)
return;
#endif
setSampleStart(sampleStartNew);
setSampleEnd(sampleEndNew); /* FIXME: Use len? */
#endif
repaint();
}
void MagnifyingGlassTool::setFocalPoint(const double cursorPosition[3])
{
// Passem el punt a coordenades de display
double pointInDisplay[3];
m_2DViewer->computeWorldToDisplay(cursorPosition[0], cursorPosition[1], cursorPosition[2], pointInDisplay);
double viewportBounds[4];
m_magnifiedRenderer->GetViewport(viewportBounds);
QSize renderWindowSize = m_2DViewer->getRenderWindowSize();
double magnifyingWindowHalfWidht = (viewportBounds[2] - viewportBounds[0]) * renderWindowSize.width() / 2.0;
double magnifyingWindowHalfHeight = (viewportBounds[3] - viewportBounds[1]) * renderWindowSize.height() / 2.0;
// Calculem la diferencia entre el centre del viewport i on esta el cursor per calcular el punt central real
double offsetXMin = qMax(0.0, magnifyingWindowHalfWidht - pointInDisplay[0]);
double offsetXMax = qMax(0.0, (pointInDisplay[0] + magnifyingWindowHalfWidht) - renderWindowSize.width());
double offsetYMin = qMax(0.0, magnifyingWindowHalfHeight - pointInDisplay[1]);
double offsetYMax = qMax(0.0, (pointInDisplay[1] + magnifyingWindowHalfHeight) - renderWindowSize.height());
// Apliquem el factor de zoom perque volem la distancia en el render magnificat
double zoomFactor = getZoomFactor();
double offsetX = (offsetXMax - offsetXMin) / zoomFactor;
double offsetY = (offsetYMax - offsetYMin) / zoomFactor;
double focalPoint[3];
m_2DViewer->computeDisplayToWorld(pointInDisplay[0] - offsetX, pointInDisplay[1] - offsetY, pointInDisplay[2], focalPoint);
m_magnifiedCamera->SetFocalPoint(focalPoint);
int xIndex, yIndex, zIndex;
m_2DViewer->getView().getXYZIndexes(xIndex, yIndex, zIndex);
double position[3];
m_magnifiedCamera->GetPosition(position);
position[xIndex] = focalPoint[xIndex];
position[yIndex] = focalPoint[yIndex];
m_magnifiedCamera->SetPosition(position);
}
void MapperGLCanvas::wheelEvent(QWheelEvent *event)
{
int deltaLevel = event->delta() / 120;
qreal zoomFactor = qPow(MM::ZOOM_FACTOR, _zoomLevel);
if (deltaLevel > 0)
{
// First check if we're already at max.
while (deltaLevel && zoomFactor < MM::ZOOM_MAX) {
_zoomLevel++;
deltaLevel--;
zoomFactor = qPow(MM::ZOOM_FACTOR, _zoomLevel);
}
zoomFactor = qMin(zoomFactor, MM::ZOOM_MAX);
}
else
{
// First check if we're already at min.
while (deltaLevel && zoomFactor > MM::ZOOM_MIN) {
_zoomLevel--;
deltaLevel++;
zoomFactor = qPow(MM::ZOOM_FACTOR, _zoomLevel);
}
zoomFactor = qMax(zoomFactor, MM::ZOOM_MIN);
}
// Re-bound zoom (for consistency).
zoomFactor = getZoomFactor();
// Apply zoom to view.
QGraphicsView* view = scene()->views().first();
view->resetMatrix();
view->scale(zoomFactor, zoomFactor);
view->update();
// Accept wheel scrolling event.
event->accept();
}
void HexagonGame::drawText()
{
ostringstream s;
s << "time: " << toStr(status.currentTime).substr(0, 5) << endl;
if(getOfficial()) s << "official mode" << endl;
if(getDebug()) s << "debug mode" << endl;
if(status.scoreInvalid) s << "score invalidated (performance issues)" << endl;
if(status.hasDied) s << "press r to restart" << endl;
Vector2f pos{15, 3};
vector<Vector2f> offsets{{-1, -1}, {-1, 1}, {1, -1}, {1, 1}};
Color offsetColor{getColor(1)};
if(getBlackAndWhite()) offsetColor = Color::Black;
text.setString(s.str());
text.setCharacterSize(25 / getZoomFactor());
text.setOrigin(0, 0);
text.setColor(offsetColor);
for(const auto& o : offsets) { text.setPosition(pos + o); render(text); }
text.setColor(getColorMain());
text.setPosition(pos);
render(text);
if(messageTextPtr == nullptr) return;
text.setString(messageTextPtr->getString());
text.setCharacterSize(messageTextPtr->getCharacterSize());
text.setOrigin(text.getGlobalBounds().width / 2, 0);
text.setColor(offsetColor);
for(const auto& o : offsets) { text.setPosition(messageTextPtr->getPosition() + o); render(text); }
messageTextPtr->setColor(getColorMain());
render(*messageTextPtr);
}
void HexagonGame::newGame(const string& mId, bool mFirstPlay, float mDifficultyMult)
{
firstPlay = mFirstPlay;
setLevelData(getLevelData(mId), mFirstPlay);
difficultyMult = mDifficultyMult;
// Audio cleanup
stopAllSounds();
playSound("go.ogg");
stopLevelMusic();
playLevelMusic();
// Events cleanup
clearMessage();
for(auto eventPtr : eventPtrs) delete eventPtr;
eventPtrs.clear();
while(!eventPtrQueue.empty()) { delete eventPtrQueue.front(); eventPtrQueue.pop(); }
eventPtrQueue = queue<EventData*>{};
// Game status cleanup
status = HexagonGameStatus{};
restartId = mId;
restartFirstTime = false;
setSides(levelData.getSides());
// Manager cleanup
manager.clear();
factory.createPlayer();
// Timeline cleanup
timeline.clear(); timeline.reset();
messageTimeline.clear(); messageTimeline.reset();
effectTimelineManager.clear();
// FPSWatcher reset
fpsWatcher.reset();
if(getOfficial()) fpsWatcher.enable();
// LUA context cleanup
if(!mFirstPlay) runLuaFunction<void>("onUnload");
lua = Lua::LuaContext{};
initLua();
runLuaFile(levelData.getValueString("lua_file"));
runLuaFunction<void>("onLoad");
// Random rotation direction
if(getRnd(0, 100) > 50) setRotationSpeed(getRotationSpeed() * -1);
// Reset zoom
overlayCamera.setView({{getWidth() / 2.f, getHeight() / 2.f}, sf::Vector2f(getWidth(), getHeight())});
backgroundCamera.setView({{0, 0}, {getWidth() * getZoomFactor(), getHeight() * getZoomFactor()}});
backgroundCamera.setRotation(0);
// 3D Cameras cleanup
depthCameras.clear();
unsigned int depth{styleData.get3DDepth()};
if(depth > get3DMaxDepth()) depth = get3DMaxDepth();
for(unsigned int i{0}; i < depth; ++i) depthCameras.push_back({window, {}});
}
