Merge remote-tracking branch 'upstream/master' into menu

interface/CMakeLists.txt

@@ -45,6 +45,12 @@ endforeach(SUBDIR)
 # project subdirectories
 add_subdirectory(src/starfield)
 
+find_package(Qt5Core REQUIRED)
+find_package(Qt5Gui REQUIRED)
+find_package(Qt5Network REQUIRED)
+find_package(Qt5OpenGL REQUIRED)
+find_package(Qt5Svg REQUIRED)
+
 if (APPLE)
   # set how the icon shows up in the Info.plist file
   SET(MACOSX_BUNDLE_ICON_FILE interface.icns) 
@@ -64,15 +70,8 @@ if (APPLE)
       SET(INTERFACE_SRCS ${INTERFACE_SRCS} ${DIR_CONTENTS})
     endif()    
   endforeach()  
-  
 endif (APPLE)
 
-find_package(Qt5Core REQUIRED)
-find_package(Qt5Gui REQUIRED)
-find_package(Qt5Network REQUIRED)
-find_package(Qt5OpenGL REQUIRED)
-find_package(Qt5Svg REQUIRED)
-
 set(QUAZIP_ROOT_DIR ${CMAKE_CURRENT_SOURCE_DIR}/external/quazip)
 add_subdirectory(external/fervor/)
 include_directories(external/fervor/)
@@ -101,12 +100,12 @@ find_package(UVCCameraControl)
 find_package(ZLIB)
 
 # let the source know that we have OpenNI/NITE for Kinect
-if (OPENNI_FOUND)
+if (OPENNI_FOUND AND NOT DISABLE_OPENNI)
     add_definitions(-DHAVE_OPENNI)
     include_directories(SYSTEM ${OPENNI_INCLUDE_DIRS})
     SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -isystem ${OPENNI_INCLUDE_DIRS}")
     target_link_libraries(${TARGET_NAME} ${OPENNI_LIBRARIES})
-endif (OPENNI_FOUND)
+endif (OPENNI_FOUND AND NOT DISABLE_OPENNI)
 
 qt5_use_modules(${TARGET_NAME} Core Gui Network OpenGL Svg)
 

interface/resources/shaders/diffuse.frag

@@ -0,0 +1,28 @@
+#version 120
+
+//
+//  diffuse.frag
+//  fragment shader
+//
+//  Created by Andrzej Kapolka on 8/14/13.
+//  Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
+//
+
+// the texture containing the original color
+uniform sampler2D originalTexture;
+
+// the texture containing the diffused color
+uniform sampler2D diffusedTexture;
+
+void main(void) {
+    float ds = dFdx(gl_TexCoord[0].s);
+    float dt = dFdy(gl_TexCoord[0].t);
+    gl_FragColor = (texture2D(diffusedTexture, gl_TexCoord[0].st + vec2(-ds, -dt)) +
+        texture2D(diffusedTexture, gl_TexCoord[0].st + vec2(0.0, -dt)) +
+        texture2D(diffusedTexture, gl_TexCoord[0].st + vec2(ds, -dt)) +
+        texture2D(diffusedTexture, gl_TexCoord[0].st + vec2(ds, 0.0)) +
+        texture2D(diffusedTexture, gl_TexCoord[0].st + vec2(ds, dt)) +
+        texture2D(diffusedTexture, gl_TexCoord[0].st + vec2(0.0, dt)) +
+        texture2D(diffusedTexture, gl_TexCoord[0].st + vec2(-ds, dt)) +
+        texture2D(diffusedTexture, gl_TexCoord[0].st + vec2(-ds, 0.0))) / 8.5 + texture2D(originalTexture, gl_TexCoord[0].st) * 0.1;
+}

interface/resources/shaders/glow_add.frag

@@ -0,0 +1,17 @@
+#version 120
+
+//
+//  glow_add.frag
+//  fragment shader
+//
+//  Created by Andrzej Kapolka on 8/14/13.
+//  Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
+//
+
+// the texture containing the original color
+uniform sampler2D originalTexture;
+
+void main(void) {
+    vec4 color = texture2D(originalTexture, gl_TexCoord[0].st);
+    gl_FragColor = color * (1.0 + color.a);
+}

interface/resources/shaders/glow_add_separate.frag

