Use forward pipeline for android

interface/src/Application.cpp

@@ -663,11 +663,11 @@ bool setupEssentials(int& argc, char** argv, bool runningMarkerExisted) {
     DependencyManager::set<StatTracker>();
     DependencyManager::set<ScriptEngines>(ScriptEngine::CLIENT_SCRIPT);
     DependencyManager::set<Preferences>();
-    DependencyManager::set<recording::ClipCache>();
     DependencyManager::set<recording::Deck>();
     DependencyManager::set<recording::Recorder>();
     DependencyManager::set<AddressManager>();
     DependencyManager::set<NodeList>(NodeType::Agent, listenPort);
+    DependencyManager::set<recording::ClipCache>();
     DependencyManager::set<GeometryCache>();
     DependencyManager::set<ModelCache>();
     DependencyManager::set<ScriptCache>();
@@ -845,7 +845,10 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer, bo
 #endif
 
     _logger = new FileLogger(this);
+#ifndef Q_OS_ANDROID
+    // this prevents using logcat
     qInstallMessageHandler(messageHandler);
+#endif
 
     QFontDatabase::addApplicationFont(PathUtils::resourcesPath() + "styles/Inconsolata.otf");
     _window->setWindowTitle("High Fidelity Interface");
@@ -2201,6 +2204,7 @@ void Application::initializeGL() {
         _isGLInitialized = true;
     }
 
+    gl::initModuleGl();
     _glWidget->makeCurrent();
     _chromiumShareContext = new OffscreenGLCanvas();
     _chromiumShareContext->setObjectName("ChromiumShareContext");
@@ -2223,9 +2227,15 @@ void Application::initializeGL() {
     // Set up the render engine
     render::CullFunctor cullFunctor = LODManager::shouldRender;
     static const QString RENDER_FORWARD = "HIFI_RENDER_FORWARD";
+#ifndef Q_OS_ANDROID
     bool isDeferred = !QProcessEnvironment::systemEnvironment().contains(RENDER_FORWARD);
+#else
+    bool isDeferred = false;
+#endif
     _renderEngine->addJob<UpdateSceneTask>("UpdateScene");
-    _renderEngine->addJob<SecondaryCameraRenderTask>("SecondaryCameraJob", cullFunctor);
+#ifndef Q_OS_ANDROID
+    _renderEngine->addJob<SecondaryCameraRenderTask>("SecondaryCameraJob", cullFunctor, isDeferred);
+#endif
     _renderEngine->addJob<RenderViewTask>("RenderMainView", cullFunctor, isDeferred);
     _renderEngine->load();
     _renderEngine->registerScene(_main3DScene);
@@ -3907,12 +3917,18 @@ void Application::idle() {
     PROFILE_COUNTER_IF_CHANGED(app, "pendingProcessing", int, DependencyManager::get<StatTracker>()->getStat("PendingProcessing").toInt());
     auto renderConfig = _renderEngine->getConfiguration();
     PROFILE_COUNTER_IF_CHANGED(render, "gpuTime", float, (float)_gpuContext->getFrameTimerGPUAverage());
+    auto opaqueRangeTimer = renderConfig->getConfig("OpaqueRangeTimer");
+    auto linearDepth = renderConfig->getConfig("LinearDepth");
+    auto surfaceGeometry = renderConfig->getConfig("SurfaceGeometry");
+    auto renderDeferred = renderConfig->getConfig("RenderDeferred");
+    auto toneAndPostRangeTimer = renderConfig->getConfig("ToneAndPostRangeTimer");
+
     PROFILE_COUNTER(render_detail, "gpuTimes", {
-        { "OpaqueRangeTimer", renderConfig->getConfig("OpaqueRangeTimer")->property("gpuRunTime") },
+        { "OpaqueRangeTimer", opaqueRangeTimer ? opaqueRangeTimer->property("gpuRunTime") : 0 },
-        { "LinearDepth", renderConfig->getConfig("LinearDepth")->property("gpuRunTime") },
+        { "LinearDepth", linearDepth ? linearDepth->property("gpuRunTime") : 0 },
-        { "SurfaceGeometry", renderConfig->getConfig("SurfaceGeometry")->property("gpuRunTime") },
+        { "SurfaceGeometry", surfaceGeometry ? surfaceGeometry->property("gpuRunTime") : 0 },
-        { "RenderDeferred", renderConfig->getConfig("RenderDeferred")->property("gpuRunTime") },
+        { "RenderDeferred", renderDeferred ? renderDeferred->property("gpuRunTime") : 0 },
-        { "ToneAndPostRangeTimer", renderConfig->getConfig("ToneAndPostRangeTimer")->property("gpuRunTime") }
+        { "ToneAndPostRangeTimer", toneAndPostRangeTimer ? toneAndPostRangeTimer->property("gpuRunTime") : 0 }
     });
 
     PROFILE_RANGE(app, __FUNCTION__);
@@ -4277,9 +4293,9 @@ void Application::init() {
     
     // Make sure Login state is up to date
     DependencyManager::get<DialogsManager>()->toggleLoginDialog();
-
+#ifndef Q_OS_ANDROID
     DependencyManager::get<DeferredLightingEffect>()->init();
-
+#endif
     DependencyManager::get<AvatarManager>()->init();
 
     _timerStart.start();

interface/src/SecondaryCamera.cpp

@@ -203,10 +203,14 @@ public:
     }
 };
 
-void SecondaryCameraRenderTask::build(JobModel& task, const render::Varying& inputs, render::Varying& outputs, render::CullFunctor cullFunctor) {
+void SecondaryCameraRenderTask::build(JobModel& task, const render::Varying& inputs, render::Varying& outputs, render::CullFunctor cullFunctor, bool isDeferred) {
     const auto cachedArg = task.addJob<SecondaryCameraJob>("SecondaryCamera");
     const auto items = task.addJob<RenderFetchCullSortTask>("FetchCullSort", cullFunctor);
     assert(items.canCast<RenderFetchCullSortTask::Output>());
+    if (!isDeferred) {
+        task.addJob<RenderForwardTask>("Forward", items);
+    } else {
         task.addJob<RenderDeferredTask>("RenderDeferredTask", items);
+    }
     task.addJob<EndSecondaryCameraFrame>("EndSecondaryCamera", cachedArg);
 }

interface/src/SecondaryCamera.h

@@ -71,7 +71,7 @@ public:
     using JobModel = render::Task::Model<SecondaryCameraRenderTask, Config>;
     SecondaryCameraRenderTask() {}
     void configure(const Config& config) {}
-    void build(JobModel& task, const render::Varying& inputs, render::Varying& outputs, render::CullFunctor cullFunctor);
+    void build(JobModel& task, const render::Varying& inputs, render::Varying& outputs, render::CullFunctor cullFunctor, bool isDeferred = true);
 };
 
 #endif

libraries/gl/src/gl/Config.cpp

@@ -14,9 +14,9 @@
 #include <mutex>
 
 #if defined(Q_OS_ANDROID)
-PFNGLQUERYCOUNTEREXTPROC glQueryCounterEXT = NULL;
+PFNGLQUERYCOUNTEREXTPROC __glQueryCounterEXT = NULL;
-PFNGLGETQUERYOBJECTUI64VEXTPROC glGetQueryObjectui64vEXT = NULL;
+PFNGLGETQUERYOBJECTUI64VEXTPROC __glGetQueryObjectui64vEXT = NULL;
-PFNGLFRAMEBUFFERTEXTUREEXTPROC glFramebufferTextureEXT = NULL;
+PFNGLFRAMEBUFFERTEXTUREEXTPROC __glFramebufferTextureEXT = NULL;
 #endif
 
 void gl::initModuleGl() {

libraries/gl/src/gl/Config.h

@@ -50,9 +50,15 @@ extern "C" {
     typedef void (GL_APIENTRYP PFNGLQUERYCOUNTEREXTPROC) (GLuint id, GLenum target);
     typedef void (GL_APIENTRYP PFNGLGETQUERYOBJECTUI64VEXTPROC) (GLuint id, GLenum pname, GLuint64 *params);
     typedef void (GL_APIENTRYP PFNGLFRAMEBUFFERTEXTUREEXTPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level);
-    extern PFNGLQUERYCOUNTEREXTPROC glQueryCounterEXT;
+
-    extern PFNGLGETQUERYOBJECTUI64VEXTPROC glGetQueryObjectui64vEXT;
+
-    extern PFNGLFRAMEBUFFERTEXTUREEXTPROC glFramebufferTextureEXT;
+    #define glQueryCounterEXT __glQueryCounterEXT
+    #define glGetQueryObjectui64vEXT __glGetQueryObjectui64vEXT
+    #define glFramebufferTextureEXT __glFramebufferTextureEXT
+
+    extern PFNGLQUERYCOUNTEREXTPROC __glQueryCounterEXT;
+    extern PFNGLGETQUERYOBJECTUI64VEXTPROC __glGetQueryObjectui64vEXT;
+    extern PFNGLFRAMEBUFFERTEXTUREEXTPROC __glFramebufferTextureEXT;
 }
 
 #else // !defined(Q_OS_ANDROID)

libraries/gpu-gles/src/gpu/gl/GLBackend.cpp

@@ -94,6 +94,7 @@ GLBackend::CommandCall GLBackend::_commandCalls[Batch::NUM_COMMANDS] =
     (&::gpu::gl::GLBackend::do_setStateScissorRect),
 
     (&::gpu::gl::GLBackend::do_setUniformBuffer),
+    (&::gpu::gl::GLBackend::do_setResourceBuffer),
     (&::gpu::gl::GLBackend::do_setResourceTexture),
 
     (&::gpu::gl::GLBackend::do_setFramebuffer),
@@ -107,6 +108,11 @@ GLBackend::CommandCall GLBackend::_commandCalls[Batch::NUM_COMMANDS] =
 
     (&::gpu::gl::GLBackend::do_resetStages),
 
+    (&::gpu::gl::GLBackend::do_disableContextViewCorrection),
+    (&::gpu::gl::GLBackend::do_restoreContextViewCorrection),
+    (&::gpu::gl::GLBackend::do_disableContextStereo),
+    (&::gpu::gl::GLBackend::do_restoreContextStereo),
+
     (&::gpu::gl::GLBackend::do_runLambda),
 
     (&::gpu::gl::GLBackend::do_startNamedCall),
@@ -333,6 +339,22 @@ void GLBackend::do_resetStages(const Batch& batch, size_t paramOffset) {
     resetStages();
 }
 
+void GLBackend::do_disableContextViewCorrection(const Batch& batch, size_t paramOffset) {
+    _transform._viewCorrectionEnabled = false;
+}
+
+void GLBackend::do_restoreContextViewCorrection(const Batch& batch, size_t paramOffset) {
+    _transform._viewCorrectionEnabled = true;
+}
+
+void GLBackend::do_disableContextStereo(const Batch& batch, size_t paramOffset) {
+
+}
+
+void GLBackend::do_restoreContextStereo(const Batch& batch, size_t paramOffset) {
+
+}
+
 void GLBackend::do_runLambda(const Batch& batch, size_t paramOffset) {
     std::function<void()> f = batch._lambdas.get(batch._params[paramOffset]._uint);
     f();

libraries/gpu-gles/src/gpu/gl/GLBackend.h

@@ -92,6 +92,8 @@ namespace gpu { namespace gl {
 
             // this is the maximum per shader stage on the low end apple
             // TODO make it platform dependant at init time
+            static const int MAX_NUM_RESOURCE_BUFFERS = 16;
+            size_t getMaxNumResourceBuffers() const { return MAX_NUM_RESOURCE_BUFFERS; }
             static const int MAX_NUM_RESOURCE_TEXTURES = 16;
             size_t getMaxNumResourceTextures() const { return MAX_NUM_RESOURCE_TEXTURES; }
 
@@ -121,6 +123,7 @@ namespace gpu { namespace gl {
             virtual void do_setUniformBuffer(const Batch& batch, size_t paramOffset) final;
 
             // Resource Stage
+            virtual void do_setResourceBuffer(const Batch& batch, size_t paramOffset) final;
             virtual void do_setResourceTexture(const Batch& batch, size_t paramOffset) final;
 
             // Pipeline Stage
@@ -139,6 +142,12 @@ namespace gpu { namespace gl {
             // Reset stages
             virtual void do_resetStages(const Batch& batch, size_t paramOffset) final;
 
+            virtual void do_disableContextViewCorrection(const Batch& batch, size_t paramOffset) final;
+            virtual void do_restoreContextViewCorrection(const Batch& batch, size_t paramOffset) final;
+
+            virtual void do_disableContextStereo(const Batch& batch, size_t paramOffset) final;
+            virtual void do_restoreContextStereo(const Batch& batch, size_t paramOffset) final;
+
             virtual void do_runLambda(const Batch& batch, size_t paramOffset) final;
 
             virtual void do_startNamedCall(const Batch& batch, size_t paramOffset) final;
@@ -322,6 +331,7 @@ namespace gpu { namespace gl {
                 bool _skybox { false };
                 Transform _view;
                 CameraCorrection _correction;
+                bool _viewCorrectionEnabled{ true };
 
                 Mat4 _projection;
                 Vec4i _viewport { 0, 0, 1, 1 };
@@ -353,12 +363,18 @@ namespace gpu { namespace gl {
             void releaseUniformBuffer(uint32_t slot);
             void resetUniformStage();
 
+            // update resource cache and do the gl bind/unbind call with the current gpu::Buffer cached at slot s
+            // This is using different gl object  depending on the gl version
+            virtual bool bindResourceBuffer(uint32_t slot, BufferPointer& buffer) = 0;
+            virtual void releaseResourceBuffer(uint32_t slot) = 0;
+
             // update resource cache and do the gl unbind call with the current gpu::Texture cached at slot s
             void releaseResourceTexture(uint32_t slot);
 
             void resetResourceStage();
 
             struct ResourceStageState {
+                std::array<BufferPointer, MAX_NUM_RESOURCE_BUFFERS> _buffers;
                 std::array<TexturePointer, MAX_NUM_RESOURCE_TEXTURES> _textures;
                 //Textures _textures { { MAX_NUM_RESOURCE_TEXTURES } };
                 int findEmptyTextureSlot() const;

libraries/gpu-gles/src/gpu/gl/GLBackendPipeline.cpp

@@ -197,6 +197,36 @@ void GLBackend::resetResourceStage() {
     }
 }
 
+void GLBackend::do_setResourceBuffer(const Batch& batch, size_t paramOffset) {
+    GLuint slot = batch._params[paramOffset + 1]._uint;
+    if (slot >= (GLuint)MAX_NUM_RESOURCE_BUFFERS) {
+        qCDebug(gpugllogging) << "GLBackend::do_setResourceBuffer: Trying to set a resource Buffer at slot #" << slot << " which doesn't exist. MaxNumResourceBuffers = " << getMaxNumResourceBuffers();
+        return;
+    }
+
+    auto resourceBuffer = batch._buffers.get(batch._params[paramOffset + 0]._uint);
+
+    if (!resourceBuffer) {
+        releaseResourceBuffer(slot);
+        return;
+    }
+    // check cache before thinking
+    if (_resource._buffers[slot] == resourceBuffer) {
+        return;
+    }
+
+    // One more True Buffer bound
+    _stats._RSNumResourceBufferBounded++;
+
+    // If successful bind then cache it
+    if (bindResourceBuffer(slot, resourceBuffer)) {
+        _resource._buffers[slot] = resourceBuffer;
+    } else { // else clear slot and cache
+        releaseResourceBuffer(slot);
+        return;
+    }
+}
+
 void GLBackend::do_setResourceTexture(const Batch& batch, size_t paramOffset) {
     GLuint slot = batch._params[paramOffset + 1]._uint;
     if (slot >= (GLuint) MAX_NUM_RESOURCE_TEXTURES) {

libraries/gpu-gles/src/gpu/gles/GLESBackend.h

@@ -87,6 +87,10 @@ protected:
     void updateTransform(const Batch& batch);
     void resetTransformStage();
 
+    // Resource Stage
+    bool bindResourceBuffer(uint32_t slot, BufferPointer& buffer) override;
+    void releaseResourceBuffer(uint32_t slot) override;
+
     // Output stage
     void do_blit(const Batch& batch, size_t paramOffset) override;
 };

libraries/gpu-gles/src/gpu/gles/GLESBackendBuffer.cpp

@@ -67,3 +67,27 @@ GLuint GLESBackend::getBufferID(const Buffer& buffer) {
 GLBuffer* GLESBackend::syncGPUObject(const Buffer& buffer) {
     return GLESBuffer::sync<GLESBuffer>(*this, buffer);
 }
+
+bool GLESBackend::bindResourceBuffer(uint32_t slot, BufferPointer& buffer) {
+    GLBuffer* object = syncGPUObject((*buffer));
+    if (object) {
+        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, slot, object->_id);
+
+        (void)CHECK_GL_ERROR();
+
+        _resource._buffers[slot] = buffer;
+
+        return true;
+    }
+
+    return false;
+}
+
+void GLESBackend::releaseResourceBuffer(uint32_t slot) {
+    auto& buf = _resource._buffers[slot];
+    if (buf) {
+        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, slot, 0);
+        buf.reset();
+    }
+}
+

libraries/render-utils/src/RenderForwardTask.cpp

@@ -21,7 +21,7 @@
 
 #include "FramebufferCache.h"
 #include "TextureCache.h"
-
+#include <gpu/Texture.h>
 #include <gpu/StandardShaderLib.h>
 
 #include "nop_frag.h"
@@ -75,11 +75,11 @@ void PrepareFramebuffer::run(const RenderContextPointer& renderContext,
 
         auto colorFormat = gpu::Element::COLOR_SRGBA_32;
         auto defaultSampler = gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_POINT);
-        auto colorTexture = gpu::Texture::create2D(colorFormat, frameSize.x, frameSize.y, gpu::Texture::SINGLE_MIP, defaultSampler);
+        auto colorTexture = gpu::Texture::createRenderBuffer(colorFormat, frameSize.x, frameSize.y, gpu::Texture::SINGLE_MIP, defaultSampler);
         _framebuffer->setRenderBuffer(0, colorTexture);
 
         auto depthFormat = gpu::Element(gpu::SCALAR, gpu::UINT32, gpu::DEPTH_STENCIL); // Depth24_Stencil8 texel format
-        auto depthTexture = gpu::Texture::create2D(depthFormat, frameSize.x, frameSize.y, gpu::Texture::SINGLE_MIP, defaultSampler);
+        auto depthTexture = gpu::Texture::createRenderBuffer(depthFormat, frameSize.x, frameSize.y, gpu::Texture::SINGLE_MIP, defaultSampler);
         _framebuffer->setDepthStencilBuffer(depthTexture, depthFormat);
     }
 

libraries/shared/src/shared/FileUtils.cpp

@@ -84,7 +84,11 @@ void FileUtils::locateFile(QString filePath) {
 QString FileUtils::standardPath(QString subfolder) {
     // standard path
     // Mac: ~/Library/Application Support/Interface
+#ifndef Q_OS_ANDROID
     QString path = QStandardPaths::writableLocation(QStandardPaths::DataLocation);
+#else
+    QString path = QStandardPaths::writableLocation(QStandardPaths::CacheLocation);
+#endif
     if (!subfolder.startsWith("/")) {
         subfolder.prepend("/");
     }