Mirrors/overte-AleziaKurdis
3
0
Fork 0
mirror of https://github.com/AleziaKurdis/overte.git synced 2025-04-06 12:12:59 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Trying to get widgets / windows working

Browse source
This commit is contained in:
Brad Davis 2015-06-01 17:31:18 -07:00
parent 23d6725a6a
commit a483dd27ba
33 changed files with 954 additions and 615 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
cmake/macros/GroupSources.cmake Normal file
View file

@ -0,0 +1,16 @@
#
# Distributed under the Apache License, Version 2.0.
# See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
#
macro(GroupSources curdir)
file(GLOB children RELATIVE ${PROJECT_SOURCE_DIR}/${curdir} ${PROJECT_SOURCE_DIR}/${curdir}/*)
foreach(child ${children})
if(IS_DIRECTORY ${PROJECT_SOURCE_DIR}/${curdir}/${child})
GroupSources(${curdir}/${child})
else()
string(REPLACE "/" "\\" groupname ${curdir})
source_group(${groupname} FILES ${PROJECT_SOURCE_DIR}/${curdir}/${child})
endif()
endforeach()
endmacro()

13
interface/CMakeLists.txt
View file

@ -36,19 +36,6 @@ endif ()
configure_file(InterfaceConfig.h.in "${PROJECT_BINARY_DIR}/includes/InterfaceConfig.h")
configure_file(InterfaceVersion.h.in "${PROJECT_BINARY_DIR}/includes/InterfaceVersion.h")
macro(GroupSources curdir)
file(GLOB children RELATIVE ${PROJECT_SOURCE_DIR}/${curdir} ${PROJECT_SOURCE_DIR}/${curdir}/*)
foreach(child ${children})
if(IS_DIRECTORY ${PROJECT_SOURCE_DIR}/${curdir}/${child})
GroupSources(${curdir}/${child})
else()
string(REPLACE "/" "\\" groupname ${curdir})
source_group(${groupname} FILES ${PROJECT_SOURCE_DIR}/${curdir}/${child})
endif()
endforeach()
endmacro()
# grab the implementation and header files from src dirs
file(GLOB_RECURSE INTERFACE_SRCS "src/*.cpp" "src/*.h")
GroupSources("src")

3
interface/src/Application.cpp
View file

@ -821,6 +821,9 @@ void Application::initializeUi() {
}
void Application::paintGL() {
if (getCanvasSize() == uvec2(0)) {
return;
}
PROFILE_RANGE(__FUNCTION__);
auto displayPlugin = getActiveDisplayPlugin();
displayPlugin->preRender();

12
interface/src/DisplayPlugins.cpp
View file

@ -12,11 +12,12 @@
#include <display-plugins/DisplayPlugin.h>
#include <display-plugins/NullDisplayPlugin.h>
#include <display-plugins/Tv3dDisplayPlugin.h>
#include <display-plugins/WindowDisplayPlugin.h>
#include <display-plugins/stereo/SideBySideStereoDisplayPlugin.h>
#include <display-plugins/stereo/InterleavedStereoDisplayPlugin.h>
#include <display-plugins/WidgetOpenGLDisplayPlugin.h>
#ifdef Q_OS_WIN
#include <display-plugins/OculusWin32DisplayPlugin.h>
#include <display-plugins/oculus/OculusWin32DisplayPlugin.h>
#else
#endif
@ -49,11 +50,12 @@ const DisplayPluginList& getDisplayPlugins() {
init = true;
DisplayPlugin* PLUGIN_POOL[] = {
new WindowDisplayPlugin(),
new WidgetOpenGLDisplayPlugin(),
#ifdef DEBUG
new NullDisplayPlugin(),
#endif
new Tv3dDisplayPlugin(),
new SideBySideStereoDisplayPlugin(),
new InterleavedStereoDisplayPlugin(),
new OculusWin32DisplayPlugin(),
nullptr
};

2
interface/src/ui/ApplicationOverlay.cpp
View file

@ -196,7 +196,7 @@ void ApplicationOverlay::renderOverlay() {
glm::uvec2 size = qApp->getCanvasSize();
if (size == uvec2(0)) {
qDebug() << "Bad size from display plugin";
glm::uvec2 size = qApp->getCanvasSize();
size = qApp->getCanvasSize();
}
if (!_framebufferObject || size != toGlm(_framebufferObject->size())) {

2
libraries/display-plugins/CMakeLists.txt
View file

@ -7,6 +7,8 @@ setup_hifi_opengl()
link_hifi_libraries(shared plugins gpu render-utils)
GroupSources("src/display-plugins")
add_dependency_external_projects(glm)
find_package(GLM REQUIRED)
target_include_directories(${TARGET_NAME} PUBLIC ${GLM_INCLUDE_DIRS})

33
libraries/display-plugins/src/display-plugins/OculusWin32DisplayPlugin.h
View file

@ -1,33 +0,0 @@
//
// Created by Bradley Austin Davis on 2015/05/29
// Copyright 2015 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#pragma once
#include "OculusBaseDisplayPlugin.h"
#include <QTimer>
class OffscreenGlCanvas;
class OculusWin32DisplayPlugin : public OculusBaseDisplayPlugin {
public:
virtual bool isSupported();
virtual const QString & getName();
virtual void activate(PluginContainer * container);
virtual void deactivate();
// virtual QSize getDeviceSize() const final;
// virtual glm::ivec2 getCanvasSize() const final;
void display(GLuint sceneTexture, const glm::uvec2& sceneSize,
GLuint overlayTexture, const glm::uvec2& overlaySize);
protected:
virtual void customizeWindow(PluginContainer * container);
virtual void customizeContext(PluginContainer * container);
private:
static const QString NAME;
};

0
libraries/display-plugins/src/OglplusHelpers.cpp → libraries/display-plugins/src/display-plugins/OglplusHelpers.cpp
View file

0
libraries/display-plugins/src/OglplusHelpers.h → libraries/display-plugins/src/display-plugins/OglplusHelpers.h
View file

125
libraries/display-plugins/src/display-plugins/OpenGlDisplayPlugin.cpp → libraries/display-plugins/src/display-plugins/OpenGLDisplayPlugin.cpp
View file

@ -5,7 +5,7 @@
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#include "OpenGlDisplayPlugin.h"
#include "OpenGLDisplayPlugin.h"
#include <QOpenGLContext>
#include <TextureCache.h>
@ -19,115 +19,55 @@
#include <GLMHelpers.h>
OpenGlDisplayPlugin::OpenGlDisplayPlugin() {
OpenGLDisplayPlugin::OpenGLDisplayPlugin() {
connect(&_timer, &QTimer::timeout, this, [&] {
if (_window) {
emit requestRender();
}
emit requestRender();
});
}
OpenGlDisplayPlugin::~OpenGlDisplayPlugin() {
OpenGLDisplayPlugin::~OpenGLDisplayPlugin() {
}
QWindow* OpenGlDisplayPlugin::getWindow() const {
return _window;
}
glm::ivec2 OpenGlDisplayPlugin::getTrueMousePosition() const {
return toGlm(_window->mapFromGlobal(QCursor::pos()));
}
QSize OpenGlDisplayPlugin::getDeviceSize() const {
return _window->geometry().size() * _window->devicePixelRatio();
}
glm::ivec2 OpenGlDisplayPlugin::getCanvasSize() const {
return toGlm(_window->geometry().size());
}
bool OpenGlDisplayPlugin::hasFocus() const {
return _window->isActive();
}
void OpenGlDisplayPlugin::makeCurrent() {
_window->makeCurrent();
}
void OpenGlDisplayPlugin::doneCurrent() {
_window->doneCurrent();
}
void OpenGlDisplayPlugin::swapBuffers() {
_window->swapBuffers();
}
void OpenGlDisplayPlugin::preDisplay() {
void OpenGLDisplayPlugin::preDisplay() {
makeCurrent();
};
void OpenGlDisplayPlugin::preRender() {
void OpenGLDisplayPlugin::preRender() {
// NOOP
}
void OpenGlDisplayPlugin::finishFrame() {
void OpenGLDisplayPlugin::finishFrame() {
swapBuffers();
doneCurrent();
};
void OpenGlDisplayPlugin::activate(PluginContainer * container) {
Q_ASSERT(nullptr == _window);
_window = new GlWindow(QOpenGLContext::currentContext());
_window->installEventFilter(this);
customizeWindow(container);
// _window->show();
makeCurrent();
customizeContext(container);
_timer.start(1);
}
void OpenGlDisplayPlugin::customizeContext(PluginContainer * container) {
void OpenGLDisplayPlugin::customizeContext(PluginContainer * container) {
using namespace oglplus;
Context::BlendFunc(BlendFunction::SrcAlpha, BlendFunction::OneMinusSrcAlpha);
Context::Disable(Capability::Blend);
Context::Disable(Capability::DepthTest);
Context::Disable(Capability::CullFace);
program = loadDefaultShader();
plane = loadPlane(program);
_program = loadDefaultShader();
_plane = loadPlane(_program);
Context::ClearColor(0, 0, 0, 1);
crosshairTexture = DependencyManager::get<TextureCache>()->
_crosshairTexture = DependencyManager::get<TextureCache>()->
getImageTexture(PathUtils::resourcesPath() + "images/sixense-reticle.png");
}
void OpenGlDisplayPlugin::deactivate() {
void OpenGLDisplayPlugin::activate(PluginContainer * container) {
_timer.start(1);
}
void OpenGLDisplayPlugin::deactivate() {
_timer.stop();
makeCurrent();
plane.reset();
program.reset();
crosshairTexture.reset();
Q_ASSERT(0 == glGetError());
_plane.reset();
_program.reset();
_crosshairTexture.reset();
doneCurrent();
Q_ASSERT(nullptr != _window);
_window->hide();
_window->destroy();
_window->deleteLater();
_window = nullptr;
}
void OpenGlDisplayPlugin::installEventFilter(QObject* filter) {
_window->installEventFilter(filter);
}
void OpenGlDisplayPlugin::removeEventFilter(QObject* filter) {
_window->removeEventFilter(filter);
}
// Pressing Alt (and Meta) key alone activates the menubar because its style inherits the
// SHMenuBarAltKeyNavigation from QWindowsStyle. This makes it impossible for a scripts to
// receive keyPress events for the Alt (and Meta) key in a reliable manner.
@ -137,7 +77,7 @@ void OpenGlDisplayPlugin::removeEventFilter(QObject* filter) {
// http://www.archivum.info/qt-interest@trolltech.com/2006-09/00053/Re-(Qt4)-Alt-key-focus-QMenuBar-(solved).html
// Pass input events on to the application
bool OpenGlDisplayPlugin::eventFilter(QObject* receiver, QEvent* event) {
bool OpenGLDisplayPlugin::eventFilter(QObject* receiver, QEvent* event) {
switch (event->type()) {
case QEvent::MouseButtonPress:
case QEvent::MouseButtonRelease:
@ -168,3 +108,26 @@ bool OpenGlDisplayPlugin::eventFilter(QObject* receiver, QEvent* event) {
return false;
}
void OpenGLDisplayPlugin::display(
GLuint sceneTexture, const glm::uvec2& sceneSize,
GLuint overlayTexture, const glm::uvec2& overlaySize) {
makeCurrent();
Q_ASSERT(0 == glGetError());
uvec2 size = toGlm(getDeviceSize());
using namespace oglplus;
Context::Viewport(size.x, size.y);
glClearColor(0, 1, 1, 1);
Context::Clear().ColorBuffer().DepthBuffer();
_program->Bind();
Mat4Uniform(*_program, "ModelView").Set(mat4());
Mat4Uniform(*_program, "Projection").Set(mat4());
glBindTexture(GL_TEXTURE_2D, sceneTexture);
_plane->Use();
_plane->Draw();
Context::Enable(Capability::Blend);
glBindTexture(GL_TEXTURE_2D, overlayTexture);
_plane->Draw();
Context::Disable(Capability::Blend);
glBindTexture(GL_TEXTURE_2D, 0);
Q_ASSERT(0 == glGetError());
}

52
libraries/display-plugins/src/display-plugins/OpenGLDisplayPlugin.h Normal file
View file

@ -0,0 +1,52 @@
//
// Created by Bradley Austin Davis on 2015/05/29
// Copyright 2015 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#pragma once
#include <QTimer>
#include <gpu/Texture.h>
#include "DisplayPlugin.h"
#include "OglplusHelpers.h"
class GlWindow;
class QOpenGLContext;
class OpenGLDisplayPlugin : public DisplayPlugin {
public:
OpenGLDisplayPlugin();
virtual ~OpenGLDisplayPlugin();
virtual void preRender() override;
virtual void preDisplay() override;
virtual void finishFrame() override;
virtual void activate(PluginContainer * container) override;
virtual void deactivate() override;
virtual bool eventFilter(QObject* receiver, QEvent* event) override;
void display(
GLuint sceneTexture, const glm::uvec2& sceneSize,
GLuint overlayTexture, const glm::uvec2& overlaySize) override;
protected:
// Needs to be called by the activate method after the GL context has been created to
// initialize OpenGL context settings needed by the plugin
virtual void customizeContext(PluginContainer * container);
virtual void makeCurrent() = 0;
virtual void doneCurrent() = 0;
virtual void swapBuffers() = 0;
QTimer _timer;
ProgramPtr _program;
ShapeWrapperPtr _plane;
gpu::TexturePointer _crosshairTexture;
};

61
libraries/display-plugins/src/display-plugins/OpenGlDisplayPlugin.h
View file

@ -1,61 +0,0 @@
//
// Created by Bradley Austin Davis on 2015/05/29
// Copyright 2015 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#pragma once
#include <QTimer>
#include <gpu/Texture.h>
#include "DisplayPlugin.h"
#include "../OglplusHelpers.h"
class GlWindow;
class OpenGlDisplayPlugin : public DisplayPlugin {
public:
OpenGlDisplayPlugin();
virtual ~OpenGlDisplayPlugin();
virtual void preRender();
virtual void preDisplay();
virtual void finishFrame();
virtual void activate(PluginContainer * container);
virtual void deactivate();
virtual QSize getDeviceSize() const;
virtual glm::ivec2 getCanvasSize() const;
virtual bool hasFocus() const;
virtual glm::ivec2 getTrueMousePosition() const;
virtual QWindow* getWindow() const;
virtual bool eventFilter(QObject* receiver, QEvent* event);
virtual void installEventFilter(QObject* filter);
virtual void removeEventFilter(QObject* filter);
protected:
// Called by the activate method to specify the initial
// window geometry flags, etc
virtual void customizeWindow(PluginContainer * container) = 0;
// Needs to be called by the activate method after the GL context has been created to
// initialize OpenGL context settings needed by the plugin
virtual void customizeContext(PluginContainer * container);
virtual void makeCurrent() final;
virtual void doneCurrent() final;
virtual void swapBuffers() final;
GlWindow* _window{ nullptr };
QTimer _timer;
ProgramPtr program;
ShapeWrapperPtr plane;
gpu::TexturePointer crosshairTexture;
};

166
libraries/display-plugins/src/display-plugins/Tv3dDisplayPlugin.cpp
View file

@ -1,166 +0,0 @@
//
// Created by Bradley Austin Davis on 2015/05/29
// Copyright 2015 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#include "Tv3dDisplayPlugin.h"
#include <QApplication>
#include <QDesktopWidget>
#include <GlWindow.h>
#include <ViewFrustum.h>
#include <MatrixStack.h>
#include <gpu/GLBackend.h>
const QString Tv3dDisplayPlugin::NAME("Tv3dDisplayPlugin");
const QString & Tv3dDisplayPlugin::getName() {
return NAME;
}
Tv3dDisplayPlugin::Tv3dDisplayPlugin() {
}
bool Tv3dDisplayPlugin::isSupported() const {
// FIXME this should attempt to do a scan for supported 3D output
return true;
}
void Tv3dDisplayPlugin::customizeWindow(PluginContainer * container) {
_window->setFlags(Qt::FramelessWindowHint);
auto desktop = QApplication::desktop();
QRect primaryGeometry = desktop->screenGeometry();
for (int i = 0; i < desktop->screenCount(); ++i) {
QRect geometry = desktop->screen(i)->geometry();
if (geometry.topLeft() == primaryGeometry.topLeft()) {
continue;
}
float aspect = (float)geometry.width() / (float)geometry.height();
if (aspect < 1.0f) {
continue;
}
_window->setGeometry(geometry);
break;
}
_window->setCursor(Qt::BlankCursor);
_window->show();
}
// FIXME make this into a setting that can be adjusted
const float DEFAULT_IPD = 0.064f;
const float HALF_DEFAULT_IPD = DEFAULT_IPD / 2.0f;
glm::mat4 Tv3dDisplayPlugin::getProjection(Eye eye, const glm::mat4& baseProjection) const {
// Refer to http://www.nvidia.com/content/gtc-2010/pdfs/2010_gtc2010.pdf on creating
// stereo projection matrices. Do NOT use "toe-in", use translation.
float nearZ = DEFAULT_NEAR_CLIP; // near clipping plane
float screenZ = 0.25f; // screen projection plane
// FIXME verify this is the right calculation
float frustumshift = HALF_DEFAULT_IPD * nearZ / screenZ;
if (eye == Right) {
frustumshift = -frustumshift;
}
return glm::translate(baseProjection, vec3(frustumshift, 0, 0));
}
glm::mat4 Tv3dDisplayPlugin::getModelview(Eye eye, const glm::mat4& baseModelview) const {
float modelviewShift = HALF_DEFAULT_IPD;
if (eye == Left) {
modelviewShift = -modelviewShift;
}
return baseModelview * glm::translate(mat4(), vec3(modelviewShift, 0, 0));
}
template <typename F>
void sbs_for_each_eye(const uvec2& size, F f) {
QRect r(QPoint(0, 0), QSize(size.x / 2, size.y));
for_each_eye([&](Eye eye) {
oglplus::Context::Viewport(r.x(), r.y(), r.width(), r.height());
f(eye);
}, [&] {
r.moveLeft(r.width());
});
}
void Tv3dDisplayPlugin::display(
GLuint sceneTexture, const glm::uvec2& sceneSize,
GLuint overlayTexture, const glm::uvec2& overlaySize) {
makeCurrent();
GLenum err = glGetError();
uvec2 size = toGlm(getDeviceSize());
err = glGetError();
using namespace oglplus;
err = glGetError();
Context::Viewport(size.x, size.y);
err = glGetError();
Context::Clear().ColorBuffer().DepthBuffer();
Mat4Uniform(*program, "ModelView").Set(mat4());
Mat4Uniform(*program, "Projection").Set(mat4());
glBindTexture(GL_TEXTURE_2D, sceneTexture);
plane->Draw();
// FIXME the
const float screenAspect = aspect(size);
const GLfloat distance = 1.0f;
const GLfloat halfQuadHeight = distance * tan(DEFAULT_FIELD_OF_VIEW_DEGREES);
const GLfloat halfQuadWidth = halfQuadHeight * screenAspect;
const GLfloat quadWidth = halfQuadWidth * 2.0f;
const GLfloat quadHeight = halfQuadHeight * 2.0f;
vec3 quadSize(quadWidth, quadHeight, 1.0f);
quadSize = vec3(1.0f) / quadSize;
using namespace oglplus;
Context::Enable(Capability::Blend);
glBindTexture(GL_TEXTURE_2D, overlayTexture);
mat4 pr = glm::perspective(glm::radians(DEFAULT_FIELD_OF_VIEW_DEGREES), screenAspect, DEFAULT_NEAR_CLIP, DEFAULT_FAR_CLIP);
Mat4Uniform(*program, "Projection").Set(pr);
// Position the camera relative to the overlay texture
MatrixStack mv;
mv.translate(vec3(0, 0, -distance)).scale(vec3(0.7f, 0.7f / screenAspect, 1.0f)); // .scale(vec3(quadWidth, quadHeight, 1.0));
sbs_for_each_eye(size, [&](Eye eye) {
mv.withPush([&] {
// translate
mv.top() = getModelview(eye, mv.top());
Mat4Uniform(*program, "ModelView").Set(mv.top());
plane->Draw();
});
});
glBindTexture(GL_TEXTURE_2D, gpu::GLBackend::getTextureID(crosshairTexture));
glm::vec2 canvasSize = getCanvasSize();
glm::vec2 mouse = toGlm(_window->mapFromGlobal(QCursor::pos()));
mouse /= canvasSize;
mouse *= 2.0f;
mouse -= 1.0f;
mouse.y *= -1.0f;
sbs_for_each_eye(size, [&](Eye eye) {
mv.withPush([&] {
// translate
mv.top() = getModelview(eye, mv.top());
mv.translate(mouse);
//mv.scale(0.05f);
mv.scale(vec3(0.025f, 0.05f, 1.0f));
Mat4Uniform(*program, "ModelView").Set(mv.top());
plane->Draw();
});
});
Context::Disable(Capability::Blend);
}
void Tv3dDisplayPlugin::activate(PluginContainer * container) {
OpenGlDisplayPlugin::activate(container);
// FIXME Add menu items
}

35
libraries/display-plugins/src/display-plugins/Tv3dDisplayPlugin.h
View file

@ -1,35 +0,0 @@
//
// Created by Bradley Austin Davis on 2015/05/29
// Copyright 2015 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#pragma once
#include "OpenGlDisplayPlugin.h"
class Tv3dDisplayPlugin : public OpenGlDisplayPlugin {
Q_OBJECT
public:
Tv3dDisplayPlugin();
virtual const QString & getName();
virtual bool isStereo() const final { return true; }
virtual bool isSupported() const final;
virtual void activate(PluginContainer * container);
void display(GLuint sceneTexture, const glm::uvec2& sceneSize,
GLuint overlayTexture, const glm::uvec2& overlaySize);
virtual glm::mat4 getProjection(Eye eye, const glm::mat4& baseProjection) const;
virtual glm::mat4 getModelview(Eye eye, const glm::mat4& baseModelview) const;
protected:
virtual void customizeWindow(PluginContainer * container);
//virtual std::function<QPointF(const QPointF&)> getMouseTranslator();
//virtual glm::ivec2 trueMouseToUiMouse(const glm::ivec2 & position) const;
private:
static const QString NAME;
};

108
libraries/display-plugins/src/display-plugins/WidgetOpenGLDisplayPlugin.cpp Normal file
View file

@ -0,0 +1,108 @@
//
// Created by Bradley Austin Davis on 2015/05/29
// Copyright 2015 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#include "WidgetOpenGLDisplayPlugin.h"
#include <QMainWindow>
#include <GlWindow.h>
#include <QOpenGLContext>
#include <QOpenGLDebugLogger>
#include <QWidget>
#include <QGLContext>
#include <QGLWidget>
#include "plugins/PluginContainer.h"
WidgetOpenGLDisplayPlugin::WidgetOpenGLDisplayPlugin() {
}
const QString WidgetOpenGLDisplayPlugin::NAME("QWindow 2D Renderer");
const QString & WidgetOpenGLDisplayPlugin::getName() {
return NAME;
}
class CustomOpenGLWidget : public QGLWidget {
public:
explicit CustomOpenGLWidget(const QGLFormat& format, QWidget* parent = 0,
const QGLWidget* shareWidget = 0, Qt::WindowFlags f = 0) : QGLWidget(format, parent, shareWidget, f) {
setAutoBufferSwap(false);
}
protected:
void paintGL() { }
void resizeGL() {}
void initializeGL() {}
};
void WidgetOpenGLDisplayPlugin::activate(PluginContainer * container) {
OpenGLDisplayPlugin::activate(container);
Q_ASSERT(nullptr == _widget);
_widget = new CustomOpenGLWidget(QGL::NoDepthBuffer | QGL::NoStencilBuffer);
QOpenGLContext * sourceContext = QOpenGLContext::currentContext();
QOpenGLContext * newContext = new QOpenGLContext();
_widget->setContext(
QGLContext::fromOpenGLContext(newContext),
QGLContext::fromOpenGLContext(sourceContext));
QMainWindow* mainWindow = container->getAppMainWindow();
mainWindow->setCentralWidget(_widget);
makeCurrent();
customizeContext(container);
_widget->installEventFilter(this);
}
void WidgetOpenGLDisplayPlugin::deactivate() {
OpenGLDisplayPlugin::deactivate();
_widget->deleteLater();
_widget = nullptr;
}
void WidgetOpenGLDisplayPlugin::makeCurrent() {
_widget->makeCurrent();
}
void WidgetOpenGLDisplayPlugin::doneCurrent() {
_widget->doneCurrent();
}
void WidgetOpenGLDisplayPlugin::swapBuffers() {
_widget->swapBuffers();
}
glm::ivec2 WidgetOpenGLDisplayPlugin::getTrueMousePosition() const {
return toGlm(_widget->mapFromGlobal(QCursor::pos()));
}
QSize WidgetOpenGLDisplayPlugin::getDeviceSize() const {
return _widget->geometry().size() * _widget->devicePixelRatio();
}
glm::ivec2 WidgetOpenGLDisplayPlugin::getCanvasSize() const {
return toGlm(_widget->geometry().size());
}
bool WidgetOpenGLDisplayPlugin::hasFocus() const {
return _widget->hasFocus();
}
void WidgetOpenGLDisplayPlugin::installEventFilter(QObject* filter) {
_widget->installEventFilter(filter);
}
void WidgetOpenGLDisplayPlugin::removeEventFilter(QObject* filter) {
_widget->removeEventFilter(filter);
}
QWindow* WidgetOpenGLDisplayPlugin::getWindow() const {
return _widget->windowHandle();
}

40
libraries/display-plugins/src/display-plugins/WidgetOpenGLDisplayPlugin.h Normal file
View file

@ -0,0 +1,40 @@
//
// Created by Bradley Austin Davis on 2015/05/29
// Copyright 2015 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#pragma once
#include "OpenGLDisplayPlugin.h"
class QGLWidget;
class QOpenGLDebugLogger;
class WidgetOpenGLDisplayPlugin : public OpenGLDisplayPlugin {
Q_OBJECT
public:
static const QString NAME;
WidgetOpenGLDisplayPlugin();
virtual const QString & getName() override;
virtual glm::ivec2 getTrueMousePosition() const override;
virtual QSize getDeviceSize() const override;
virtual glm::ivec2 getCanvasSize() const override;
virtual bool hasFocus() const override;
virtual QWindow* getWindow() const override;
virtual void activate(PluginContainer * container) override;
virtual void deactivate() override;
virtual void installEventFilter(QObject* filter) override;
virtual void removeEventFilter(QObject* filter) override;
protected:
virtual void makeCurrent() override;
virtual void doneCurrent() override;
virtual void swapBuffers() override;
QGLWidget* _widget{ nullptr };
};

94
libraries/display-plugins/src/display-plugins/WindowDisplayPlugin.cpp
View file

@ -1,94 +0,0 @@
//
// Created by Bradley Austin Davis on 2015/05/29
// Copyright 2015 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#include "WindowDisplayPlugin.h"
#include <QMainWindow>
#include <GlWindow.h>
#include "plugins/PluginContainer.h"
WindowDisplayPlugin::WindowDisplayPlugin() {
}
const QString WindowDisplayPlugin::NAME("QWindow 2D Renderer");
const QString & WindowDisplayPlugin::getName() {
return NAME;
}
void WindowDisplayPlugin::customizeWindow(PluginContainer * container) {
QMainWindow* mainWindow = container->getAppMainWindow();
QWidget* widget = QWidget::createWindowContainer(_window);
mainWindow->setCentralWidget(widget);
}
void WindowDisplayPlugin::display(
GLuint sceneTexture, const glm::uvec2& sceneSize,
GLuint overlayTexture, const glm::uvec2& overlaySize) {
glDisable(GL_LIGHTING);
glDisable(GL_DEPTH_TEST);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glClearColor(0, 0, 1, 1);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_TEXTURE_2D);
glViewport(0, 0, getDeviceSize().width(), getDeviceSize().height());
if (sceneTexture) {
glBindTexture(GL_TEXTURE_2D, sceneTexture);
glBegin(GL_QUADS);
glTexCoord2f(0, 0);
glVertex2f(-1, -1);
glTexCoord2f(1, 0);
glVertex2f(+1, -1);
glTexCoord2f(1, 1);
glVertex2f(+1, +1);
glTexCoord2f(0, 1);
glVertex2f(-1, +1);
glEnd();
}
if (overlayTexture) {
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glBindTexture(GL_TEXTURE_2D, overlayTexture);
glBegin(GL_QUADS);
glTexCoord2f(0, 0);
glVertex2f(-1, -1);
glTexCoord2f(1, 0);
glVertex2f(+1, -1);
glTexCoord2f(1, 1);
glVertex2f(+1, +1);
glTexCoord2f(0, 1);
glVertex2f(-1, +1);
glEnd();
}
glDisable(GL_BLEND);
glBindTexture(GL_TEXTURE_2D, 0);
glDisable(GL_TEXTURE_2D);
//Q_ASSERT(!glGetError());
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
glEnable(GL_LIGHTING);
glEnable(GL_DEPTH_TEST);
glFinish();
}

28
libraries/display-plugins/src/display-plugins/WindowDisplayPlugin.h
View file

@ -1,28 +0,0 @@
//
// Created by Bradley Austin Davis on 2015/05/29
// Copyright 2015 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#pragma once
#include "OpenGlDisplayPlugin.h"
class WindowDisplayPlugin : public OpenGlDisplayPlugin {
Q_OBJECT
public:
static const QString NAME;
WindowDisplayPlugin();
virtual const QString & getName();
void display(GLuint sceneTexture, const glm::uvec2& sceneSize,
GLuint overlayTexture, const glm::uvec2& overlaySize);
protected:
// Called by the activate method to specify the initial
// window geometry flags, etc
virtual void customizeWindow(PluginContainer * container);
};

87
libraries/display-plugins/src/display-plugins/WindowOpenGLDisplayPlugin.cpp Normal file
View file

@ -0,0 +1,87 @@
//
// Created by Bradley Austin Davis on 2015/05/29
// Copyright 2015 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#include "WindowOpenGLDisplayPlugin.h"
#include <GlWindow.h>
#include <QOpenGLContext>
WindowOpenGLDisplayPlugin::WindowOpenGLDisplayPlugin() {
}
glm::ivec2 WindowOpenGLDisplayPlugin::getTrueMousePosition() const {
return toGlm(_window->mapFromGlobal(QCursor::pos()));
}
QSize WindowOpenGLDisplayPlugin::getDeviceSize() const {
return _window->geometry().size() * _window->devicePixelRatio();
}
glm::ivec2 WindowOpenGLDisplayPlugin::getCanvasSize() const {
return toGlm(_window->geometry().size());
}
bool WindowOpenGLDisplayPlugin::hasFocus() const {
return _window->isActive();
}
void WindowOpenGLDisplayPlugin::initSurfaceFormat(QSurfaceFormat& format) {
// Qt Quick may need a depth and stencil buffer. Always make sure these are available.
format.setDepthBufferSize(0);
format.setStencilBufferSize(0);
format.setVersion(4, 1);
#ifdef DEBUG
format.setOption(QSurfaceFormat::DebugContext);
#endif
format.setProfile(QSurfaceFormat::OpenGLContextProfile::CoreProfile);
}
void WindowOpenGLDisplayPlugin::activate(PluginContainer * container) {
OpenGLDisplayPlugin::activate(container);
_window = new GlWindow(QOpenGLContext::currentContext());
QSurfaceFormat format;
initSurfaceFormat(format);
_window->setFormat(format);
_window->create();
_window->installEventFilter(this);
customizeWindow(container);
makeCurrent();
customizeContext(container);
}
void WindowOpenGLDisplayPlugin::deactivate() {
OpenGLDisplayPlugin::deactivate();
_window->deleteLater();
_window = nullptr;
}
void WindowOpenGLDisplayPlugin::makeCurrent() {
_window->makeCurrent();
}
void WindowOpenGLDisplayPlugin::doneCurrent() {
_window->doneCurrent();
}
void WindowOpenGLDisplayPlugin::swapBuffers() {
_window->swapBuffers();
}
void WindowOpenGLDisplayPlugin::installEventFilter(QObject* filter) {
_window->installEventFilter(filter);
}
void WindowOpenGLDisplayPlugin::removeEventFilter(QObject* filter) {
_window->removeEventFilter(filter);
}
QWindow* WindowOpenGLDisplayPlugin::getWindow() const {
return _window;
}

38
libraries/display-plugins/src/display-plugins/WindowOpenGLDisplayPlugin.h Normal file
View file

@ -0,0 +1,38 @@
//
// Created by Bradley Austin Davis on 2015/05/29
// Copyright 2015 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#pragma once
#include "OpenGLDisplayPlugin.h"
class GlWindow;
class QSurfaceFormat;
class WindowOpenGLDisplayPlugin : public OpenGLDisplayPlugin {
Q_OBJECT
public:
WindowOpenGLDisplayPlugin();
virtual glm::ivec2 getTrueMousePosition() const override;
virtual QSize getDeviceSize() const override;
virtual glm::ivec2 getCanvasSize() const override;
virtual bool hasFocus() const override;
virtual QWindow* getWindow() const override;
virtual void activate(PluginContainer * container) override;
virtual void deactivate() override;
virtual void installEventFilter(QObject* filter) override;
virtual void removeEventFilter(QObject* filter) override;
protected:
virtual void makeCurrent() override;
virtual void doneCurrent() override;
virtual void swapBuffers() override;
virtual void customizeWindow(PluginContainer * container) = 0;
virtual void initSurfaceFormat(QSurfaceFormat& format);
GlWindow* _window{ nullptr };
};

20
libraries/display-plugins/src/display-plugins/OculusBaseDisplayPlugin.cpp → libraries/display-plugins/src/display-plugins/oculus/OculusBaseDisplayPlugin.cpp
View file

@ -9,13 +9,12 @@
#include <ViewFrustum.h>
#include "../OculusHelpers.h"
#include "OculusHelpers.h"
void OculusBaseDisplayPlugin::activate(PluginContainer * container) {
OpenGlDisplayPlugin::activate(container);
glm::uvec2 eyeSizes[2];
ovr_for_each_eye([&](ovrEyeType eye) {
ovrEyeRenderDesc erd = ovrHmd_GetRenderDesc(_hmd, eye, _hmd->MaxEyeFov[eye]);
ovrEyeRenderDesc& erd = _eyeRenderDescs[eye] = ovrHmd_GetRenderDesc(_hmd, eye, _hmd->MaxEyeFov[eye]);
ovrMatrix4f ovrPerspectiveProjection =
ovrMatrix4f_Projection(erd.Fov, DEFAULT_NEAR_CLIP, DEFAULT_FAR_CLIP, ovrProjection_RightHanded);
_eyeProjections[eye] = toGlm(ovrPerspectiveProjection);
@ -23,8 +22,15 @@ void OculusBaseDisplayPlugin::activate(PluginContainer * container) {
eyeSizes[eye] = toGlm(ovrHmd_GetFovTextureSize(_hmd, eye, erd.Fov, 1.0f));
});
_desiredFramebufferSize = QSize(
eyeSizes[0].x + eyeSizes[1].x,
eyeSizes[0].x + eyeSizes[1].x,
std::max(eyeSizes[0].y, eyeSizes[1].y));
if (!OVR_SUCCESS(ovrHmd_ConfigureTracking(_hmd,
ovrTrackingCap_Orientation | ovrTrackingCap_Position | ovrTrackingCap_MagYawCorrection, 0))) {
qFatal("Could not attach to sensor device");
}
WidgetOpenGLDisplayPlugin::activate(container);
}
QSize OculusBaseDisplayPlugin::getRecommendedFramebufferSize() const {
@ -40,5 +46,9 @@ glm::mat4 OculusBaseDisplayPlugin::getProjection(Eye eye, const glm::mat4& baseP
}
glm::mat4 OculusBaseDisplayPlugin::getModelview(Eye eye, const glm::mat4& baseModelview) const {
return toGlm(_eyePoses[eye]);
return baseModelview * toGlm(_eyePoses[eye]);
}
void OculusBaseDisplayPlugin::resetSensors() {
ovrHmd_RecenterPose(_hmd);
}

19
libraries/display-plugins/src/display-plugins/OculusBaseDisplayPlugin.h → libraries/display-plugins/src/display-plugins/oculus/OculusBaseDisplayPlugin.h
View file

@ -7,24 +7,25 @@
//
#pragma once
#include "OpenGlDisplayPlugin.h"
#include "../WidgetOpenGLDisplayPlugin.h"
#include <OVR_CAPI.h>
class OculusBaseDisplayPlugin : public OpenGlDisplayPlugin {
class OculusBaseDisplayPlugin : public WidgetOpenGLDisplayPlugin {
public:
// Stereo specific methods
virtual bool isHmd() const { return true; }
virtual glm::mat4 getProjection(Eye eye, const glm::mat4& baseProjection) const;
virtual glm::mat4 getModelview(Eye eye, const glm::mat4& baseModelview) const;
virtual void activate(PluginContainer * container);
virtual void preRender();
virtual QSize getRecommendedFramebufferSize() const;
virtual bool isHmd() const override { return true; }
virtual glm::mat4 getProjection(Eye eye, const glm::mat4& baseProjection) const override;
virtual glm::mat4 getModelview(Eye eye, const glm::mat4& baseModelview) const override;
virtual void activate(PluginContainer * container) override;
virtual void preRender() override;
virtual QSize getRecommendedFramebufferSize() const override;
virtual void resetSensors() override;
protected:
ovrHmd _hmd;
unsigned int _frameIndex{ 0 };
ovrEyeRenderDesc _eyeRenderDescs[2];
ovrPosef _eyePoses[2];
ovrVector3f _eyeOffsets[2];
glm::mat4 _eyeProjections[2];

1
libraries/display-plugins/src/OculusHelpers.h → libraries/display-plugins/src/display-plugins/oculus/OculusHelpers.h
View file

@ -10,6 +10,7 @@
#include <OVR_CAPI.h>
#include <GLMHelpers.h>
#include <glm/gtc/type_ptr.hpp>
#include <glm/gtc/matrix_transform.hpp>
// Convenience method for looping over each eye with a lambda
template <typename Function>

259
libraries/display-plugins/src/display-plugins/OculusWin32DisplayPlugin.cpp → libraries/display-plugins/src/display-plugins/oculus/OculusWin32DisplayPlugin.cpp
View file

@ -10,68 +10,23 @@
#include <memory>
#include <QMainWindow>
#include <QGLWidget>
#include <GLMHelpers.h>
#include <GlWindow.h>
#include <QEvent>
#include <QResizeEvent>
#include <OVR_CAPI_GL.h>
#include "plugins/PluginContainer.h"
#include "OculusHelpers.h"
#include "../OglplusHelpers.h"
const QString OculusWin32DisplayPlugin::NAME("Oculus Rift");
using oglplus::Framebuffer;
using oglplus::DefaultFramebuffer;
const QString & OculusWin32DisplayPlugin::getName() {
return NAME;
}
bool OculusWin32DisplayPlugin::isSupported() {
if (!OVR_SUCCESS(ovr_Initialize(nullptr))) {
return false;
}
bool result = false;
if (ovrHmd_Detect() > 0) {
result = true;
}
ovr_Shutdown();
return result;
}
void OculusWin32DisplayPlugin::activate(PluginContainer * container) {
if (!OVR_SUCCESS(ovr_Initialize(nullptr))) {
Q_ASSERT(false);
qFatal("Failed to Initialize SDK");
}
if (!OVR_SUCCESS(ovrHmd_Create(0, &_hmd))) {
Q_ASSERT(false);
qFatal("Failed to acquire HMD");
}
// Parent class relies on our _hmd intialization, so it must come after that.
OculusBaseDisplayPlugin::activate(container);
}
void OculusWin32DisplayPlugin::customizeWindow(PluginContainer * container) {
container->getAppMainWindow()->setCentralWidget(QWidget::createWindowContainer(_window));
}
void OculusWin32DisplayPlugin::customizeContext(PluginContainer * container) {
}
void OculusWin32DisplayPlugin::deactivate() {
ovrHmd_Destroy(_hmd);
_hmd = nullptr;
ovr_Shutdown();
}
void OculusWin32DisplayPlugin::display(
GLuint sceneTexture, const glm::uvec2& sceneSize,
GLuint overlayTexture, const glm::uvec2& overlaySize) {
glClearColor(0, 1, 0, 1);
glClear(GL_COLOR_BUFFER_BIT);
}
#if 0
// A basic wrapper for constructing a framebuffer with a renderbuffer
// for the depth attachment and an undefined type for the color attachement
// This allows us to reuse the basic framebuffer code for both the Mirror
@ -81,10 +36,10 @@ void OculusWin32DisplayPlugin::display(
// the screen.
template <typename C = GLuint, typename D = GLuint>
struct FramebufferWrapper {
uvec2 size;
oglplus::Framebuffer fbo;
uvec2 size;
Framebuffer fbo;
C color{ 0 };
GLuint depth{ 0 };
D depth{ 0 };
virtual ~FramebufferWrapper() {
}
@ -93,9 +48,6 @@ struct FramebufferWrapper {
virtual void Init(const uvec2 & size) {
this->size = size;
if (!fbo) {
glGenFramebuffers(1, &fbo);
}
initColor();
initDepth();
initDone();
@ -108,7 +60,7 @@ struct FramebufferWrapper {
template <typename F>
void Bound(GLenum target, F f) {
glBindFramebuffer(target, fbo);
glBindFramebuffer(target, oglplus::GetName(fbo));
onBind(target);
f();
onUnbind(target);
@ -152,10 +104,11 @@ struct RiftFramebufferWrapper : public FramebufferWrapper<C> {
// then submit it and increment to the next texture.
// The Oculus SDK manages the creation and destruction of
// the textures
struct SwapTextureFramebufferWrapper : public RiftFramebufferWrapper<ovrSwapTextureSet*>{
SwapTextureFramebufferWrapper(const ovrHmd & hmd)
: RiftFramebufferWrapper(hmd) {}
~SwapTextureFramebufferWrapper() {
struct SwapFramebufferWrapper : public RiftFramebufferWrapper<ovrSwapTextureSet*> {
SwapFramebufferWrapper(const ovrHmd & hmd)
: RiftFramebufferWrapper(hmd) {
}
~SwapFramebufferWrapper() {
if (color) {
ovrHmd_DestroySwapTextureSet(hmd, color);
color = nullptr;
@ -175,7 +128,7 @@ protected:
}
if (!OVR_SUCCESS(ovrHmd_CreateSwapTextureSetGL(hmd, GL_RGBA, size.x, size.y, &color))) {
FAIL("Unable to create swap textures");
qFatal("Unable to create swap textures");
}
for (int i = 0; i < color->TextureCount; ++i) {
@ -190,9 +143,9 @@ protected:
}
virtual void initDone() {
glBindFramebuffer(GL_FRAMEBUFFER, fbo);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depth);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, oglplus::GetName(fbo));
glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depth);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
}
virtual void onBind(GLenum target) {
@ -205,14 +158,14 @@ protected:
}
};
using SwapTexFboPtr = std::shared_ptr<SwapTextureFramebufferWrapper>;
// We use a FBO to wrap the mirror texture because it makes it easier to
// render to the screen via glBlitFramebuffer
struct MirrorFramebufferWrapper : public RiftFramebufferWrapper<ovrGLTexture*>{
struct MirrorFramebufferWrapper : public RiftFramebufferWrapper<ovrGLTexture*> {
float targetAspect;
MirrorFramebufferWrapper(const ovrHmd & hmd)
: RiftFramebufferWrapper(hmd) {}
: RiftFramebufferWrapper(hmd) {
}
~MirrorFramebufferWrapper() {
if (color) {
ovrHmd_DestroyMirrorTexture(hmd, (ovrTexture*)color);
@ -221,13 +174,14 @@ struct MirrorFramebufferWrapper : public RiftFramebufferWrapper<ovrGLTexture*>{
}
void Resize(const uvec2 & size) {
glBindFramebuffer(GL_FRAMEBUFFER, fbo);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, oglplus::GetName(fbo));
glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
this->size = size;
initColor();
initDone();
}
private:
virtual void initDepth() {
}
@ -238,16 +192,163 @@ private:
color = nullptr;
}
ovrResult result = ovrHmd_CreateMirrorTextureGL(hmd, GL_RGBA, size.x, size.y, (ovrTexture**)&color);
assert(OVR_SUCCESS(result));
Q_ASSERT(OVR_SUCCESS(result));
}
void initDone() {
glBindFramebuffer(GL_FRAMEBUFFER, fbo);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, color->OGL.TexId, 0);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, oglplus::GetName(fbo));
glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, color->OGL.TexId, 0);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
}
};
using MirrorFboPtr = std::shared_ptr<MirrorFramebufferWrapper>;
#endif
const QString OculusWin32DisplayPlugin::NAME("Oculus Rift");
const QString & OculusWin32DisplayPlugin::getName() {
return NAME;
}
bool OculusWin32DisplayPlugin::isSupported() {
if (!OVR_SUCCESS(ovr_Initialize(nullptr))) {
return false;
}
bool result = false;
if (ovrHmd_Detect() > 0) {
result = true;
}
ovr_Shutdown();
return result;
}
void OculusWin32DisplayPlugin::activate(PluginContainer * container) {
if (!OVR_SUCCESS(ovr_Initialize(nullptr))) {
Q_ASSERT(false);
qFatal("Failed to Initialize SDK");
}
if (!OVR_SUCCESS(ovrHmd_Create(0, &_hmd))) {
Q_ASSERT(false);
qFatal("Failed to acquire HMD");
}
// Parent class relies on our _hmd intialization, so it must come after that.
OculusBaseDisplayPlugin::activate(container);
_layer.Header.Type = ovrLayerType_EyeFov;
_layer.Header.Flags = ovrLayerFlag_TextureOriginAtBottomLeft;
ovr_for_each_eye([&](ovrEyeType eye) {
ovrFovPort & fov = _layer.Fov[eye] = _eyeRenderDescs[eye].Fov;
ovrSizei & size = _layer.Viewport[eye].Size = ovrHmd_GetFovTextureSize(_hmd, eye, fov, 1.0f);
_layer.Viewport[eye].Pos = { eye == ovrEye_Left ? 0 : size.w, 0 };
});
}
void OculusWin32DisplayPlugin::customizeContext(PluginContainer * container) {
OculusBaseDisplayPlugin::customizeContext(container);
wglSwapIntervalEXT(0);
uvec2 mirrorSize = toGlm(_widget->geometry().size());
_mirrorFbo = MirrorFboPtr(new MirrorFramebufferWrapper(_hmd));
_mirrorFbo->Init(mirrorSize);
_swapFbo = SwapFboPtr(new SwapFramebufferWrapper(_hmd));
uvec2 swapSize = toGlm(getRecommendedFramebufferSize());
_swapFbo->Init(swapSize);
}
void OculusWin32DisplayPlugin::deactivate() {
makeCurrent();
_swapFbo.reset();
_mirrorFbo.reset();
// doneCurrent();
OculusBaseDisplayPlugin::deactivate();
ovrHmd_Destroy(_hmd);
_hmd = nullptr;
ovr_Shutdown();
}
void OculusWin32DisplayPlugin::display(
GLuint sceneTexture, const glm::uvec2& sceneSize,
GLuint overlayTexture, const glm::uvec2& overlaySize) {
using namespace oglplus;
//Context::Viewport(_mirrorFbo->size.x, _mirrorFbo->size.y);
//glClearColor(0, 0, 1, 1);
//Context::Clear().ColorBuffer().DepthBuffer();
//_program->Bind();
//Mat4Uniform(*_program, "ModelView").Set(mat4());
//Mat4Uniform(*_program, "Projection").Set(mat4());
//glBindTexture(GL_TEXTURE_2D, sceneTexture);
//_plane->Use();
//_plane->Draw();
_swapFbo->Bound([&] {
Q_ASSERT(0 == glGetError());
using namespace oglplus;
Context::Viewport(_swapFbo->size.x, _swapFbo->size.y);
glClearColor(0, 0, 1, 1);
Context::Clear().ColorBuffer().DepthBuffer();
_program->Bind();
Mat4Uniform(*_program, "ModelView").Set(mat4());
Mat4Uniform(*_program, "Projection").Set(mat4());
glBindTexture(GL_TEXTURE_2D, sceneTexture);
_plane->Use();
_plane->Draw();
/*
Context::Enable(Capability::Blend);
glBindTexture(GL_TEXTURE_2D, overlayTexture);
_plane->Draw();
Context::Disable(Capability::Blend);
*/
glBindTexture(GL_TEXTURE_2D, 0);
Q_ASSERT(0 == glGetError());
});
_swapFbo->Bound(GL_READ_FRAMEBUFFER, [&] {
glBlitFramebuffer(
0, 0, _swapFbo->size.x, _swapFbo->size.y,
0, 0, _mirrorFbo->size.x, _mirrorFbo->size.y,
GL_COLOR_BUFFER_BIT, GL_NEAREST);
});
ovr_for_each_eye([&](ovrEyeType eye){
_layer.RenderPose[eye] = _eyePoses[eye];
});
_layer.ColorTexture[0] = _swapFbo->color;
_layer.ColorTexture[1] = nullptr;
ovrLayerHeader* layers = &_layer.Header;
ovrResult result = ovrHmd_SubmitFrame(_hmd, _frameIndex, nullptr, &layers, 1);
_swapFbo->Increment();
wglSwapIntervalEXT(0);
auto mirrorSize = toGlm(getDeviceSize());
Context::Viewport(mirrorSize.x, mirrorSize.y);
_mirrorFbo->Bound(GL_READ_FRAMEBUFFER, [&] {
glBlitFramebuffer(
0, _mirrorFbo->size.y, _mirrorFbo->size.x, 0,
0, 0, _mirrorFbo->size.x, _mirrorFbo->size.y,
GL_COLOR_BUFFER_BIT, GL_NEAREST);
});
}
// Pressing Alt (and Meta) key alone activates the menubar because its style inherits the
// SHMenuBarAltKeyNavigation from QWindowsStyle. This makes it impossible for a scripts to
// receive keyPress events for the Alt (and Meta) key in a reliable manner.
//
// This filter catches events before QMenuBar can steal the keyboard focus.
// The idea was borrowed from
// http://www.archivum.info/qt-interest@trolltech.com/2006-09/00053/Re-(Qt4)-Alt-key-focus-QMenuBar-(solved).html
// Pass input events on to the application
bool OculusWin32DisplayPlugin::eventFilter(QObject* receiver, QEvent* event) {
if (event->type() == QEvent::Resize) {
QResizeEvent* resizeEvent = static_cast<QResizeEvent*>(event);
qDebug() << resizeEvent->size().width() << " x " << resizeEvent->size().height();
auto newSize = toGlm(resizeEvent->size());
makeCurrent();
_mirrorFbo->Resize(newSize);
doneCurrent();
}
return OculusBaseDisplayPlugin::eventFilter(receiver, event);
}
void OculusWin32DisplayPlugin::swapBuffers() {
}