@@ -0,0 +1,20 @@
+#version 120
+
+//
+//  glow_add_separate.frag
+//  fragment shader
+//
+//  Created by Andrzej Kapolka on 8/14/13.
+//  Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
+//
+
+// the texture containing the original color
+uniform sampler2D originalTexture;
+
+// the texture containing the blurred color
+uniform sampler2D blurredTexture;
+
+void main(void) {
+    vec4 blurred = texture2D(blurredTexture, gl_TexCoord[0].st);
+    gl_FragColor = blurred * blurred.a + texture2D(originalTexture, gl_TexCoord[0].st) * (1.0 + blurred.a * 0.5);
+}

interface/resources/shaders/vertical_blur.frag

@@ -4,25 +4,21 @@
 //  vertical_blur.frag
 //  fragment shader
 //
-//  Created by Andrzej Kapolka on 8/8/13.
+//  Created by Andrzej Kapolka on 8/14/13.
 //  Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
 //
 
-// the texture containing the original color
-uniform sampler2D originalTexture;
-
 // the texture containing the horizontally blurred color
-uniform sampler2D horizontallyBlurredTexture;
+uniform sampler2D originalTexture;
 
 void main(void) {
     float dt = dFdy(gl_TexCoord[0].t);
-    vec4 blurred = (texture2D(horizontallyBlurredTexture, gl_TexCoord[0].st + vec2(0.0, dt * -7.5)) +
-        texture2D(horizontallyBlurredTexture, gl_TexCoord[0].st + vec2(0.0, dt * -5.5)) +
-        texture2D(horizontallyBlurredTexture, gl_TexCoord[0].st + vec2(0.0, dt * -3.5)) +
-        texture2D(horizontallyBlurredTexture, gl_TexCoord[0].st + vec2(0.0, dt * -1.5)) +
-        texture2D(horizontallyBlurredTexture, gl_TexCoord[0].st + vec2(0.0, dt * 1.5)) +
-        texture2D(horizontallyBlurredTexture, gl_TexCoord[0].st + vec2(0.0, dt * 3.5)) +
-        texture2D(horizontallyBlurredTexture, gl_TexCoord[0].st + vec2(0.0, dt * 5.5)) +
-        texture2D(horizontallyBlurredTexture, gl_TexCoord[0].st + vec2(0.0, dt * 7.5))) / 8.0;
-    gl_FragColor = blurred * blurred.a + texture2D(originalTexture, gl_TexCoord[0].st) * (1.0 + blurred.a * 0.5);
+    gl_FragColor = (texture2D(originalTexture, gl_TexCoord[0].st + vec2(0.0, dt * -7.5)) +
+        texture2D(originalTexture, gl_TexCoord[0].st + vec2(0.0, dt * -5.5)) +
+        texture2D(originalTexture, gl_TexCoord[0].st + vec2(0.0, dt * -3.5)) +
+        texture2D(originalTexture, gl_TexCoord[0].st + vec2(0.0, dt * -1.5)) +
+        texture2D(originalTexture, gl_TexCoord[0].st + vec2(0.0, dt * 1.5)) +
+        texture2D(originalTexture, gl_TexCoord[0].st + vec2(0.0, dt * 3.5)) +
+        texture2D(originalTexture, gl_TexCoord[0].st + vec2(0.0, dt * 5.5)) +
+        texture2D(originalTexture, gl_TexCoord[0].st + vec2(0.0, dt * 7.5))) / 8.0;
 }

interface/resources/shaders/vertical_blur_add.frag

