bool PreflatePredictorState::createMatchHelper(
MatchHelper& helper,
const unsigned prevLen,
const unsigned startPos,
const bool veryFarMatches,
const bool matchesToStart,
const unsigned maxDepth) {
helper.maxLen = std::min(totalInputSize() - startPos, (unsigned)PreflateConstants::MAX_MATCH);
if (helper.maxLen < std::max<uint32_t>(prevLen + 1, PreflateConstants::MIN_MATCH)) {
return false;
}
helper.startPos = startPos;
unsigned maxDistToStart = startPos - (matchesToStart ? 0 : 1);
if (veryFarMatches) {
helper.curMaxDistHop1Plus
= helper.curMaxDistHop0
= std::min(maxDistToStart, windowSize());
} else {
unsigned maxDist = windowSize() - PreflateConstants::MIN_LOOKAHEAD;
helper.curMaxDistHop0 = std::min(maxDistToStart, maxDist);
helper.curMaxDistHop1Plus = std::min(maxDistToStart, maxDist - 1);
}
if (maxDepth > 0) {
helper.maxChain = maxDepth;
helper.niceLen = helper.maxLen;
} else {
helper.maxChain = maxChainLength();/* max hash chain length */
helper.niceLen = std::min(niceMatchLength(), helper.maxLen);
if (prevLen >= goodMatchLength()) {
helper.maxChain >>= 2;
}
}
/******************************************************************************
* 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);
}
void LayeredLayout::updateLayout(const MFUnrecComponentPtr* Components, const Component* ParentComponent) const
{
Pnt2f windowTopLeft, windowBottomRight;
dynamic_cast<const ComponentContainer*>(ParentComponent)->getInsideInsetsBounds(windowTopLeft, windowBottomRight);
Vec2f windowSize(windowBottomRight-windowTopLeft);
int maxX = 0;
int maxY = 0;
for(UInt32 i = 0; i < Components->size(); i++){
(*Components)[i]->setSize(windowSize);
if((*Components)[i]->getSize().x()>maxX)
maxX = (*Components)[i]->getSize().x();
if((*Components)[i]->getSize().y()>maxY)
maxY = (*Components)[i]->getSize().y();
}
//overlay layout simply draws all the components on top of each other, with the reference point for all the components being the same
/*for(UInt32 i = 0; i <Components->size(); i++){
//(*Components)[i]->setSize((*Components)[i]->getPreferredSize());
(*Components)[i]->setPosition(borderTopLeft +
Vec2f((maxX-(*Components)[i]->getSize().x())/2.0,
(maxY-(*Components)[i]->getSize().y())/2.0));
}*/
for(UInt32 i = 0; i <Components->size(); i++){
//(*Components)[i]->setSize((*Components)[i]->getPreferredSize());
(*Components)[i]->setPosition(windowTopLeft);
}
}
void CScrollHelper::UpdateScrollInfo()
{
if (m_attachWnd == nullptr)
return;
// Get the width/height of the attached wnd that includes the area
// covered by the scrollbars (if any). The reason we need this is
// because when scrollbars are present, both cx/cy and GetClientRect()
// when accessed from OnSize() do not include the scrollbar covered
// areas. In other words, their values are smaller than what you would
// expect.
CRect rect;
GetClientRectSB(m_attachWnd, rect);
CSize windowSize(rect.Width(), rect.Height());
// Update horizontal scrollbar.
CSize deltaPos(0, 0);
UpdateScrollBar(SB_HORZ, windowSize.cx, m_displaySize.cx,
m_pageSize.cx, m_scrollPos.cx, deltaPos.cx);
// Update vertical scrollbar.
UpdateScrollBar(SB_VERT, windowSize.cy, m_displaySize.cy,
m_pageSize.cy, m_scrollPos.cy, deltaPos.cy);
// See if we need to scroll the window back in place.
// This is needed to handle the case where the scrollbar is
// moved all the way to the right for example, and controls
// at the left side disappear from the view. Then the user
// resizes the window wider until scrollbars disappear. Without
// this code below, the controls off the page will be gone forever.
if (deltaPos.cx != 0 || deltaPos.cy != 0) {
m_attachWnd->ScrollWindow(deltaPos.cx, deltaPos.cy);
}
}
void run()
{
TMPROF_BLOCK();
int argc = 1;
char* argv[] = { "" };
QGuiApplication app(argc, argv);
QScreen *screen = QGuiApplication::primaryScreen();
QRect screenGeometry = screen->availableGeometry();
QPoint center = QPoint(screenGeometry.center().x(), screenGeometry.top() + 80);
QSize windowSize(400, 320);
int delta = 40;
QList<QWindow *> windows;
xqtgl::window *windowA = new xqtgl::window(&init,&step,&draw,&fini);
windowA->setGeometry(QRect(center, windowSize).translated(-windowSize.width() - delta / 2, 0));
windowA->setTitle(QStringLiteral("Window"));
windowA->setVisible(true);
windows.prepend(windowA);
app.exec();
qDeleteAll(windows);
}
void IrrWidget::createIrrlichtDevice(){
dimension2d<u32> windowSize(this->geometry().width(), this->geometry().height());
SIrrlichtCreationParameters createParams;
createParams.WindowId = (void*)this->winId();
createParams.WindowSize = windowSize;
createParams.DriverType = EDT_OPENGL;
createParams.Stencilbuffer = true;
createParams.Vsync = false;
m_pDevice = createDeviceEx(createParams);
if(m_pDevice == NULL){
qDebug() << "failed to create irrlicht device";
}
m_pDevice->setResizable(true);
m_pScene = m_pDevice->getSceneManager();
m_pDriver = m_pDevice->getVideoDriver();
scene::IAnimatedMesh* mesh = m_pScene->getMesh("./media/sydney.md2");
if(mesh == NULL){
return;
}
scene::IAnimatedMeshSceneNode* node = m_pScene->addAnimatedMeshSceneNode(mesh);
if(node !=NULL){
node->setMaterialFlag(EMF_LIGHTING, false);
node->setMD2Animation(scene::EMAT_STAND);
node->setMaterialTexture(0, m_pDriver->getTexture("./media/sydney.bmp"));
}
m_pScene->addCameraSceneNode(0, vector3df(0,30,-40), vector3df(0,5,0));
}
/* set up the plotter and the params */
plPlotter* setUp() {
plPlotter* plotter;
plPlotterParams* plotterParams;
/* create a plotter parametric structure */
plotterParams = pl_newplparams();
pl_setplparam(plotterParams, "BITMAPSIZE", "750x750");
pl_setplparam(plotterParams, "USE_DOUBLE_BUFFERING", "no");
pl_setplparam(plotterParams, "BG_COLOR", "black");
/* create the plotter device and open it */
if((plotter = pl_newpl_r("X", stdin, stdout, stderr, plotterParams)) == NULL) {
fprintf(stderr, "Couldn't create Xwindows plotter\n");
exit(1);
} else if(pl_openpl_r(plotter) < 0) {
fprintf(stderr, "Couldn't open Xwindows plotter\n");
exit(1);
}
/* set our coordinate space in the plotter window */
double winSize = windowSize(PLANETS);
pl_fspace_r(plotter, -winSize, -winSize, winSize, winSize);
/* pick a type for the pen and the fill */
pl_pentype_r(plotter, 1);
pl_filltype_r(plotter, 1);
return plotter;
}
void Ide::onInit()
{
auto p = Preferences::get();
if (p->wasWindowMaximized())
{
showMaximized();
}
else
{
resize(p->windowSize());
}
addDockWidget(Qt::LeftDockWidgetArea, new ProjectDock(this));
auto java = new JavaDock(this);
addDockWidget(Qt::BottomDockWidgetArea, java);
auto zipAlign = new ZipAlignDock(this);
addDockWidget(Qt::BottomDockWidgetArea, zipAlign);
tabifyDockWidget(java, zipAlign);
auto jarSigner = new JarSignerDock(this);
addDockWidget(Qt::BottomDockWidgetArea, jarSigner);
tabifyDockWidget(zipAlign, jarSigner);
auto adb = new AdbDock(this);
addDockWidget(Qt::BottomDockWidgetArea, adb);
tabifyDockWidget(jarSigner, adb);
restoreState(p->docksState());
}
Channels Frequency::split(Channel a,std::vector<float> cutoff,float width,bool fade)
{
Channels target(cutoff.size()+1);
unsigned i;
for(i=0;i<cutoff.size();i++)
{
Channels temp=split(a,cutoff[i],width,false);
target[i]=temp[0];
a=temp[1];
/*temp=split(a,cutoff[i]);
for(unsigned j=0;j<a.size();j++)
target[i][j]+=temp[0][j];
a=temp[1];*/
if(fade)
{
unsigned N=windowSize(a,cutoff[i],width);
for(unsigned j=0;j<N*2 && j<target[i].size();j++)
{
double f=(double(j)-N)/N;
if(f<0)
f=0;
target[i][j]*=f;
target[i][target[i].size()-1-j]*=f;
}
}
}
target[i]=a;
//Wave::save("bands.wav",target);
return target;
}
PauseState::PauseState(StateStack& stack, Context context)
: State(stack, context)
, mBackgroundSprite()
, mPausedText()
, mGUIContainer()
{
sf::Font& font = context.fonts->get(Fonts::Main);
sf::Vector2f windowSize(context.window->getSize());
mPausedText.setFont(font);
mPausedText.setString("Game Paused");
mPausedText.setCharacterSize(70);
centerOrigin(mPausedText);
mPausedText.setPosition(0.5f * windowSize.x, 0.4f * windowSize.y);
auto returnButton = std::make_shared<GUI::Button>(*context.fonts, *context.textures);
returnButton->setPosition(0.5f * windowSize.x - 100, 0.4f * windowSize.y + 75);
returnButton->setText("Return");
returnButton->setCallback([this] ()
{
requestStackPop();
});
auto backToMenuButton = std::make_shared<GUI::Button>(*context.fonts, *context.textures);
backToMenuButton->setPosition(0.5f * windowSize.x - 100, 0.4f * windowSize.y + 125);
backToMenuButton->setText("Back to menu");
backToMenuButton->setCallback([this] ()
{
requestStateClear();
requestStackPush(States::Menu);
});
mGUIContainer.pack(returnButton);
mGUIContainer.pack(backToMenuButton);
}
void TextAutosizer::updatePageInfo()
{
if (m_updatePageInfoDeferred || !m_document->page() || !m_document->settings())
return;
PageInfo previousPageInfo(m_pageInfo);
m_pageInfo.m_settingEnabled = m_document->settings()->textAutosizingEnabled();
if (!m_pageInfo.m_settingEnabled || m_document->printing()) {
m_pageInfo.m_pageNeedsAutosizing = false;
} else {
LayoutView* layoutView = m_document->layoutView();
bool horizontalWritingMode = isHorizontalWritingMode(layoutView->style()->writingMode());
// FIXME: With out-of-process iframes, the top frame can be remote and
// doesn't have sizing information. Just return if this is the case.
Frame* frame = m_document->frame()->tree().top();
if (frame->isRemoteFrame())
return;
LocalFrame* mainFrame = toLocalFrame(frame);
IntSize frameSize = m_document->settings()->textAutosizingWindowSizeOverride();
if (frameSize.isEmpty())
frameSize = windowSize();
m_pageInfo.m_frameWidth = horizontalWritingMode ? frameSize.width() : frameSize.height();
IntSize layoutSize = mainFrame->view()->layoutSize();
m_pageInfo.m_layoutWidth = horizontalWritingMode ? layoutSize.width() : layoutSize.height();
// Compute the base font scale multiplier based on device and accessibility settings.
m_pageInfo.m_baseMultiplier = m_document->settings()->accessibilityFontScaleFactor();
// If the page has a meta viewport or @viewport, don't apply the device scale adjustment.
const ViewportDescription& viewportDescription = mainFrame->document()->viewportDescription();
if (!viewportDescription.isSpecifiedByAuthor()) {
float deviceScaleAdjustment = m_document->settings()->deviceScaleAdjustment();
m_pageInfo.m_baseMultiplier *= deviceScaleAdjustment;
}
m_pageInfo.m_pageNeedsAutosizing = !!m_pageInfo.m_frameWidth
&& (m_pageInfo.m_baseMultiplier * (static_cast<float>(m_pageInfo.m_layoutWidth) / m_pageInfo.m_frameWidth) > 1.0f);
}
if (m_pageInfo.m_pageNeedsAutosizing) {
// If page info has changed, multipliers may have changed. Force a layout to recompute them.
if (m_pageInfo.m_frameWidth != previousPageInfo.m_frameWidth
|| m_pageInfo.m_layoutWidth != previousPageInfo.m_layoutWidth
|| m_pageInfo.m_baseMultiplier != previousPageInfo.m_baseMultiplier
|| m_pageInfo.m_settingEnabled != previousPageInfo.m_settingEnabled)
setAllTextNeedsLayout();
} else if (previousPageInfo.m_hasAutosized) {
// If we are no longer autosizing the page, we won't do anything during the next layout.
// Set all the multipliers back to 1 now.
resetMultipliers();
m_pageInfo.m_hasAutosized = false;
}
}
void GLFW_App::init()
{
// Initialize GLFW
if( !glfwInit() )
{
throw Exception("GLFW failed to initialize");
}
int num_color_bits = 8;
//TODO: find out why this is necessary for smooth gradients
glfwWindowHint(GLFW_RED_BITS, num_color_bits);
glfwWindowHint(GLFW_GREEN_BITS, num_color_bits);
glfwWindowHint(GLFW_BLUE_BITS, num_color_bits);
// request an OpenGl 4.1 Context
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_SAMPLES, 4);
// create the window
addWindow(GLFW_Window::create(getWidth(), getHeight(), getName(), fullSceen()));
gl::setWindowDimension(windowSize());
// set graphical log stream
Logger::get()->add_outstream(&m_outstream_gl);
// version
LOG_INFO<<"OpenGL: " << glGetString(GL_VERSION);
LOG_INFO<<"GLSL: " << glGetString(GL_SHADING_LANGUAGE_VERSION);
glfwSwapInterval(1);
glClearColor(0, 0, 0, 1);
// file search paths
kinski::addSearchPath(".", true);
kinski::addSearchPath("./res", true);
kinski::addSearchPath("../Resources", true);
//---------------------------------
#ifdef KINSKI_MAC
kinski::addSearchPath("/Library/Fonts");
kinski::addSearchPath("~/Library/Fonts");
#endif
//---------------------------------
// AntTweakbar
TwInit(TW_OPENGL_CORE, NULL);
TwWindowSize(getWidth(), getHeight());
// call user defined setup callback
setup();
}
void Purity::Engine::initializeWindow()
{
Vector2i windowSize(Configuration::getInstance()->getInteger("window", "window_size_x", 800),
Configuration::getInstance()->getInteger("window", "window_size_y", 400));
#ifdef _WIN32
mWindow = std::unique_ptr<Purity::Window>(new Purity::Win32Window(windowSize.x, windowSize.y, "Purity2D"));
#else
mWindow = std::unique_ptr<Purity::Window>(new Purity::Window(windowSize.x, windowSize.y, "Purity2D"));
#endif
}
void PreflateCompLevelEstimatorState::recommend() {
info.recommendedCompressionLevel = 9;
info.veryFarMatches = !(info.longestDistAtHop0 <= windowSize() - PreflateConstants::MIN_LOOKAHEAD
&& info.longestDistAtHop1Plus < windowSize() - PreflateConstants::MIN_LOOKAHEAD);
info.farLen3Matches = info.longestLen3Dist > 4096;
info.zlibCompatible = info.possibleCompressionLevels > 1
&& !info.matchToStart
&& !info.veryFarMatches
&& (!info.farLen3Matches || (info.possibleCompressionLevels & 0xe) != 0);
if (info.unfoundReferences) {
return;
}
if (info.zlibCompatible && info.possibleCompressionLevels > 1) {
unsigned l = info.possibleCompressionLevels >> 1;
info.recommendedCompressionLevel = 1;
while ((l & 1) == 0) {
info.recommendedCompressionLevel++;
l >>= 1;
}
return;
}
PlayState::PlayState(StateStack& stack, Context context) : State(stack, context), mGUIContainer() {
sf::Texture& texture = context.textures->get(Textures::TitleScreen);
mBackgroundSprite.setTexture(texture);
sf::Vector2f windowSize(context.window->getSize());
auto playButton = std::make_shared<GUI::Button>(context);
playButton->setPosition(0.4f * windowSize.x, 0.3f * windowSize.y);
playButton->setText("New Game");
playButton->setCallback([this]() {
requestStackPop();
requestStackPush(States::Game);
});
auto LevelButton = std::make_shared<GUI::Button>(context);
LevelButton->setPosition(0.4f * windowSize.x, 0.4f * windowSize.y);
LevelButton->setText("Select Level");
LevelButton->setCallback([this]() {
requestStackPush(States::LevelSelect);
});
auto UpgradesButton = std::make_shared<GUI::Button>(context);
UpgradesButton->setPosition(0.4f * windowSize.x, 0.5f * windowSize.y);
UpgradesButton->setText("Ship Modifications");
UpgradesButton->setCallback([this]() {
requestStackPush(States::Upgrade);
});
auto LeaderBButton = std::make_shared<GUI::Button>(context);
LeaderBButton->setPosition(0.4f * windowSize.x, 0.6f * windowSize.y);
LeaderBButton->setText("Leaderboards");
LeaderBButton->setCallback([this]() {
requestStackPush(States::Leader);
});
auto backButton = std::make_shared<GUI::Button>(context);
backButton->setPosition(0.4f * windowSize.x, 0.8f * windowSize.y);
backButton->setText("Back");
backButton->setCallback([this]() {
requestStackPop();
requestStackPush(States::Menu);
});
mGUIContainer.pack(playButton);
mGUIContainer.pack(LevelButton);
mGUIContainer.pack(UpgradesButton);
mGUIContainer.pack(LeaderBButton);
mGUIContainer.pack(backButton);
}
unsigned short PreflateCompLevelEstimatorState::matchDepth(
const unsigned hashHead,
const PreflateToken& targetReference,
const PreflateHashChainExt& hash) {
unsigned curPos = hash.input().pos();
unsigned curMaxDist = std::min(curPos, windowSize());
unsigned startDepth = hash.getNodeDepth(hashHead);
PreflateHashIterator chainIt = hash.iterateFromPos(curPos - targetReference.dist, curPos, curMaxDist);
if (!chainIt.curPos || targetReference.dist > curMaxDist) {
return 0xffffu;
}
unsigned endDepth = chainIt.depth();
return std::min(startDepth - endDepth, 0xffffu);
}
void IrrWidget::createIrrlichtDevice(){
dimension2d<u32> windowSize(this->geometry().width(), this->geometry().height());
SIrrlichtCreationParameters createParams;
createParams.WindowId = (void*)this->winId();
createParams.WindowSize = windowSize;
createParams.DriverType = EDT_OPENGL;
createParams.Stencilbuffer = true;
createParams.Vsync = false;
m_pDevice = createDeviceEx(createParams);
if(m_pDevice == NULL){
qDebug() << "failed to create irrlicht device";
}
m_pDevice->setResizable(true);
m_pScene = m_pDevice->getSceneManager();
m_pDriver = m_pDevice->getVideoDriver();
m_pGuiEnv = m_pDevice->getGUIEnvironment();
m_pBufferList = m_pGuiEnv->addListBox(core::rect<int>(5,5,200, 400), 0, true, true);
//gui::IGUITab* optTab = tabctrl->addTab(L"Demo");
//gui::IGUITab* aboutTab = tabctrl->addTab(L"About");
// add list box
//gui::IGUIListBox* box = m_pGuiEnv->addListBox(core::rect<int>(10,10,220,120), optTab, 1);
m_pBufferList->addItem(L"OpenGL 1.5");
m_pBufferList->addItem(L"Direct3D 8.1");
m_pBufferList->addItem(L"Direct3D 9.0c");
m_pBufferList->addItem(L"Burning's Video 0.47");
m_pBufferList->addItem(L"Irrlicht Software Renderer 1.0");
m_pBufferList->setSelected(true);
scene::IAnimatedMesh* mesh = m_pScene->getMesh("./media/sydney.md2");
if(mesh == NULL){
return;
}
scene::IAnimatedMeshSceneNode* node = m_pScene->addAnimatedMeshSceneNode(mesh);
if(node !=NULL){
node->setMaterialFlag(EMF_LIGHTING, false);
node->setMD2Animation(scene::EMAT_STAND);
node->setMaterialTexture(0, m_pDriver->getTexture("./media/sydney.bmp"));
}
m_pScene->addCameraSceneNode(0, vector3df(0,30,-40), vector3df(0,5,0));
//m_pDevice->setEventReceiver(new IrrEventReciever());
}
void
UiSettings::loadSettings()
{
QSettings s( "CS224", "snow" );
windowPosition() = s.value( "windowPosition", QPoint(0,0) ).toPoint();
windowSize() = s.value( "windowSize", QSize(1000,800) ).toSize();
fillNumParticles() = s.value( "fillNumParticles", 512*128 ).toInt();
fillResolution() = s.value( "fillResolution", 0.05f ).toFloat();
fillDensity() = s.value( "fillDensity", 150.f ).toFloat();
exportDensity() = s.value("exportDensity", false).toBool();
exportVelocity() = s.value("exportVelocity", false).toBool();
exportFPS() = s.value("exportFPS", 24).toInt();
maxTime() = s.value("maxTime", 3).toFloat();
gridPosition() = vec3( s.value("gridPositionX", 0.f).toFloat(),
s.value("gridPositionY", 0.f).toFloat(),
s.value("gridPositionZ", 0.f).toFloat() );
gridDimensions() = glm::ivec3( s.value("gridDimensionX", 128).toInt(),
s.value("gridDimensionY", 128).toInt(),
s.value("gridDimensionZ", 128).toInt() );
gridResolution() = s.value( "gridResolution", 0.05f ).toFloat();
timeStep() = s.value( "timeStep", 1e-5 ).toFloat();
implicit() = s.value( "implicit", true ).toBool();
materialPreset() = s.value( "materialPreset", MAT_DEFAULT).toInt();
showContainers() = s.value( "showContainers", true ).toBool();
showContainersMode() = s.value( "showContainersMode", WIREFRAME ).toInt();
showColliders() = s.value( "showColliders", true ).toBool();
showCollidersMode() = s.value( "showCollidersMode", SOLID ).toInt();
showGrid() = s.value( "showGrid", false ).toBool();
showGridMode() = s.value( "showGridMode", MIN_FACE_CELLS ).toInt();
showGridData() = s.value( "showGridData", false ).toBool();
showGridDataMode() = s.value( "showGridDataMode", NODE_DENSITY ).toInt();
showParticles() = s.value( "showParticles", true ).toBool();
showParticlesMode() = s.value( "showParticlesMode", PARTICLE_MASS ).toInt();
selectionColor() = glm::vec4( 0.302f, 0.773f, 0.839f, 1.f );
}
void LevelSelectState::buildLevelPanel(){
sf::Vector2f windowSize(getContext().window->getSize());
sf::Texture &bgPanelTexture = getContext().textureManager->get(TextureID::LevelSelectionPanel);
mLevelPanel = sf::Sprite(bgPanelTexture);
mLevelPanel.setOrigin(sf::Vector2f(
mLevelPanel.getGlobalBounds().width / 2,
mLevelPanel.getGlobalBounds().height / 2));
mLevelPanel.setPosition(windowSize * 0.5f);
mLevelPanel.setColor(sf::Color(255, 255, 255, 100));
//Set a centered view for our level display panel to handle
//overflowing levels and scrolling down
sf::View levelPanelView;
levelPanelView.setCenter(mLevelPanel.getPosition());
levelPanelView.setSize(sf::Vector2f(
static_cast<float>(bgPanelTexture.getSize().x),
static_cast<float>(bgPanelTexture.getSize().y)));
//Set viewport ratio according to the ratio of panel size
//to window size, with a small amount of padding
levelPanelView.setViewport(sf::FloatRect(
(windowSize.x - bgPanelTexture.getSize().x) / 2.f / windowSize.x,
((windowSize.y - bgPanelTexture.getSize().y) / 2.f / windowSize.y) + 0.01f,
bgPanelTexture.getSize().x / windowSize.x,
bgPanelTexture.getSize().y / windowSize.y - 0.02f));
mLevelContainer->setView(levelPanelView);
SaveManager &saveManager = SaveManager::getInstance();
int collectedGems = getCollectedGems();
//Level selection buttons
std::vector<std::string> lPaths = saveManager.getLevelPaths();
LevelData data = saveManager.getLevelData(lPaths[0]);
addLevel(data, lPaths[0], true);
LevelData previousData;
for (auto it = lPaths.begin() + 1; it != lPaths.end(); ++it){
previousData = data;
data = saveManager.getLevelData(*it);
addLevel(data, (*it), (previousData.completed) && (collectedGems >= data.requiredGems));
}
mGUIContainer.add(mLevelContainer);
}
GameOverState::GameOverState(trmb::StateStack& stack, trmb::State::Context context)
: trmb::State(stack, context)
, mGameOverText()
, mElapsedTime(sf::Time::Zero)
{
sf::Font& font = context.fonts->get(Fonts::ID::Main);
sf::Vector2f windowSize(context.window->getSize());
mGameOverText.setFont(font);
if (context.player->getMissionStatus() == Player::MissionStatus::MissionFailure)
mGameOverText.setString("Mission failed!");
else
mGameOverText.setString("Mission successful!");
mGameOverText.setCharacterSize(70);
trmb::centerOrigin(mGameOverText);
mGameOverText.setPosition(0.5f * windowSize.x, 0.4f * windowSize.y);
}
void
UiSettings::saveSettings()
{
QSettings s( "CS224", "snow" );
s.setValue( "windowPosition", windowPosition() );
s.setValue( "windowSize", windowSize() );
s.setValue( "fillNumParticles", fillNumParticles() );
s.setValue( "fillResolution", fillResolution() );
s.setValue( "fillDensity", fillDensity() );
s.setValue("exportDensity", exportDensity());
s.setValue("exportVelocity",exportVelocity());
s.setValue( "exportFPS", exportFPS());
s.setValue( "maxTime", maxTime());
s.setValue( "gridPositionX", gridPosition().x );
s.setValue( "gridPositionY", gridPosition().y );
s.setValue( "gridPositionZ", gridPosition().z );
s.setValue( "gridDimensionX", gridDimensions().x );
s.setValue( "gridDimensionY", gridDimensions().y );
s.setValue( "gridDimensionZ", gridDimensions().z );
s.setValue( "gridResolution", gridResolution() );
s.setValue( "timeStep", timeStep() );
s.setValue( "implicit", implicit() );
s.setValue("materialPreset", materialPreset());
s.setValue( "showContainers", showContainers() );
s.setValue( "showContainersMode", showContainersMode() );
s.setValue( "showColliders", showColliders() );
s.setValue( "showCollidersMode", showCollidersMode() );
s.setValue( "showGrid", showGrid() );
s.setValue( "showGridMode", showGridMode() );
s.setValue( "showGridData", showGridData() );
s.setValue( "showGridDataMode", showGridDataMode() );
s.setValue( "showParticles", showParticles() );
s.setValue( "showParticlesMode", showParticlesMode() );
}
SettingsState::SettingsState(StateStack& stack, Context context) : State(stack, context), mGUIContainer() {
mBackgroundSprite.setTexture(context.textures->get(Textures::TitleScreen));
sf::Vector2f windowSize(context.window->getSize());
// Labeling according to button
addButtonLabel(Player::MoveLeft, 300.f, "Move Left", context);
addButtonLabel(Player::MoveRight, 350.f, "Move Right", context);
addButtonLabel(Player::MoveUp, 400.f, "Move Up", context);
addButtonLabel(Player::MoveDown, 450.f, "Move Down", context);
addButtonLabel(Player::Fire, 500.f, "Fire", context);
addButtonLabel(Player::Special, 550.f, "Special", context);
updateLabels();
auto backButton = std::make_shared<GUI::Button>(context);
backButton->setPosition(0.4f * windowSize.x, 0.8f * windowSize.y);
backButton->setText("Back");
backButton->setCallback(std::bind(&SettingsState::requestStackPop, this));
mGUIContainer.pack(backButton);
}
/*!
* Returns Device's Display resolution
*/
QSize CxeViewfinderControlSymbian::deviceDisplayResolution() const
{
TSize windowSize(640, 360); // magic: default size if mUiWindow is NULL
if (mUiWindow) {
windowSize = mUiWindow->Size();
}
QSize displaySize = QSize(windowSize.iWidth, windowSize.iHeight);
if (displaySize.height() > displaySize.width()) {
// Window server orientation might differ from the Orbit UI orientation.
// Swap width and height if needed.
displaySize.transpose();
}
CX_DEBUG(("deviceDisplayResolution returning %dx%d", displaySize.width(),
displaySize.height()));
return displaySize;
}
void MediaLayer::InitializeSDL()
{
// Initialize all the SDL Subsytems you need.
// Checkout https://wiki.libsdl.org/SDL_Init#Remarks for more subsystems.
if (SDL_Init(SDL_INIT_VIDEO) != 0) {
std::cerr << "ERROR: SDL Initialization failed." << std::endl;
return;
}
// Create OpenGL Context with the set attributes. This tells SDL to create an OpenGL context
// with the specifies properties.
// More information can be found here: https://wiki.libsdl.org/SDL_GL_SetAttribute
// Note that these properties must be set before the window is created.
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute( SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE );
SDL_GL_SetAttribute( SDL_GL_CONTEXT_MAJOR_VERSION, 4);
SDL_GL_SetAttribute( SDL_GL_CONTEXT_MINOR_VERSION, 1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 16);
glm::vec2 windowSize(app->GetWindowSize());
sdlWindow = SDL_CreateWindow("CS148 Fall 2015-2016", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
windowSize.x, windowSize.y, SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE);
if (!sdlWindow) {
std::cerr << "ERROR: SDL failed to create a window." << std::endl;
return;
}
sdlInitialized = true;
}
GameOverState::GameOverState(StateStack& stack, Context context)
: State(stack, context)
, mGameOverText()
, mPointsDisplayText()
, mElapsedTime(sf::Time::Zero)
{
sf::Font& font = context.fonts->get(Fonts::Main);
sf::Vector2f windowSize(context.window->getSize());
mGameOverText.setFont(font);
if (context.player->getMissionStatus() == Player::MissionFailure)
mGameOverText.setString("You Crash!");
mGameOverText.setCharacterSize(70);
centerOrigin(mGameOverText);
mGameOverText.setPosition(0.5f * windowSize.x, 0.4f * windowSize.y);
mPointsDisplayText.setFont(font);
mPointsDisplayText.setCharacterSize(50);
centerOrigin(mPointsDisplayText);
mPointsDisplayText.setString("Points: " + toString(static_cast<int>(context.player->getPoints())));
mPointsDisplayText.setPosition(0.38f * windowSize.x, 0.5f * windowSize.y);
}
GameOverState::GameOverState(StateStack& stack, Context context)
: State(stack, context)
, mGameOverText()
, mElapsedTime(sf::Time::Zero)
, mStatus(context.player->getMissionStatus())
{
sf::Font& font = context.fonts->get(Fonts::Main);
sf::Vector2f windowSize(context.window->getSize());
mGameOverText.setFont(font);
if (mStatus == Player::MissionFailure)
mGameOverText.setString("Mission failed!");
else if (mStatus == Player::MissionSuccess)
{
mGameOverText.setString("Mission successful!");
context.player->setMissionStatus(Player::MissionRunning);
}
else
mGameOverText.setString("You win!");
mGameOverText.setCharacterSize(70);
centerOrigin(mGameOverText);
mGameOverText.setPosition(0.5f * windowSize.x, 0.4f * windowSize.y);
}
void RendererImpl2dGdi::makeCurrentContext( bool force )
{
if( mPaintEvents )
mPaintDc = ::BeginPaint( mWnd, &mPaintStruct );
else
mPaintDc = ::GetDC( mWnd );
if( mDoubleBuffer ) {
::RECT clientRect;
::GetClientRect( mWnd, &clientRect );
ivec2 windowSize( clientRect.right - clientRect.left, clientRect.bottom - clientRect.top );
mDoubleBufferDc = ::CreateCompatibleDC( mPaintDc );
if(( mDoubleBufferBitmap == 0 ) || ( mDoubleBufferBitmapSize != windowSize )) {
if( mDoubleBufferBitmap ) {
::DeleteObject( mDoubleBufferBitmap );
}
mDoubleBufferBitmap = ::CreateCompatibleBitmap( mPaintDc, windowSize.x, windowSize.y );
mDoubleBufferBitmapSize = windowSize;
}
mDoubleBufferOldBitmap = (::HBITMAP)::SelectObject( mDoubleBufferDc, mDoubleBufferBitmap );
}
}
OutputWindow::OutputWindow()
: QGraphicsView(new QGraphicsScene())
, m_url("")
, m_pollDviz(false)
, m_updateTime(1000)
, m_isDataPoll(false)
, m_slideId(-1)
, m_slideName("")
//, m_startStopButton(0)
, m_countValue(0)
, m_drw(0)
, m_blinkCount(0)
{
// Setup graphics view
setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing | QPainter::SmoothPixmapTransform );
setCacheMode(QGraphicsView::CacheBackground);
setViewportUpdateMode(QGraphicsView::BoundingRectViewportUpdate);
setOptimizationFlags(QGraphicsView::DontSavePainterState);
setViewportUpdateMode(QGraphicsView::SmartViewportUpdate);
setTransformationAnchor(AnchorUnderMouse);
setResizeAnchor(AnchorViewCenter);
setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
// Add pixmap item for background
QPixmap bluePixmap(32,23);
bluePixmap.fill(Qt::blue);
m_pixmap = scene()->addPixmap(bluePixmap);
// Background behind text
m_counterBgRect = scene()->addRect(0,0,100,60,QPen(), Qt::black);
m_counterBgRect->setZValue(99);
// Add text (for use with clock)
QFont font("Monospace", 50, 600);
m_counterText = new QGraphicsSimpleTextItem("0");
m_counterText->setFont(font);
m_counterText->setPen(QPen(Qt::black));
m_counterText->setBrush(Qt::white);
m_counterText->setPos(0, -13);
m_counterText->setZValue(100);
scene()->addItem(m_counterText);
// Background behind text
m_overlayBgRect = scene()->addRect(0,300,100,60,QPen(), Qt::black);
m_overlayBgRect->setZValue(99);
// Add text (for use with clock)
//QFont font("Monospace", 50, 600);
m_overlayText = new QGraphicsSimpleTextItem("Hello, World!");
m_overlayText->setFont(font);
m_overlayText->setPen(QPen(Qt::black));
m_overlayText->setBrush(Qt::white);
m_overlayText->setPos(0, 300-13);
m_overlayText->setZValue(100);
scene()->addItem(m_overlayText);
m_blinkOverlay = false;
connect(&m_blinkOverlayTimer, SIGNAL(timeout()), this, SLOT(blinkOverlaySlot()));
GET_CONFIG();
QPoint windowPos(1024,0);
QPoint windowSize(1024,768);
//QPoint windowPos(10,10);
//QPoint windowSize = QPoint(640,480);
QString windowGeomString = config.value("geom","1024,0,1024,768").toString();
if(!windowGeomString.isEmpty())
{
QStringList list = windowGeomString.split(",");
windowPos = QPoint(list[0].toInt(), list[1].toInt());
windowSize = QPoint(list[2].toInt(), list[3].toInt());
}
setWindowGeom(QRect(windowPos.x(),windowPos.y(),windowSize.x(),windowSize.y()));
bool frameless = config.value("frameless","true").toString() == "true";
if(frameless)
setWindowFlags(Qt::FramelessWindowHint);// | Qt::ToolTip);
connect(&m_pollDvizTimer, SIGNAL(timeout()), this, SLOT(initDvizPoll()));
//connect(&m_pollImageTimer, SIGNAL(timeout()), this, SLOT(initImagePoll()));
setUpdateTime(m_updateTime);
//setUrl("http://10.10.9.90:8081/image");
//setUrl("");
//setPollDviz(true);
setInputSource(config.value("source","dviz://192.168.0.10:8081/image").toString());
// m_startStopButton = new QPushButton("Start Counter");
// connect(m_startStopButton, SIGNAL(clicked()), this, SLOT(toggleCounter()));
connect(&m_counterTimer, SIGNAL(timeout()), this, SLOT(counterTick()));
m_counterTimer.setInterval(1000);
//
// m_startStopButton->show();
//toggleCounter();
setCounterActive(false);
setBlinkOverlay(config.value("blink-overlay","false").toString() == "true", config.value("blink-speed", 333).toInt());
//setOverlayVisible(config.value("overlay-visible", "true").toString() == "true");
setCounterVisible(config.value("counter-visible", "true").toString() == "true");
setCounterAlignment((Qt::Alignment)config.value("counter-alignment", (int)(Qt::AlignLeft | Qt::AlignTop)).toInt());
setOverlayAlignment((Qt::Alignment)config.value("overlay-alignment", (int)(Qt::AlignCenter | Qt::AlignBottom)).toInt());
setOverlayText(config.value("overlay-text").toString());
}
void XInputMTInputDevice::start()
{
Status status;
SDLDisplayEngine * pEngine = Player::get()->getDisplayEngine();
glm::vec2 size(pEngine->getSize());
glm::vec2 windowSize(pEngine->getWindowSize());
m_DisplayScale.x = size.x/windowSize.x;
m_DisplayScale.y = size.y/windowSize.y;
SDL_SysWMinfo info;
SDL_VERSION(&info.version);
int rc = SDL_GetWMInfo(&info);
AVG_ASSERT(rc != -1);
s_pDisplay = info.info.x11.display;
m_SDLLockFunc = info.info.x11.lock_func;
m_SDLUnlockFunc = info.info.x11.unlock_func;
m_SDLLockFunc();
// XInput Extension available?
int event, error;
bool bOk = XQueryExtension(s_pDisplay, "XInputExtension", &m_XIOpcode,
&event, &error);
if (!bOk) {
throw Exception(AVG_ERR_MT_INIT,
"XInput multitouch event source: X Input extension not available.");
}
// Which version of XI2?
int major;
int minor;
status = XIQueryVersion(s_pDisplay, &major, &minor);
if (status == BadRequest) {
throw Exception(AVG_ERR_MT_INIT,
"XInput 2.1 multitouch event source: Server does not support XI2");
}
if (major < 2 || minor < 1) {
throw Exception(AVG_ERR_MT_INIT,
"XInput multitouch event source: Supported version is "
+toString(major)+"."+toString(minor)+". At least 2.1 is needed.");
}
findMTDevice();
// SDL grabs the pointer in full screen mode. This breaks touchscreen usage.
// Can't use SDL_WM_GrabInput(SDL_GRAB_OFF) because it doesn't work in full
// screen mode. Get the display connection and do it manually.
XUngrabPointer(info.info.x11.display, CurrentTime);
XIEventMask mask;
mask.deviceid = m_DeviceID;
mask.mask_len = XIMaskLen(XI_LASTEVENT);
mask.mask = (unsigned char *)calloc(mask.mask_len, sizeof(char));
memset(mask.mask, 0, mask.mask_len);
XISetMask(mask.mask, XI_TouchBegin);
XISetMask(mask.mask, XI_TouchUpdate);
XISetMask(mask.mask, XI_TouchEnd);
status = XISelectEvents(s_pDisplay, info.info.x11.window, &mask, 1);
AVG_ASSERT(status == Success);
m_SDLUnlockFunc();
SDL_SetEventFilter(XInputMTInputDevice::filterEvent);
XIDetachSlaveInfo detInfo;
detInfo.type = XIDetachSlave;
detInfo.deviceid = m_DeviceID;
XIChangeHierarchy(s_pDisplay, (XIAnyHierarchyChangeInfo *)&detInfo, 1);
pEngine->setXIMTInputDevice(this);
MultitouchInputDevice::start();
AVG_TRACE(Logger::category::CONFIG, Logger::severity::INFO,
"XInput Multitouch event source created.");
}
int main(int argc, char *argv[])
{
QGuiApplication app(argc, argv);
const bool multipleWindows = false;
QScreen *screen = QGuiApplication::primaryScreen();
QRect screenGeometry = screen->availableGeometry();
QSurfaceFormat format;
format.setDepthBufferSize(16);
format.setSamples(4);
QPoint center = QPoint(screenGeometry.center().x(), screenGeometry.top() + 80);
QSize windowSize(400, 320);
int delta = 40;
QList<QWindow *> windows;
QSharedPointer<Renderer> rendererA(new Renderer(format));
HelloWindow *windowA = new HelloWindow(rendererA);
windowA->setGeometry(QRect(center, windowSize).translated(-windowSize.width() - delta / 2, 0));
windowA->setTitle(QStringLiteral("Thread A - Context A"));
windowA->setVisible(true);
windows.prepend(windowA);
QList<QThread *> renderThreads;
if (multipleWindows) {
QSharedPointer<Renderer> rendererB(new Renderer(format, rendererA.data()));
QThread *renderThread = new QThread;
rendererB->moveToThread(renderThread);
renderThreads << renderThread;
HelloWindow *windowB = new HelloWindow(rendererA);
windowB->setGeometry(QRect(center, windowSize).translated(delta / 2, 0));
windowB->setTitle(QStringLiteral("Thread A - Context A"));
windowB->setVisible(true);
windows.prepend(windowB);
HelloWindow *windowC = new HelloWindow(rendererB);
windowC->setGeometry(QRect(center, windowSize).translated(-windowSize.width() / 2, windowSize.height() + delta));
windowC->setTitle(QStringLiteral("Thread B - Context B"));
windowC->setVisible(true);
windows.prepend(windowC);
for (int i = 1; i < QGuiApplication::screens().size(); ++i) {
QScreen *screen = QGuiApplication::screens().at(i);
QSharedPointer<Renderer> renderer(new Renderer(format, rendererA.data(), screen));
renderThread = new QThread;
renderer->moveToThread(renderThread);
renderThreads.prepend(renderThread);
QRect screenGeometry = screen->availableGeometry();
QPoint center = screenGeometry.center();
QSize windowSize = screenGeometry.size() * 0.8;
HelloWindow *window = new HelloWindow(renderer);
window->setScreen(screen);
window->setGeometry(QRect(center, windowSize).translated(-windowSize.width() / 2, -windowSize.height() / 2));
QChar id = QChar('B' + i);
window->setTitle(QStringLiteral("Thread ") + id + QStringLiteral(" - Context ") + id);
window->setVisible(true);
windows.prepend(window);
}
}
for (int i = 0; i < renderThreads.size(); ++i) {
QObject::connect(qGuiApp, SIGNAL(lastWindowClosed()), renderThreads.at(i), SLOT(quit()));
renderThreads.at(i)->start();
}
const int exitValue = app.exec();
for (int i = 0; i < renderThreads.size(); ++i)
renderThreads.at(i)->wait();
qDeleteAll(windows);
qDeleteAll(renderThreads);
return exitValue;
}