43
libraries/display-plugins/src/display-plugins/oculus/OculusWin32DisplayPlugin.h Normal file
View file

@ -0,0 +1,43 @@
//
// Created by Bradley Austin Davis on 2015/05/29
// Copyright 2015 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#pragma once
#include "OculusBaseDisplayPlugin.h"
#include <QTimer>
class OffscreenGlCanvas;
class MirrorFramebufferWrapper;
class SwapFramebufferWrapper;
using SwapFboPtr = QSharedPointer<SwapFramebufferWrapper>;
using MirrorFboPtr = QSharedPointer<MirrorFramebufferWrapper>;
class OculusWin32DisplayPlugin : public OculusBaseDisplayPlugin {
public:
virtual bool isSupported();
virtual const QString & getName();
virtual void activate(PluginContainer * container) override;
virtual void deactivate() override;
virtual void display(GLuint sceneTexture, const glm::uvec2& sceneSize,
GLuint overlayTexture, const glm::uvec2& overlaySize) override;
virtual bool eventFilter(QObject* receiver, QEvent* event) override;
protected:
virtual void customizeContext(PluginContainer * container) override;
virtual void swapBuffers() override;
private:
static const QString NAME;
SwapFboPtr _swapFbo;
MirrorFboPtr _mirrorFbo;
ovrLayerEyeFov _layer;
};