@@ -0,0 +1,28 @@
+#version 120
+
+//
+//  vertical_blur_add.frag
+//  fragment shader
+//
+//  Created by Andrzej Kapolka on 8/8/13.
+//  Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
+//
+
+// the texture containing the original color
+uniform sampler2D originalTexture;
+
+// the texture containing the horizontally blurred color
+uniform sampler2D horizontallyBlurredTexture;
+
+void main(void) {
+    float dt = dFdy(gl_TexCoord[0].t);
+    vec4 blurred = (texture2D(horizontallyBlurredTexture, gl_TexCoord[0].st + vec2(0.0, dt * -7.5)) +
+        texture2D(horizontallyBlurredTexture, gl_TexCoord[0].st + vec2(0.0, dt * -5.5)) +
+        texture2D(horizontallyBlurredTexture, gl_TexCoord[0].st + vec2(0.0, dt * -3.5)) +
+        texture2D(horizontallyBlurredTexture, gl_TexCoord[0].st + vec2(0.0, dt * -1.5)) +
+        texture2D(horizontallyBlurredTexture, gl_TexCoord[0].st + vec2(0.0, dt * 1.5)) +
+        texture2D(horizontallyBlurredTexture, gl_TexCoord[0].st + vec2(0.0, dt * 3.5)) +
+        texture2D(horizontallyBlurredTexture, gl_TexCoord[0].st + vec2(0.0, dt * 5.5)) +
+        texture2D(horizontallyBlurredTexture, gl_TexCoord[0].st + vec2(0.0, dt * 7.5))) / 8.0;
+    gl_FragColor = blurred * blurred.a + texture2D(originalTexture, gl_TexCoord[0].st) * (1.0 + blurred.a * 0.5);
+}

interface/src/Application.cpp

@@ -1928,17 +1928,20 @@ void Application::updateAvatar(float deltaTime) {
         _headMouseY = min(_headMouseY, _glWidget->height());
 
         const float MIDPOINT_OF_SCREEN = 0.5;
-
-        // Set lookAtPosition if an avatar is at the center of the screen
-        glm::vec3 screenCenterRayOrigin, screenCenterRayDirection;
-        _viewFrustum.computePickRay(MIDPOINT_OF_SCREEN, MIDPOINT_OF_SCREEN, screenCenterRayOrigin, screenCenterRayDirection);
-
-        glm::vec3 eyePosition;
         
-        _isLookingAtOtherAvatar = isLookingAtOtherAvatar(screenCenterRayOrigin, screenCenterRayDirection, eyePosition);
-        if (_isLookingAtOtherAvatar) {
-            glm::vec3 myLookAtFromMouse(eyePosition);
-            _myAvatar.getHead().setLookAtPosition(myLookAtFromMouse);
+        // Only use gyro to set lookAt if mouse hasn't selected an avatar
+        if (!_isLookingAtOtherAvatar) {
+
+            // Set lookAtPosition if an avatar is at the center of the screen
+            glm::vec3 screenCenterRayOrigin, screenCenterRayDirection;
+            _viewFrustum.computePickRay(MIDPOINT_OF_SCREEN, MIDPOINT_OF_SCREEN, screenCenterRayOrigin, screenCenterRayDirection);
+
+            glm::vec3 eyePosition;
+            _isLookingAtOtherAvatar = isLookingAtOtherAvatar(screenCenterRayOrigin, screenCenterRayDirection, eyePosition);
+            if (_isLookingAtOtherAvatar) {
+                glm::vec3 myLookAtFromMouse(eyePosition);
+                _myAvatar.getHead().setLookAtPosition(myLookAtFromMouse);
+            }
         }
 
     }
@@ -2343,6 +2346,7 @@ void Application::displaySide(Camera& whichCamera) {
                 if (!avatar->isInitialized()) {
                     avatar->init();
                 }
+                // Set lookAt to myCamera on client side if other avatars are looking at client
                 if (isLookingAtMyAvatar(avatar)) {
                     avatar->getHead().setLookAtPosition(_myCamera.getPosition());
                 }
@@ -3292,4 +3296,4 @@ void* Application::networkReceive(void* args) {
         pthread_exit(0); 
     }
     return NULL; 
-}
+}

interface/src/main.cpp

@@ -18,12 +18,19 @@
 #include "Application.h"
 
 #include <QDebug>
