void CustomWindow::vsyncChangedHandler( bool vsync ) {
QSurfaceFormat fmt = format();
// Grab OpenGL context surface format if it's ready to go, it's more filled out than the window one
// It can be unitialized on startup before so check that it exists before using it
if( openglContext() ) {
fmt = openglContext()->format();
}
#if defined( Q_OS_WIN )
fmt.setSwapBehavior( vsync ? QSurfaceFormat::SingleBuffer : QSurfaceFormat::DoubleBuffer );
#elif defined( Q_OS_MACX )
// Leave it alone, OS X happily accepts single buffering
#endif
fmt.setSwapInterval( vsync ? 1 : 0 );
// Window must be reset to apply the changes
resetPlatformWindow( fmt );
emit doubleBufferedChanged( fmt.swapBehavior() == QSurfaceFormat::DoubleBuffer );
}
void App::slotSceneGraphInitialized()
{
if (openglContext() == NULL)
return;
qDebug() << "OpenGL version: " << openglContext()->format().majorVersion() << openglContext()->format().minorVersion();
}
bool App::is3DSupported() const
{
if (openglContext() == NULL)
return false;
int glVersion = (openglContext()->format().majorVersion() * 10) + openglContext()->format().minorVersion();
return glVersion < 33 ? false : true;
}
virtual void initEvent()
{
if (!GLEW_ARB_multitexture)
{
vl::Log::error("GL_ARB_multitexture required.\n");
openglContext()->quitApplication();
return;
}
vl::Log::print(appletInfo());
ghostCameraManipulator()->setMovementSpeed(5);
// allocate terrain scene manager
vl::ref<vl::Terrain> terrain = new vl::Terrain;
// use GLSL?
terrain->setUseGLSL( GLEW_ARB_shading_language_100 ? true : false );
// dimensions of the terrain
terrain->setWidth(100);
terrain->setDepth(100);
terrain->setHeight(5.0f);
// heightmap texture size used by the GLSL program
if (GLEW_ATI_texture_float || GLEW_ARB_texture_float)
terrain->setHeightmapTextureFormat(vl::TF_LUMINANCE16F);
else
terrain->setHeightmapTextureFormat(vl::TF_LUMINANCE);
// origin of the terrain
terrain->setOrigin(vl::vec3(0,0,0));
// define textures
terrain->setHeightmapTexture("/images/ps_height_4k.jpg");
terrain->setTerrainTexture("/images/ps_texture_4k.jpg");
terrain->setDetailTexture("/images/noise.png");
terrain->setDetailRepetitionCount(8);
// define shaders to be used to render the terrain
terrain->setFragmentShader("/glsl/terrain.fs");
terrain->setVertexShader("/glsl/terrain.vs");
// initialize the terrain
terrain->init();
// add the terrain scene manager to the rendering
rendering()->as<vl::Rendering>()->sceneManagers()->push_back( terrain.get() );
// adds fog if we are not using GLSL but the fixed function pipeline
if (!terrain->useGLSL())
{
// set sky to white
rendering()->as<vl::Rendering>()->camera()->viewport()->setClearColor(vl::white);
// set fog render state
vl::ref<vl::Fog> fog = new vl::Fog;
fog->setColor(vl::white);
fog->setDensity(0.045f);
fog->setMode(vl::FM_EXP);
// install and enable fog
terrain->shaderNode()->setRenderState(fog.get());
terrain->shaderNode()->setEnable(vl::EN_FOG,true);
terrain->shaderNode()->updateHierarchy();
}
// for debugging purposes
#if 0
showBoundingVolumes(1,0);
#endif
}
void keyPressEvent(unsigned short ch, vl::EKey key)
{
// ignore left/right ctrl key events, we use Key_Ctrl only
if (key == vl::Key_LeftCtrl || key == vl::Key_RightCtrl )
return;
if (key == vl::Key_H)
{
mHelpOn = !mHelpOn;
updateText();
}
else
// resets the grid
if (key == vl::Key_Return)
{
if (mMode == NoMode)
{
mMode = AnimateMode;
mStartTime = vl::Time::currentTime();
mGrid->setVertexArray(mPointsAnim.get());
openglContext()->setContinuousUpdate(true);
mCursorActor->setEnableMask(0);
}
else
if (mMode == AnimateMode)
{
mMode = NoMode;
mGrid->setVertexArray(mPoints.get());
openglContext()->setContinuousUpdate(false);
openglContext()->update();
}
}
if (mMode == AnimateMode)
return;
if (key == vl::Key_Space)
{
reset();
}
else
if (openglContext()->isKeyPressed(vl::Key_Ctrl) && openglContext()->isKeyPressed(vl::Key_Z))
{
if (!mPointsUndo.empty())
{
memcpy(mPoints->ptr(), mPointsUndo.back()->ptr(), mPoints->bytesUsed());
mPointsUndo.pop_back();
openglContext()->update();
}
}
else
{
if (key == vl::Key_F5)
// disable the mouse cursor while taking the screenshot
mCursorActor->setEnableMask(0);
BaseDemo::keyPressEvent(ch,key);
openglContext()->update();
}
}
void mouseWheelEvent(int w)
{
openglContext()->update();
mBrushSize += 4*w;
mBrushSize = vl::clamp(mBrushSize, 10, 1000);
vl::mat4 m;
m.scale((vl::Real)mBrushSize/2.0f, (vl::Real)mBrushSize/2.0f, (vl::Real)mBrushSize/2.0f);
m.translate(mCursorTransform->localMatrix().getT());
mCursorTransform->setLocalMatrix(m);
}
void mouseMoveEvent(int x, int y)
{
if (mMode == AnimateMode)
return;
openglContext()->update();
mCursorActor->setEnableMask(0xFFFFFFFF);
vl::mat4 m;
m.scale((vl::Real)mBrushSize/2.0f, (vl::Real)mBrushSize/2.0f, (vl::Real)mBrushSize/2.0f);
if (mMode == ScaleMode)
m.translate(mCursorTransform->localMatrix().getT());
else
m.translate((vl::Real)x, (vl::Real)rendering()->as<vl::Rendering>()->camera()->viewport()->height()-y, 0);
mCursorTransform->setLocalMatrix(m);
if (mMode == TranslateMode)
{
float tx = +(float)(x-mMouseStart.x())/rendering()->as<vl::Rendering>()->camera()->viewport()->width();
float ty = -(float)(y-mMouseStart.y())/rendering()->as<vl::Rendering>()->camera()->viewport()->height();
for(unsigned i=0; i<mSelection.size(); ++i)
{
int ipt = mSelection[i].mIndex;
float w = mSelection[i].mWeight;
w = w*w;
vl::vec3 new_pos = mSelection[i].mStartPos + vl::vec3(tx,ty,0)*w;
new_pos = vl::clamp(new_pos,vl::vec3(-0.5,-0.5,-0.5),vl::vec3(0.5,0.5,0.5));
mPoints->at(ipt) = (vl::fvec3)new_pos;
}
}
else
if (mMode == ScaleMode)
{
float scaling = 0.1f * (float)(y-mMouseStart.y())/rendering()->as<vl::Rendering>()->camera()->viewport()->height();
for(unsigned i=0; i<mSelection.size(); ++i)
{
int ipt = mSelection[i].mIndex;
float w = mSelection[i].mWeight;
vl::vec3 new_pos = mSelection[i].mStartPos + vl::vec3(mSelection[i].mDirection*w*scaling,0);
new_pos = vl::clamp(new_pos,vl::vec3(-0.5,-0.5,-0.5),vl::vec3(0.5,0.5,0.5));
mPoints->at(ipt) = (vl::fvec3)new_pos;
}
}
}
void mouseDownEvent(vl::EMouseButton, int x, int y)
{
vl::Camera* camera = rendering()->as<vl::Rendering>()->camera();
// convert Y coordinates to the OpenGL conventions
y = openglContext()->height() - y;
// compute the ray passing through the selected pixel
vl::Ray ray = camera->computeRay(x,y);
// instance our ray-intersector
vl::RayIntersector intersector;
// compute a frustum along the ray to accelerate the intersection test
intersector.setFrustum( camera->computeRayFrustum( x,y ) );
// compute the intersections!
// (1) short way
intersector.intersect(ray, sceneManager());
// (2) long way
/*
// specify the Actor[s] to be tested
intersector.actors()->clear();
sceneManager()->extractActors( *intersector.actors() );
// set the intersecting ray
intersector.setRay(ray);
// run intersection test
intersector.intersect();
*/
// inspect our intersections, the intersections returned are sorted according to their distance, the first one is the closest.
if (intersector.intersections().size())
{
// highlight the intersection point by moving the green sphere there
mIntersectionPoint->setLocalMatrix( vl::mat4() );
mIntersectionPoint->translate( intersector.intersections()[0]->intersectionPoint() );
mIntersectionPoint->computeWorldMatrix();
// print the name of the picked object
vl::Log::print( vl::Say("Intersections detected = %n (%s).\n") << intersector.intersections().size() << intersector.intersections()[0]->actor()->objectName() );
}
else
vl::Log::print("No intersections detected.\n");
}
void GLC_QuickView::sceneGraphInitializedDone()
{
disconnect(this, SIGNAL(sceneGraphInitialized()), this, SLOT(sceneGraphInitializedDone()));
QOpenGLContext* pContext= openglContext();
Q_ASSERT(pContext);
m_pQOpenGLContext= new QOpenGLContext();
m_pQOpenGLContext->setShareContext(pContext);
m_pQOpenGLContext->setFormat(pContext->format());
m_pQOpenGLContext->create();
Q_ASSERT(m_pQOpenGLContext->isValid());
QOffscreenSurface* pFakeSurface = new QOffscreenSurface();
pFakeSurface->setFormat(pContext->format());
pFakeSurface->create();
m_pContext= GLC_ContextManager::instance()->createContext(m_pQOpenGLContext, pFakeSurface);
m_pContext->makeCurrent();
qDebug() << m_pContext;
initializeGL();
}
virtual void initEvent()
{
vl::Log::notify(appletInfo());
// transform used for the moving cube and star
vl::ref< vl::Transform > transf = new vl::Transform;
rendering()->as<vl::Rendering>()->transform()->addChild(transf.get());
// effect for 2d rendering
vl::ref<vl::Effect> pixel_fx = new vl::Effect;
pixel_fx->shader()->enable(vl::EN_BLEND);
pixel_fx->shader()->enable(vl::EN_ALPHA_TEST);
pixel_fx->shader()->gocAlphaFunc()->set(vl::FU_GEQUAL, 0.9f);
// points rendering
vl::ref<vl::ImagePBO> circle16 = new vl::ImagePBO("/images/circle16.png");
mPoints = new vl::DrawPixels;
for(int i=0; i<1000; ++i)
{
vl::ref<vl::DrawPixels::Pixels> pixels = new vl::DrawPixels::Pixels(circle16.get(), 0,0);
mPoints->draws()->push_back( pixels.get() );
vl::ivec2 pos;
pos.x() = int(openglContext()->width() / 2.0 + rand()%300 - 150);
pos.y() = int(openglContext()->height() / 2.0 + rand()%300 - 150);
pixels->setPosition(pos);
pixels->setAlign(vl::AlignHCenter | vl::AlignVCenter);
}
mPoints->generatePixelBufferObjects(vl::BU_STATIC_DRAW, true);
sceneManager()->tree()->addActor( mPoints.get(), pixel_fx.get(), NULL )->setRenderRank(0);
// split star rendering
vl::ref<vl::ImagePBO> star_img = new vl::ImagePBO("/images/star.png");
int w = star_img->width() / 2;
mStar1 = new vl::DrawPixels::Pixels( star_img.get(), 0, 0, 0, 0, w, w );
mStar2 = new vl::DrawPixels::Pixels( star_img.get(), 0, 0, w, w, w, w );
mStar3 = new vl::DrawPixels::Pixels( star_img.get(), 0, 0, w, 0, w, w);
mStar4 = new vl::DrawPixels::Pixels( star_img.get(), 0, 0, 0, w, w, w);
mStar1->setAlign(vl::AlignRight|vl::AlignTop);
mStar2->setAlign(vl::AlignLeft|vl::AlignBottom);
mStar3->setAlign(vl::AlignLeft|vl::AlignTop);
mStar4->setAlign(vl::AlignRight|vl::AlignBottom);
mStar = new vl::DrawPixels;
mStar->draws()->push_back( mStar1.get() );
mStar->draws()->push_back( mStar2.get() );
mStar->draws()->push_back( mStar3.get() );
mStar->draws()->push_back( mStar4.get() );
mStar->generatePixelBufferObjects(vl::BU_STATIC_DRAW, true);
sceneManager()->tree()->addActor( mStar.get(), pixel_fx.get(), transf.get() )->setRenderRank(1);
// moving cube
vl::ref<vl::Effect> cube_fx = new vl::Effect;
cube_fx->shader()->enable(vl::EN_DEPTH_TEST);
cube_fx->shader()->enable(vl::EN_LIGHTING);
cube_fx->shader()->setRenderState( new vl::Light, 0 );
vl::ref<vl::Geometry> cube = vl::makeBox( vl::vec3(0,0,0), 1, 1, 1 );
cube->computeNormals();
mCube = sceneManager()->tree()->addActor(cube.get(), cube_fx.get(), transf.get() );
mCube->setRenderRank(2); // draw after 2d objects
}
void initEvent()
{
vl::Log::print(appletInfo());
mMode = NoMode;
openglContext()->setContinuousUpdate(false);
// camera setup
rendering()->as<vl::Rendering>()->setNearFarClippingPlanesOptimized(false);
rendering()->as<vl::Rendering>()->camera()->setProjectionAsOrtho2D();
rendering()->as<vl::Rendering>()->camera()->setViewMatrix( vl::mat4() );
// disable trackball and ghost camera manipulator
trackball()->setEnabled(false);
ghostCameraManipulator()->setEnabled(false);
// dummy empty image
mImage = new vl::Image(8,8,0, 1, vl::IF_RGBA, vl::IT_UNSIGNED_BYTE);
memset(mImage->pixels(), 0xFF, mImage->requiredMemory());
// texture setup
mTexture = new vl::Texture;
mTexture->getTexParameter()->setWrapS(vl::TPW_CLAMP);
mTexture->getTexParameter()->setWrapT(vl::TPW_CLAMP);
mTexture->getTexParameter()->setMinFilter(vl::TPF_LINEAR);
mTexture->getTexParameter()->setMagFilter(vl::TPF_LINEAR);
mTexture->prepareTexture2D(mImage.get(), vl::TF_RGBA);
mTextureMatrix = new vl::TextureMatrix(0);
vl::ref<vl::Effect> image_fx = new vl::Effect;
image_fx->shader()->gocTextureUnit(0)->setTexture(mTexture.get());
image_fx->shader()->setRenderState( mTextureMatrix.get() );
image_fx->shader()->enable(vl::EN_BLEND);
mGrid = vl::makeGrid( vl::vec3(0,0,0), 1.0f, 1.0f, mSlices, mSlices, true, vl::fvec2(0,0), vl::fvec2(1,1) );
mGrid->setVBOEnabled(false);
mGrid->transform(vl::mat4::getRotation(-90,1,0,0));
mPoints = dynamic_cast<vl::ArrayFloat3*>(mGrid->vertexArray());
// save point coordinates for the animation keyframe
mPointsRest = new vl::ArrayFloat3;
mPointsRest->resize( mPoints->size() );
memcpy(mPointsRest->ptr(), mPoints->ptr(), mPoints->bytesUsed());
// animate points buffer
mPointsAnim = new vl::ArrayFloat3;
mPointsAnim->resize( mPoints->size() );
mTransform = new vl::Transform;
rendering()->as<vl::Rendering>()->transform()->addChild(mTransform.get());
sceneManager()->tree()->addActor(mGrid.get(), image_fx.get(), mTransform.get());
mCursorTransform = new vl::Transform;
rendering()->as<vl::Rendering>()->transform()->addChild(mCursorTransform.get());
mBrushSize = 100;
vl::ref<vl::Effect> cursor_fx = new vl::Effect;
cursor_fx->shader()->gocLogicOp()->set(vl::LO_INVERT);
cursor_fx->shader()->enable(vl::EN_COLOR_LOGIC_OP);
vl::ref<vl::Geometry> cursor = vl::makeCircle(vl::vec3(0,0,0), 1.0f);
cursor->transform(vl::mat4::getRotation(-90,1,0,0));
mCursorActor = sceneManager()->tree()->addActor(cursor.get(), cursor_fx.get(), mCursorTransform.get());
// ensure the cursor is rendered over the image (whose render rank is 0 by default)
mCursorActor->setRenderRank(1);
mText = new vl::Text;
mText->setFont( vl::defFontManager()->acquireFont("/font/bitstream-vera/Vera.ttf", 10) );
mText->translate(0,-5,0);
mText->setColor(vl::white);
mText->setBackgroundColor(vl::fvec4(0,0,0,.75f));
mText->setBackgroundEnabled(true);
mHelpOn = true;
updateText();
vl::ref<vl::Effect> txt_fx = new vl::Effect;
txt_fx->shader()->enable(vl::EN_BLEND);
vl::Actor* txt_act = sceneManager()->tree()->addActor(mText.get(), txt_fx.get());
// draw the text for last
txt_act->setRenderRank(2);
loadFile("/images/toy.jpg");
}
void reset()
{
memcpy(mPoints->ptr(), mPointsRest->ptr(), mPoints->bytesUsed());
mPointsUndo.clear();
openglContext()->update();
}
void LipstickCompositor::setFullscreenSurface(QWaylandSurface *surface)
{
if (surface == m_fullscreenSurface)
return;
// Prevent flicker when returning to composited mode
if (!surface && m_fullscreenSurface && m_fullscreenSurface->surfaceItem())
m_fullscreenSurface->surfaceItem()->update();
m_fullscreenSurface = surface;
const bool directRenderingSucceeded = setDirectRenderSurface(m_fullscreenSurface, openglContext());
if (surface && !directRenderingSucceeded)
qWarning() << Q_FUNC_INFO << "failed to set direct render surface";
if ((surface && directRenderingSucceeded) != m_directRenderingActive) {
m_directRenderingActive = surface && directRenderingSucceeded;
emit directRenderingActiveChanged();
}
emit fullscreenSurfaceChanged();
}