38
libraries/display-plugins/src/display-plugins/stereo/InterleavedStereoDisplayPlugin.cpp Normal file
View file

@ -0,0 +1,38 @@
//
// Created by Bradley Austin Davis on 2015/05/29
// Copyright 2015 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#include "InterleavedStereoDisplayPlugin.h"
#include <QApplication>
#include <QDesktopWidget>
#include <GlWindow.h>
#include <ViewFrustum.h>
#include <MatrixStack.h>
#include <gpu/GLBackend.h>
const QString InterleavedStereoDisplayPlugin::NAME("Interleaved Stereo Display");
const QString & InterleavedStereoDisplayPlugin::getName() {
return NAME;
}
InterleavedStereoDisplayPlugin::InterleavedStereoDisplayPlugin() {
}
void InterleavedStereoDisplayPlugin::display(
GLuint sceneTexture, const glm::uvec2& sceneSize,
GLuint overlayTexture, const glm::uvec2& overlaySize) {
}
void InterleavedStereoDisplayPlugin::customizeContext(PluginContainer * container) {
StereoDisplayPlugin::customizeContext(container);
// Set up the stencil buffers
}

26
libraries/display-plugins/src/display-plugins/stereo/InterleavedStereoDisplayPlugin.h Normal file
View file

@ -0,0 +1,26 @@
//
// Created by Bradley Austin Davis on 2015/05/29
// Copyright 2015 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#pragma once
#include "StereoDisplayPlugin.h"
class InterleavedStereoDisplayPlugin : public StereoDisplayPlugin {
Q_OBJECT
public:
InterleavedStereoDisplayPlugin();
virtual const QString & getName() override;
virtual void display(GLuint sceneTexture, const glm::uvec2& sceneSize,
GLuint overlayTexture, const glm::uvec2& overlaySize) override;
// initialize OpenGL context settings needed by the plugin
virtual void customizeContext(PluginContainer * container) override;
private:
static const QString NAME;
};