+#include <QDir>
 
 int main(int argc, const char * argv[]) {
     timeval startup_time;
     gettimeofday(&startup_time, NULL);
     
+    #if defined(Q_OS_MAC)
+    const QString QT_RELEASE_PLUGIN_PATH = "/usr/local/lib/qt5/plugins"; 
+    QCoreApplication::addLibraryPath(QT_RELEASE_PLUGIN_PATH);
+    #endif
+
     Application app(argc, const_cast<char**>(argv), startup_time);
+    
     qDebug( "Created QT Application.\n" );
     int exitCode = app.exec();
     qDebug("Normal exit.\n");

interface/src/renderer/GlowEffect.cpp

@@ -14,9 +14,12 @@
 #include "GlowEffect.h"
 #include "ProgramObject.h"
 
-static ProgramObject* createBlurProgram(const QString& direction) {
+GlowEffect::GlowEffect() : _renderMode(BLUR_ADD_MODE) {
+}
+
+static ProgramObject* createProgram(const QString& name) {
     ProgramObject* program = new ProgramObject();
-    program->addShaderFromSourceFile(QGLShader::Fragment, "resources/shaders/" + direction + "_blur.frag");
+    program->addShaderFromSourceFile(QGLShader::Fragment, "resources/shaders/" + name + ".frag");
     program->link();
     
     program->bind();
@@ -28,12 +31,25 @@ static ProgramObject* createBlurProgram(const QString& direction) {
 
 void GlowEffect::init() {
     switchToResourcesParentIfRequired();
-    _horizontalBlurProgram = createBlurProgram("horizontal");
-    _verticalBlurProgram = createBlurProgram("vertical");
     
-    _verticalBlurProgram->bind();
-    _verticalBlurProgram->setUniformValue("horizontallyBlurredTexture", 1);
-    _verticalBlurProgram->release();
+    _addProgram = createProgram("glow_add");
+    _horizontalBlurProgram = createProgram("horizontal_blur");
+    _verticalBlurAddProgram = createProgram("vertical_blur_add");
+    _verticalBlurProgram = createProgram("vertical_blur");
+    _addSeparateProgram = createProgram("glow_add_separate");
+    _diffuseProgram = createProgram("diffuse");
+    
+    _verticalBlurAddProgram->bind();
+    _verticalBlurAddProgram->setUniformValue("horizontallyBlurredTexture", 1);
+    _verticalBlurAddProgram->release();
+    
+    _addSeparateProgram->bind();
+    _addSeparateProgram->setUniformValue("blurredTexture", 1);
+    _addSeparateProgram->release();
+    
+    _diffuseProgram->bind();
+    _diffuseProgram->setUniformValue("diffusedTexture", 1);
+    _diffuseProgram->release();
 }
 
 void GlowEffect::prepare() {
@@ -43,8 +59,8 @@ void GlowEffect::prepare() {
     _isEmpty = true;
 }
 
-void GlowEffect::begin(float amount) {
-    glBlendColor(0.0f, 0.0f, 0.0f, amount);
+void GlowEffect::begin(float intensity) {
+    glBlendColor(0.0f, 0.0f, 0.0f, intensity);
     _isEmpty = false;
 }
 
@@ -93,7 +109,42 @@ void GlowEffect::render() {
             glDisable(GL_TEXTURE_2D);
             glEnable(GL_LIGHTING);
         }
-    } else {
+    } else if (_renderMode == ADD_MODE) {
+        _addProgram->bind();
+        renderFullscreenQuad();
+        _addProgram->release();
+    
+    } else if (_renderMode == DIFFUSE_ADD_MODE) {
+        // diffuse into the secondary/tertiary (alternating between frames)
+        QOpenGLFramebufferObject* oldDiffusedFBO =
+            Application::getInstance()->getTextureCache()->getSecondaryFramebufferObject();
+        QOpenGLFramebufferObject* newDiffusedFBO =
+            Application::getInstance()->getTextureCache()->getTertiaryFramebufferObject();
+        if ((_isOddFrame = !_isOddFrame)) {
+            qSwap(oldDiffusedFBO, newDiffusedFBO);
+        }
+        newDiffusedFBO->bind();
+        
+        glActiveTexture(GL_TEXTURE1);
+        glBindTexture(GL_TEXTURE_2D, oldDiffusedFBO->texture());
+            
+        _diffuseProgram->bind();
+        renderFullscreenQuad();
+        _diffuseProgram->release();
+        
+        newDiffusedFBO->release();
+        
+        // add diffused texture to the primary
+        glBindTexture(GL_TEXTURE_2D, newDiffusedFBO->texture());
+        
+        _addSeparateProgram->bind();      
+        renderFullscreenQuad();
+        _addSeparateProgram->release();
+        
+        glBindTexture(GL_TEXTURE_2D, 0);
+        glActiveTexture(GL_TEXTURE0);
+        
+    } else { // _renderMode == BLUR_ADD_MODE || _renderMode == BLUR_PERSIST_ADD_MODE
         // render the primary to the secondary with the horizontal blur
         QOpenGLFramebufferObject* secondaryFBO =
             Application::getInstance()->getTextureCache()->getSecondaryFramebufferObject();
@@ -105,13 +156,48 @@ void GlowEffect::render() {
      
         secondaryFBO->release();
         
-        // render the secondary to the screen with the vertical blur
-        glActiveTexture(GL_TEXTURE1);
-        glBindTexture(GL_TEXTURE_2D, secondaryFBO->texture());
+        if (_renderMode == BLUR_ADD_MODE) {
+            // render the secondary to the screen with the vertical blur
+            glActiveTexture(GL_TEXTURE1);
+            glBindTexture(GL_TEXTURE_2D, secondaryFBO->texture());
+            
+            _verticalBlurAddProgram->bind();      
+            renderFullscreenQuad();
+            _verticalBlurAddProgram->release();
+            
+        } else { // _renderMode == BLUR_PERSIST_ADD_MODE
+            // render the secondary to the tertiary with horizontal blur and persistence
+            QOpenGLFramebufferObject* tertiaryFBO =
+                Application::getInstance()->getTextureCache()->getTertiaryFramebufferObject();
+            tertiaryFBO->bind();
+            
+            glEnable(GL_BLEND);
+            glBlendFunc(GL_ONE_MINUS_CONSTANT_ALPHA, GL_CONSTANT_ALPHA);
+            const float PERSISTENCE_SMOOTHING = 0.9f;
+            glBlendColor(0.0f, 0.0f, 0.0f, PERSISTENCE_SMOOTHING);
+            
+            glBindTexture(GL_TEXTURE_2D, secondaryFBO->texture());
+            
+            _verticalBlurProgram->bind();      
+            renderFullscreenQuad();
+            _verticalBlurProgram->release();
         
-        _verticalBlurProgram->bind();      
-        renderFullscreenQuad();
-        _verticalBlurProgram->release();
+            glBlendColor(0.0f, 0.0f, 0.0f, 0.0f);
+            glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_CONSTANT_ALPHA, GL_ONE);
+            glDisable(GL_BLEND);
+        
+            // now add the tertiary to the primary buffer
+            tertiaryFBO->release();
+            
+            glBindTexture(GL_TEXTURE_2D, primaryFBO->texture());
+            
+            glActiveTexture(GL_TEXTURE1);
+            glBindTexture(GL_TEXTURE_2D, tertiaryFBO->texture());
+            
+            _addSeparateProgram->bind();      
+            renderFullscreenQuad();
+            _addSeparateProgram->release();
+        }
         
         glBindTexture(GL_TEXTURE_2D, 0);
         glActiveTexture(GL_TEXTURE0);
@@ -126,3 +212,7 @@ void GlowEffect::render() {
     glEnable(GL_DEPTH_TEST);
     glBindTexture(GL_TEXTURE_2D, 0);
 }
+
+void GlowEffect::cycleRenderMode() {
+    _renderMode = (RenderMode)((_renderMode + 1) % RENDER_MODE_COUNT);
+}

interface/src/renderer/GlowEffect.h

@@ -9,26 +9,51 @@
 #ifndef __interface__GlowEffect__
 #define __interface__GlowEffect__
 
+#include <QObject>
+
 class ProgramObject;
 
-class GlowEffect {
+/// A generic full screen glow effect.
+class GlowEffect : public QObject {
+    Q_OBJECT
+    
 public:
     
+    GlowEffect();
+    
     void init();
     
+    /// Prepares the glow effect for rendering the current frame.  To be called before rendering the scene.
     void prepare();
     
-    void begin(float amount = 1.0f);
+    /// Starts using the glow effect.
+    /// \param intensity the desired glow intensity, from zero to one
+    void begin(float intensity = 1.0f);
+    
+    /// Stops using the glow effect.
     void end();
     
+    /// Renders the glow effect.  To be called after rendering the scene.
     void render();
 
+public slots:
+    
+    void cycleRenderMode();
+    
 private:
     
-    ProgramObject* _horizontalBlurProgram;
-    ProgramObject* _verticalBlurProgram;
+    enum RenderMode { ADD_MODE, BLUR_ADD_MODE, BLUR_PERSIST_ADD_MODE, DIFFUSE_ADD_MODE, RENDER_MODE_COUNT };
     
-    bool _isEmpty;
+    RenderMode _renderMode;
+    ProgramObject* _addProgram;
+    ProgramObject* _horizontalBlurProgram;
+    ProgramObject* _verticalBlurAddProgram;
+    ProgramObject* _verticalBlurProgram;
+    ProgramObject* _addSeparateProgram;
+    ProgramObject* _diffuseProgram;
+    
+    bool _isEmpty; ///< set when nothing in the scene is currently glowing
+    bool _isOddFrame; ///< controls the alternation between texture targets in diffuse add mode
 };
 
 #endif /* defined(__interface__GlowEffect__) */

interface/src/renderer/TextureCache.cpp

@@ -14,7 +14,7 @@
 #include "TextureCache.h"
 
 TextureCache::TextureCache() : _permutationNormalTextureID(0),
-    _primaryFramebufferObject(NULL), _secondaryFramebufferObject(NULL) {
+    _primaryFramebufferObject(NULL), _secondaryFramebufferObject(NULL), _tertiaryFramebufferObject(NULL) {
 }
 
 TextureCache::~TextureCache() {
@@ -27,6 +27,9 @@ TextureCache::~TextureCache() {
     if (_secondaryFramebufferObject != NULL) {
         delete _secondaryFramebufferObject;
     }
+    if (_tertiaryFramebufferObject != NULL) {
+        delete _tertiaryFramebufferObject;
+    }
 }
 
 GLuint TextureCache::getPermutationNormalTextureID() {
@@ -72,6 +75,14 @@ QOpenGLFramebufferObject* TextureCache::getSecondaryFramebufferObject() {
     return _secondaryFramebufferObject;
 }
 
+QOpenGLFramebufferObject* TextureCache::getTertiaryFramebufferObject() {
+    if (_tertiaryFramebufferObject == NULL) {
+        _tertiaryFramebufferObject = new QOpenGLFramebufferObject(Application::getInstance()->getGLWidget()->size());
+        Application::getInstance()->getGLWidget()->installEventFilter(this);
+    }
+    return _tertiaryFramebufferObject;
+}
+
 bool TextureCache::eventFilter(QObject* watched, QEvent* event) {
     if (event->type() == QEvent::Resize) {
         QSize size = static_cast<QResizeEvent*>(event)->size();
@@ -83,6 +94,10 @@ bool TextureCache::eventFilter(QObject* watched, QEvent* event) {
             delete _secondaryFramebufferObject;
             _secondaryFramebufferObject = NULL;
         }
+        if (_tertiaryFramebufferObject != NULL && _tertiaryFramebufferObject->size() != size) {
+            delete _tertiaryFramebufferObject;
+            _tertiaryFramebufferObject = NULL;
+        }
     }
     return false;
 }

interface/src/renderer/TextureCache.h

@@ -25,7 +25,8 @@ public:
 
     QOpenGLFramebufferObject* getPrimaryFramebufferObject();
     QOpenGLFramebufferObject* getSecondaryFramebufferObject();
-
+    QOpenGLFramebufferObject* getTertiaryFramebufferObject();
+    
     virtual bool eventFilter(QObject* watched, QEvent* event);
 
 private:
@@ -34,6 +35,7 @@ private:
     
     QOpenGLFramebufferObject* _primaryFramebufferObject;
     QOpenGLFramebufferObject* _secondaryFramebufferObject;
+    QOpenGLFramebufferObject* _tertiaryFramebufferObject;
 };
 
 #endif /* defined(__interface__TextureCache__) */

jenkins/jobs.groovy

@@ -140,3 +140,20 @@ parameterizedJob.with {
             tasks / 'hudson.plugins.postbuildtask.TaskProperties' / script).setValue(curlCommand)
     }
 }
+
+doxygenJob = hifiJob('docs', false)
+doxygenJob.with {
+    scm {
+        git(GIT_REPO_URL, 'master') {}
+    }
+    
+    configure { project ->
+        (project / builders).setValue('')
+    }
+    
+    steps {
+        shell('doxygen')
+    }
+}
+
+queue doxygenJob