108
libraries/display-plugins/src/display-plugins/stereo/SideBySideStereoDisplayPlugin.cpp Normal file
View file

@ -0,0 +1,108 @@
//
// Created by Bradley Austin Davis on 2015/05/29
// Copyright 2015 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#include "SideBySideStereoDisplayPlugin.h"
#include <QApplication>
#include <QDesktopWidget>
#include <GlWindow.h>
#include <ViewFrustum.h>
#include <MatrixStack.h>
#include <gpu/GLBackend.h>
const QString SideBySideStereoDisplayPlugin::NAME("SBS Stereo Display");
const QString & SideBySideStereoDisplayPlugin::getName() {
return NAME;
}
SideBySideStereoDisplayPlugin::SideBySideStereoDisplayPlugin() {
}
template <typename F>
void sbs_for_each_eye(const uvec2& size, F f) {
QRect r(QPoint(0, 0), QSize(size.x / 2, size.y));
for_each_eye([&](Eye eye) {
oglplus::Context::Viewport(r.x(), r.y(), r.width(), r.height());
f(eye);
}, [&] {
r.moveLeft(r.width());
});
}
void SideBySideStereoDisplayPlugin::display(
GLuint sceneTexture, const glm::uvec2& sceneSize,
GLuint overlayTexture, const glm::uvec2& overlaySize) {
makeCurrent();
Q_ASSERT(0 == glGetError());
uvec2 size = toGlm(getDeviceSize());
using namespace oglplus;
Context::Viewport(size.x, size.y);
Context::Clear().ColorBuffer();
_program->Bind();
Mat4Uniform(*_program, "ModelView").Set(mat4());
Mat4Uniform(*_program, "Projection").Set(mat4());
glBindTexture(GL_TEXTURE_2D, sceneTexture);
_plane->Use();
_plane->Draw();
// FIXME the
const float screenAspect = aspect(size);
const GLfloat distance = 1.0f;
const GLfloat halfQuadHeight = distance * tan(DEFAULT_FIELD_OF_VIEW_DEGREES);
const GLfloat halfQuadWidth = halfQuadHeight * screenAspect;
const GLfloat quadWidth = halfQuadWidth * 2.0f;
const GLfloat quadHeight = halfQuadHeight * 2.0f;
vec3 quadSize(quadWidth, quadHeight, 1.0f);
quadSize = vec3(1.0f) / quadSize;
using namespace oglplus;
Context::Enable(Capability::Blend);
glBindTexture(GL_TEXTURE_2D, overlayTexture);
mat4 pr = glm::perspective(glm::radians(DEFAULT_FIELD_OF_VIEW_DEGREES), screenAspect, DEFAULT_NEAR_CLIP, DEFAULT_FAR_CLIP);
Mat4Uniform(*_program, "Projection").Set(pr);
// Position the camera relative to the overlay texture
MatrixStack mv;
mv.translate(vec3(0, 0, -distance)).scale(vec3(0.7f, 0.7f / screenAspect, 1.0f)); // .scale(vec3(quadWidth, quadHeight, 1.0));
sbs_for_each_eye(size, [&](Eye eye) {
mv.withPush([&] {
// translate
mv.top() = getModelview(eye, mv.top());
Mat4Uniform(*_program, "ModelView").Set(mv.top());
_plane->Draw();
});
});
glBindTexture(GL_TEXTURE_2D, gpu::GLBackend::getTextureID(_crosshairTexture));
glm::vec2 canvasSize = getCanvasSize();
glm::vec2 mouse = toGlm(_window->mapFromGlobal(QCursor::pos()));
mouse /= canvasSize;
mouse *= 2.0f;
mouse -= 1.0f;
mouse.y *= -1.0f;
sbs_for_each_eye(size, [&](Eye eye) {
mv.withPush([&] {
// translate
mv.top() = getModelview(eye, mv.top());
mv.translate(mouse);
//mv.scale(0.05f);
mv.scale(vec3(0.025f, 0.05f, 1.0f));
Mat4Uniform(*_program, "ModelView").Set(mv.top());
_plane->Draw();
});
});
Context::Disable(Capability::Blend);
}

22
libraries/display-plugins/src/display-plugins/stereo/SideBySideStereoDisplayPlugin.h Normal file
View file

@ -0,0 +1,22 @@
//
// Created by Bradley Austin Davis on 2015/05/29
// Copyright 2015 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#pragma once
#include "StereoDisplayPlugin.h"
class SideBySideStereoDisplayPlugin : public StereoDisplayPlugin {
Q_OBJECT
public:
SideBySideStereoDisplayPlugin();
virtual const QString & getName() override;
void display(GLuint sceneTexture, const glm::uvec2& sceneSize,
GLuint overlayTexture, const glm::uvec2& overlaySize) override;
private:
static const QString NAME;
};

77
libraries/display-plugins/src/display-plugins/stereo/StereoDisplayPlugin.cpp Normal file
View file

@ -0,0 +1,77 @@
//
// Created by Bradley Austin Davis on 2015/05/29
// Copyright 2015 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#include "StereoDisplayPlugin.h"
#include <QApplication>
#include <QDesktopWidget>
#include <GlWindow.h>
#include <ViewFrustum.h>
#include <MatrixStack.h>
#include <gpu/GLBackend.h>
StereoDisplayPlugin::StereoDisplayPlugin() {
}
bool StereoDisplayPlugin::isSupported() const {
// FIXME this should attempt to do a scan for supported 3D output
return true;
}
void StereoDisplayPlugin::customizeWindow(PluginContainer * container) {
_window->setFlags(Qt::FramelessWindowHint);
auto desktop = QApplication::desktop();
QRect primaryGeometry = desktop->screenGeometry();
for (int i = 0; i < desktop->screenCount(); ++i) {
QRect geometry = desktop->screen(i)->geometry();
if (geometry.topLeft() == primaryGeometry.topLeft()) {
continue;
}
float aspect = (float)geometry.width() / (float)geometry.height();
if (aspect < 1.0f) {
continue;
}
_window->setGeometry(geometry);
break;
}
_window->setCursor(Qt::BlankCursor);
_window->show();
}
// FIXME make this into a setting that can be adjusted
const float DEFAULT_IPD = 0.064f;
const float HALF_DEFAULT_IPD = DEFAULT_IPD / 2.0f;
glm::mat4 StereoDisplayPlugin::getProjection(Eye eye, const glm::mat4& baseProjection) const {
// Refer to http://www.nvidia.com/content/gtc-2010/pdfs/2010_gtc2010.pdf on creating
// stereo projection matrices. Do NOT use "toe-in", use translation.
float nearZ = DEFAULT_NEAR_CLIP; // near clipping plane
float screenZ = 0.25f; // screen projection plane
// FIXME verify this is the right calculation
float frustumshift = HALF_DEFAULT_IPD * nearZ / screenZ;
if (eye == Right) {
frustumshift = -frustumshift;
}
return glm::translate(baseProjection, vec3(frustumshift, 0, 0));
}
glm::mat4 StereoDisplayPlugin::getModelview(Eye eye, const glm::mat4& baseModelview) const {
float modelviewShift = HALF_DEFAULT_IPD;
if (eye == Left) {
modelviewShift = -modelviewShift;
}
return baseModelview * glm::translate(mat4(), vec3(modelviewShift, 0, 0));
}
void StereoDisplayPlugin::activate(PluginContainer * container) {
WindowOpenGLDisplayPlugin::activate(container);
// FIXME Add menu items
}

26
libraries/display-plugins/src/display-plugins/stereo/StereoDisplayPlugin.h Normal file
View file

@ -0,0 +1,26 @@
//
// Created by Bradley Austin Davis on 2015/05/29
// Copyright 2015 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#pragma once
#include "../WindowOpenGLDisplayPlugin.h"
class StereoDisplayPlugin : public WindowOpenGLDisplayPlugin {
Q_OBJECT
public:
StereoDisplayPlugin();
virtual bool isStereo() const override final { return true; }
virtual bool isSupported() const override final;
virtual void activate(PluginContainer * container) override;
virtual glm::mat4 getProjection(Eye eye, const glm::mat4& baseProjection) const override;
virtual glm::mat4 getModelview(Eye eye, const glm::mat4& baseModelview) const override;
protected:
virtual void customizeWindow(PluginContainer * container) override;
};

10
libraries/render-utils/src/GlWindow.cpp
View file

@ -40,8 +40,11 @@ GlWindow::~GlWindow() {
}
void GlWindow::makeCurrent() {
_context->makeCurrent(this);
bool GlWindow::makeCurrent() {
bool makeCurrentResult = _context->makeCurrent(this);
Q_ASSERT(makeCurrentResult);
QOpenGLContext * currentContext = QOpenGLContext::currentContext();
Q_ASSERT(_context == currentContext);
#ifdef DEBUG
if (!_logger) {
_logger = new QOpenGLDebugLogger(this);
@ -52,11 +55,12 @@ void GlWindow::makeCurrent() {
}
qDebug() << message;
});
_logger->disableMessages(QOpenGLDebugMessage::AnySource, QOpenGLDebugMessage::AnyType, QOpenGLDebugMessage::NotificationSeverity);
//_logger->disableMessages(QOpenGLDebugMessage::AnySource, QOpenGLDebugMessage::AnyType, QOpenGLDebugMessage::NotificationSeverity);
_logger->startLogging(QOpenGLDebugLogger::LoggingMode::SynchronousLogging);
}
}
#endif
return makeCurrentResult;
}
void GlWindow::doneCurrent() {

5
libraries/render-utils/src/GlWindow.h
View file

@ -20,11 +20,12 @@ public:
GlWindow(QOpenGLContext* shareContext = nullptr);
GlWindow(const QSurfaceFormat& format, QOpenGLContext* shareContext = nullptr);
virtual ~GlWindow();
void makeCurrent();
bool makeCurrent();
void doneCurrent();
void swapBuffers();
private:
QOpenGLContext* _context{ nullptr };
private:
#ifdef DEBUG
QOpenGLDebugLogger* _logger{ nullptr };
#endif