Update Flathub version 0.8.0

Attempt at linking vimix to MIME type .mix

.github/workflows/jekyll-gh-pages.yml

@@ -0,0 +1,50 @@
+# Sample workflow for building and deploying a Jekyll site to GitHub Pages
+name: Deploy Jekyll with GitHub Pages dependencies preinstalled
+
+on:
+  # Runs on pushes targeting the default branch
+  push:
+    branches: ["master"]
+
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+# Allow one concurrent deployment
+concurrency:
+  group: "pages"
+  cancel-in-progress: true
+
+jobs:
+  # Build job
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Setup Pages
+        uses: actions/configure-pages@v2
+      - name: Build with Jekyll
+        uses: actions/jekyll-build-pages@v1
+        with:
+          source: ./docs
+          destination: ./_site
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v1
+
+  # Deployment job
+  deploy:
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: ubuntu-latest
+    needs: build
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v1

.gitignore

@@ -14,3 +14,21 @@ libTINYXML2.a
 libvmix-resources.a
 rules.ninja
 /vmix
+/vimix_*.snap
+/CMakeLists.txt.user.*
+
+rsc/shaders/paint.fs
+
+osx/.DS_Store
+
+.DS_Store
+
+osx/runvimix
+
+*.autosave
+
+flatpak/.flatpak-builder
+
+flatpak/repo/
+
+flatpak/build/

.gitmodules

@@ -13,9 +13,12 @@
 [submodule "ext/Dirent"]
 	path = ext/Dirent
 	url = https://github.com/tronkko/dirent.git
-[submodule "ext/tfd"]
-	path = ext/tfd
-	url = https://github.com/native-toolkit/tinyfiledialogs.git
 [submodule "ext/glm"]
 	path = ext/glm
 	url = https://github.com/g-truc/glm.git
+[submodule "ext/link"]
+	path = ext/link
+	url = https://github.com/Ableton/link.git
+[submodule "ext/tfd"]
+	path = ext/tfd
+	url = https://git.code.sf.net/p/tinyfiledialogs/code

BoundingBoxVisitor.cpp

@@ -1,66 +0,0 @@
-#include <glm/gtc/matrix_transform.hpp>
-
-#include "BoundingBoxVisitor.h"
-
-#include "Log.h"
-#include "Primitives.h"
-#include "Decorations.h"
-
-BoundingBoxVisitor::BoundingBoxVisitor(): Visitor()
-{
-    modelview_ = glm::identity<glm::mat4>();
-
-}
-
-void BoundingBoxVisitor::setModelview(glm::mat4 modelview)
-{
-    modelview_ = modelview;
-}
-
-GlmToolkit::AxisAlignedBoundingBox BoundingBoxVisitor::bbox()
-{
-    return bbox_;
-}
-
-void BoundingBoxVisitor::visit(Node &n)
-{
-    // use the transform modified during update    modelview_ *= n.transform_;
-    glm::mat4 transform_local = GlmToolkit::transform(n.translation_, n.rotation_, n.scale_);
-    modelview_ *= transform_local;
-}
-
-void BoundingBoxVisitor::visit(Group &n)
-{
-    if (!n.visible_)
-        return;
-    glm::mat4 mv = modelview_;
-    for (NodeSet::iterator node = n.begin(); node != n.end(); node++) {
-        if ( (*node)->visible_ )
-            (*node)->accept(*this);
-        modelview_ = mv;
-    }
-}
-
-void BoundingBoxVisitor::visit(Switch &n)
-{
-    if (!n.visible_ || n.numChildren() < 1)
-        return;
-    glm::mat4 mv = modelview_;
-    n.activeChild()->accept(*this);
-    modelview_ = mv;
-}
-
-void BoundingBoxVisitor::visit(Primitive &n)
-{
-    if (!n.visible_)
-        return;
-
-    bbox_.extend(n.bbox().transformed(modelview_));
-
-//    Log::Info("visitor box (%f, %f)-(%f, %f)", bbox_.min().x, bbox_.min().y, bbox_.max().x, bbox_.max().y);
-}
-
-void BoundingBoxVisitor::visit(Scene &n)
-{
-    n.ws()->accept(*this);
-}

CMakeLists.txt

@@ -1,186 +1,143 @@
+#####
+#####  This file is part of vimix - video live mixer
+#####  **Copyright** (C) 2019-2023 Bruno Herbelin <bruno.herbelin@gmail.com>
+#####
 
-cmake_minimum_required(VERSION 3.8.0)
+cmake_minimum_required(VERSION 3.8.2)
 project(vimix VERSION 0.0.1 LANGUAGES CXX C)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
-set(CMAKE_VERBOSE_MAKEFILE ON CACHE BOOL "ON")
-set(CMAKE_INCLUDE_CURRENTDIR ON)
-set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules )
+#####
+##### Use git to read version from tags
+#####
+find_package (Git)
+if(GIT_EXECUTABLE)
+  execute_process(
+    COMMAND ${GIT_EXECUTABLE} describe --tags
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+    OUTPUT_VARIABLE GIT_DESCRIBE_VERSION
+    RESULT_VARIABLE GIT_DESCRIBE_ERROR_CODE
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+  if(NOT GIT_DESCRIBE_ERROR_CODE)
+      string(SUBSTRING ${GIT_DESCRIBE_VERSION} 0 1 VIMIX_VERSION_MAJOR)
+      string(SUBSTRING ${GIT_DESCRIBE_VERSION} 2 1 VIMIX_VERSION_MINOR)
+      string(LENGTH ${GIT_DESCRIBE_VERSION} VIMIX_VERSION_LENGTH)
+      if (VIMIX_VERSION_LENGTH GREATER 4)
+          string(SUBSTRING ${GIT_DESCRIBE_VERSION} 4 1 VIMIX_VERSION_PATCH)
+      else()
+          set(VIMIX_VERSION_PATCH "0")
+      endif()
+      add_definitions(-DVIMIX_VERSION_MAJOR=${VIMIX_VERSION_MAJOR})
+      add_definitions(-DVIMIX_VERSION_MINOR=${VIMIX_VERSION_MINOR})
+      add_definitions(-DVIMIX_VERSION_PATCH=${VIMIX_VERSION_PATCH})
+      message(STATUS "Compiling vimix version ${VIMIX_VERSION_MAJOR}.${VIMIX_VERSION_MINOR}.${VIMIX_VERSION_PATCH}")
+  endif()
+endif()
+
+
+#####
+##### Find the cmake modules
+#####
+
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} /usr/share/cmake ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules )
 include(MacroLogFeature)
+include(MacroFindGStreamerLibrary)
+
+
+#####
+##### Configure cmake
+#####
+
+set(BUILD_STATIC_LIBS ON)
+set(CMAKE_INCLUDE_CURRENTDIR ON)
 
 if(UNIX)
     if (APPLE)
         add_definitions(-DAPPLE)
 
+        # the RPATH to be used when installing
+        set(CMAKE_SKIP_RPATH TRUE)
         set(OpenGL_DIR /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/System/Library/Frameworks/)
-        set(CMAKE_OSX_ARCHITECTURES x86_64)
-        set(CMAKE_OSX_DEPLOYMENT_TARGET "10.13")
+        set(CMAKE_OSX_ARCHITECTURES "x86_64")
+        set(CMAKE_OSX_DEPLOYMENT_TARGET "10.14")
+
+        # CPACK
+        set(CPACK_SYSTEM_NAME  "OSX_${CMAKE_OSX_DEPLOYMENT_TARGET}_${CMAKE_OSX_ARCHITECTURES}")
+        set(CPACK_GENERATOR DragNDrop)
+        set(CPACK_BINARY_DRAGNDROP ON)
+        set(APPLE_CODESIGN_ENTITLEMENTS "${CMAKE_CURRENT_SOURCE_DIR}/osx/entitlements.plist")
+
+        # find icu4c in OSX (pretty well hidden...)
+        set(ENV{PKG_CONFIG_PATH} "$ENV{PKG_CONFIG_PATH}:/usr/local/opt/icu4c/lib/pkgconfig")
 
     else()
         add_definitions(-DLINUX)
 
+        # CPACK
+        set(CPACK_SYSTEM_NAME "${CMAKE_HOST_SYSTEM_NAME}")
+
+        # linux opengl
         set(OpenGL_GL_PREFERENCE "GLVND")
 
+        # linux dialogs use GTK
+        find_package(GTK 3.0 REQUIRED)
+        macro_log_feature(GTK_FOUND "GTK" "GTK cross-platform widget toolkit" "http://www.gtk.org" TRUE)
+
     endif()
     add_definitions(-DUNIX)
 elseif(WIN32)
     add_definitions(-DWIN32)
     add_definitions(-DMINGW32)
-endif(UNIX)
+endif()
 
+#####
+##### Dependencies
+#####
 
-# Include the CMake RC module
-include(CMakeRC)
+#
+# Basics
+#
+set(CMAKE_THREAD_PREFER_PTHREAD TRUE)
+find_package(Threads REQUIRED)
+
+find_package(ZLIB REQUIRED)
 
 #
 # GSTREAMER
 #
+find_package(GLIB2 REQUIRED)
+macro_log_feature(GLIB2_FOUND "GLib" "GTK general-purpose utility library" "http://www.gtk.org" TRUE)
+
+find_package(GObject REQUIRED)
+macro_log_feature(GOBJECT_FOUND "GObject" "GTK object-oriented framework" "http://www.gtk.org" TRUE)
 
 find_package(GStreamer 1.0.0 COMPONENTS base)
 macro_log_feature(GSTREAMER_FOUND "GStreamer"
 "Open Source Multiplatform Multimedia Framework"
 "http://gstreamer.freedesktop.org/" TRUE "1.0.0")
-macro_log_feature(GSTREAMER_BASE_LIBRARY_FOUND "GStreamer base library"
-"${GSTREAMER_BASE_LIBRARY}"
-"http://gstreamer.freedesktop.org/" FALSE "1.0.0")
 
 find_package(GStreamerPluginsBase 1.0.0 COMPONENTS app audio video pbutils gl)
-macro_log_feature(GSTREAMER_APP_LIBRARY_FOUND "GStreamer app library"
-"${GSTREAMER_APP_LIBRARY}"
+macro_log_feature(GSTREAMER_APP_LIBRARY_FOUND "GStreamerPluginsBase" "GStreamer app library"
 "http://gstreamer.freedesktop.org/" TRUE "1.0.0")
 
-macro_log_feature(GSTREAMER_AUDIO_LIBRARY_FOUND "GStreamer audio library"
-"${GSTREAMER_AUDIO_LIBRARY}"
+macro_log_feature(GSTREAMER_AUDIO_LIBRARY_FOUND "GStreamerPluginsBase" "GStreamer audio library"
 "http://gstreamer.freedesktop.org/" TRUE "1.0.0")
 
-macro_log_feature(GSTREAMER_VIDEO_LIBRARY_FOUND "GStreamer video library"
-"${GSTREAMER_VIDEO_LIBRARY}"
+macro_log_feature(GSTREAMER_VIDEO_LIBRARY_FOUND "GStreamerPluginsBase" "GStreamer video library"
 "http://gstreamer.freedesktop.org/" TRUE "1.0.0")
 
-macro_log_feature(GSTREAMER_PBUTILS_LIBRARY_FOUND "GStreamer pbutils library"
-"${GSTREAMER_PBUTILS_LIBRARY}"
+macro_log_feature(GSTREAMER_PBUTILS_LIBRARY_FOUND "GStreamerPluginsBase" "GStreamer pbutils library"
 "http://gstreamer.freedesktop.org/" TRUE "1.0.0")
 
-macro_log_feature(GSTREAMER_GL_LIBRARY_FOUND "GStreamer opengl library"
-"${GSTREAMER_GL_LIBRARY}"
+macro_log_feature(GSTREAMER_GL_LIBRARY_FOUND "GStreamerPluginsBase" "GStreamer opengl library"
 "http://gstreamer.freedesktop.org/" TRUE "1.0.0")
 
-
-#find_package(GStreamerPluginsBad 1.0.0 COMPONENTS player)
-#macro_log_feature(GSTREAMER_PLAYER_LIBRARY_FOUND "GStreamer player library"
-#"${GSTREAMER_PLAYER_LIBRARY}"
-#"http://gstreamer.freedesktop.org/" TRUE "1.0.0")
-
-
 # Various preprocessor definitions for GST
 add_definitions(-DGST_DISABLE_XML -DGST_DISABLE_LOADSAVE)
 
-# Basics
-find_package(GLIB2)
-macro_log_feature(GLIB2_FOUND "GLib" "GTK general-purpose utility library" "http://www.gtk.org/" TRUE)
-
-find_package(GObject)
-macro_log_feature(GOBJECT_FOUND "GObject" "GTK object-oriented framework" "http://www.gtk.org/" TRUE)
-
-set(CMAKE_THREAD_PREFER_PTHREAD TRUE)
-find_package(Threads REQUIRED)
-set(THREAD_LIBRARY Threads::Threads)
-
-find_package(PNG REQUIRED)
-set(PNG_LIBRARY PNG::PNG)
-
-#
-# GLFW3
-#
-find_package(glfw3 3.2 REQUIRED)
-macro_log_feature(glfw3_FOUND "GLFW3" "Open Source, multi-platform library for OpenGL" "http://www.glfw.org/" TRUE)
-set(GLFW_LIBRARY glfw)
-
-find_package(OpenGL REQUIRED)
-
-#
-# GLM
-#
-set(BUILD_STATIC_LIBS ON)
-add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/ext/glm)
-message(STATUS "Compiling 'GLM' OpenGL Mathematics https://glm.g-truc.net.")
-
-#
-# GLAD
-#
-set(GLAD_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/ext/glad/include)
-add_library(GLAD "${CMAKE_CURRENT_SOURCE_DIR}/ext/glad/src/glad.c")
-message(STATUS "Compiling 'GLAD' generated at https://glad.dav1d.de/ -- ${GLAD_INCLUDE_DIR}.")
-
-#
-# DEAR IMGUI
-#
-set(IMGUI_SRCS
-    ${CMAKE_CURRENT_SOURCE_DIR}/ext/imgui/imgui.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/ext/imgui//imgui_demo.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/ext/imgui//imgui_draw.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/ext/imgui//imgui_widgets.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/ext/imgui/examples/imgui_impl_glfw.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/ext/imgui/examples/imgui_impl_opengl3.cpp
-)
-set(IMGUI_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/ext/imgui)
-add_library(IMGUI "${IMGUI_SRCS}")
-target_compile_definitions(IMGUI PRIVATE "IMGUI_IMPL_OPENGL_LOADER_GLAD")
-message(STATUS "Compiling 'Dear ImGui' from https://github.com/ocornut/imgui.git -- ${IMGUI_INCLUDE_DIR}.")
-
-#
-# ImGui Color Text Editor
-#
-set(IMGUITEXTEDIT_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/ext/ImGuiColorTextEdit)
-set(IMGUITEXTEDIT_SRC
-    ${CMAKE_CURRENT_SOURCE_DIR}/ext/ImGuiColorTextEdit/TextEditor.cpp
-)
-message(STATUS "Including 'ImGuiColorTextEdit' from https://github.com/BalazsJako/ImGuiColorTextEdit -- ${IMGUITEXTEDIT_INCLUDE_DIR}.")
-
-#
-# TINY XML 2
-#
-set(TINYXML2_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/ext/tinyxml2)
-add_library(TINYXML2 "${CMAKE_CURRENT_SOURCE_DIR}/ext/tinyxml2/tinyxml2.cpp")
-message(STATUS "Compiling 'TinyXML2' from https://github.com/leethomason/tinyxml2.git -- ${TINYXML2_INCLUDE_DIR}.")
-
-#
-# STB
-#
-set(STB_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/ext/stb)
-add_definitions(-DIMGUI_USE_STB_SPRINTF)
-message(STATUS "Including 'STB Nothings' from https://github.com/nothings/stb -- ${STB_INCLUDE_DIR}.")
-
-#
-# DIRENT
-#
-if(WIN32)
-    set(DIRENT_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/ext/Dirent/include)
-    message(STATUS "Including 'Dirent' from https://github.com/tronkko/dirent -- ${DIRENT_INCLUDE_DIR}.")
-endif( WIN32 )
-
-#
-# TINY FILE DIALOG
-#
-set(TINYFD_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/ext/tfd)
-add_library(TINYFD "${CMAKE_CURRENT_SOURCE_DIR}/ext/tfd/tinyfiledialogs.c")
-message(STATUS "Compiling 'TinyFileDialog' from https://github.com/native-toolkit/tinyfiledialogs.git -- ${TINYFD_INCLUDE_DIR}.")
-
-#
-# OBJ LOADER
-#
-#set(OBJLOADER_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/ext/obj)
-#add_library(OBJLOADER "${CMAKE_CURRENT_SOURCE_DIR}/ext/obj/ObjLoader.cpp")
-#message(STATUS "Compiling 'ObjLoader' from https://github.com/mortennobel/OpenGL_3_2_Utils -- ${OBJLOADER_INCLUDE_DIR}.")
-
-# find_package(PkgConfig REQUIRED)
-# pkg_check_modules(GTK3 REQUIRED gtk+-3.0)
-
-#
-#  Application
-#
-
-# Setup the environment
 include_directories(
+    ${GLIB2_INCLUDE_DIR}
     ${GSTREAMER_INCLUDE_DIR}
     ${GSTREAMER_AUDIO_INCLUDE_DIR}
     ${GSTREAMER_VIDEO_INCLUDE_DIR}
@@ -188,74 +145,344 @@ include_directories(
     ${GSTREAMER_APP_INCLUDE_DIR}
     ${GSTREAMER_PBUTILS_INCLUDE_DIR}
     ${GSTREAMER_GL_INCLUDE_DIR}
-    ${GLIB2_INCLUDE_DIR}
-    ${GLAD_INCLUDE_DIR}
+)
+
+#
+# ICU4C
+#
+if (PKG_CONFIG_FOUND)
+    pkg_check_modules(ICU REQUIRED icu-i18n icu-uc icu-io)
+else ()
+    find_package(ICU REQUIRED COMPONENTS i18n io uc)
+endif ()
+
+macro_log_feature(ICU_FOUND "ICU" "International Components for Unicode" "http://site.icu-project.org" TRUE)
+
+include_directories(
+    ${ICU_INCLUDE_DIRS}
+)
+
+link_directories(
+    ${ICU_LIBRARY_DIRS}
+)
+
+#
+# GLFW3
+#
+if (PKG_CONFIG_FOUND)
+    pkg_check_modules(GLFW3 REQUIRED glfw3>=3.2)
+else ()
+    find_package(glfw3 3.2 REQUIRED)
+endif()
+
+macro_log_feature(GLFW3_FOUND "glfw3" "Open Source multi-platform library for OpenGL" "http://www.glfw.org" TRUE)
+
+include_directories(
+    ${GLFW3_INCLUDE_DIRS}
+)
+
+link_directories(
+    ${GLFW3_LIBRARY_DIRS}
+)
+
+#
+# GLM
+#
+if (PKG_CONFIG_FOUND)
+    pkg_check_modules(GLM QUIET glm>=0.9.9)
+else ()
+    find_package(glm 0.9.9 QUIET)
+endif()
+
+if (GLM_FOUND)
+    macro_log_feature(GLM_FOUND "GLM" "OpenGL mathematics" "https://glm.g-truc.net" TRUE)
+else ()
+    set(GLM_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/ext/glm)
+    add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/ext/glm)
+    message(STATUS "Compiling 'GLM' OpenGL mathematics https://glm.g-truc.net -- ${CMAKE_CURRENT_SOURCE_DIR}/ext/glm")
+endif()
+
+include_directories(
     ${GLM_INCLUDE_DIRS}
-    ${IMGUI_INCLUDE_DIR}
-    ${IMGUI_INCLUDE_DIR}/examples
+)
+
+#
+# TINY XML 2
+#
+if (PKG_CONFIG_FOUND)
+    pkg_check_modules(TINYXML2 QUIET tinyxml2>=8.0)
+else ()
+    find_package(tinyxml2 8.0 QUIET)
+endif()
+
+if (TINYXML2_FOUND)
+    macro_log_feature(TINYXML2_FOUND "TinyXML2" "TinyXML2 library" "https://github.com/leethomason/tinyxml2.git" TRUE)
+else ()
+    set(TINYXML2_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/ext/tinyxml2)
+    set(TINYXML2_LIBRARIES TINYXML2)
+    add_library(TINYXML2 "${CMAKE_CURRENT_SOURCE_DIR}/ext/tinyxml2/tinyxml2.cpp")
+    message(STATUS "Compiling 'TinyXML2' from https://github.com/leethomason/tinyxml2.git -- ${TINYXML2_INCLUDE_DIRS}")
+endif()
+
+include_directories(
+    ${TINYXML2_INCLUDE_DIRS}
+)
+
+#
+# STB
+#
+if (PKG_CONFIG_FOUND)
+    pkg_check_modules(STB QUIET stb)
+else ()
+    find_package(stb QUIET)
+endif()
+
+if (STB_FOUND)
+    macro_log_feature(STB_FOUND "STB" "single-file image and audio processing" "https://github.com/nothings/stb" TRUE)
+else ()
+    set(STB_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/ext/stb)
+    message(STATUS "Including 'STB' single-file image and audio processing from https://github.com/nothings/stb -- ${STB_INCLUDE_DIRS}")
+endif()
+
+include_directories(
+    ${STB_INCLUDE_DIRS}
+)
+
+#
+# Ableton LINK
+#
+find_package(AbletonLink QUIET)
+
+if (AbletonLink_FOUND)
+    macro_log_feature(AbletonLink_FOUND "AbletonLink" "Ableton Link synchronizer" "https://github.com/Ableton/link" TRUE)
+else ()
+    include(${CMAKE_CURRENT_SOURCE_DIR}/ext/link/AbletonLinkConfig.cmake)
+    message(STATUS "Compiling 'Ableton Link' from https://github.com/Ableton/link -- ${CMAKE_CURRENT_SOURCE_DIR}/ext/link")
+endif()
+
+include_directories(
+    ${link_HEADERS}
+)
+
+
+#
+# FILE DIALOG: use tinyfiledialog for all except Linux
+#
+if(APPLE OR WIN32)
+    set(TINYFD_LIBRARIES TINYFD)
+    set(TINYFD_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/ext/tfd)
+    include_directories(
+        ${TINYFD_INCLUDE_DIR}
+    )
+    add_library(TINYFD "${CMAKE_CURRENT_SOURCE_DIR}/ext/tfd/tinyfiledialogs.c")
+    message(STATUS "Compiling 'TinyFileDialog' from https://git.code.sf.net/p/tinyfiledialogs/code -- ${TINYFD_INCLUDE_DIR}.")
+endif()
+
+#
+# DIRENT (windows only)
+if(WIN32)
+    set(DIRENT_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/ext/Dirent/include)
+    include_directories(
+        ${DIRENT_INCLUDE_DIR}
+    )
+    message(STATUS "Including 'Dirent' from https://github.com/tronkko/dirent -- ${DIRENT_INCLUDE_DIR}.")
+endif()
+
+
+#
+# SHMDATA (Unix only)
+#
+if(UNIX)
+
+    if (PKG_CONFIG_FOUND)
+        pkg_check_modules(SHMDATA QUIET shmdata-1.3)
+    endif()
+
+    if(SHMDATA_FOUND)
+        find_library(GSTREAMER_SHMDATA_LIBRARY
+            NAMES gstshmdata
+            HINTS ${SHMDATA_LIBRARY_DIRS}/gstreamer-1.0
+        )
+        if(GSTREAMER_SHMDATA_LIBRARY)
+            add_definitions(-DGSTREAMER_SHMDATA_PLUGIN=\"${GSTREAMER_SHMDATA_LIBRARY}\")
+        endif()
+
+        macro_log_feature(GSTREAMER_SHMDATA_LIBRARY "GStreamerPluginShmdata" "Plugin to share any flow" "https://gitlab.com/sat-mtl/tools/shmdata" FALSE)
+    endif(SHMDATA_FOUND)
+
+endif(UNIX)
+
+
+# show message about found libs
+macro_display_feature_log()
+
+#####
+##### Locally built libraries
+#####
+
+#
+# GLAD
+#
+set(GLAD_LIBRARIES GLAD)
+set(GLAD_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/ext/glad/include)
+include_directories(
+    ${GLAD_INCLUDE_DIRS}
+)
+add_library(GLAD "${CMAKE_CURRENT_SOURCE_DIR}/ext/glad/src/glad.c")
+message(STATUS "Including 'GLAD' Open source multi-language OpenGL loader https://glad.dav1d.de -- ${GLAD_INCLUDE_DIRS}")
+
+#
+# DEAR IMGUI
+#
+set(IMGUI_LIBRARIES IMGUI IMGUITEXTEDIT)
+set(IMGUI_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/ext/imgui)
+set(IMGUI_BACKEND_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/ext/imgui/examples)
+include_directories(
+    ${IMGUI_INCLUDE_DIRS}
+    ${IMGUI_BACKEND_INCLUDE_DIRS}
+)
+set(IMGUI_SRCS
+    ${CMAKE_CURRENT_SOURCE_DIR}/ext/imgui/imgui.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/ext/imgui//imgui_demo.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/ext/imgui//imgui_draw.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/ext/imgui//imgui_widgets.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/ext/imgui/examples/imgui_impl_glfw.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/ext/imgui/examples/imgui_impl_opengl3.cpp
+    )
+add_library(IMGUI "${IMGUI_SRCS}")
+target_compile_definitions(IMGUI PRIVATE "IMGUI_IMPL_OPENGL_LOADER_GLAD")
+target_compile_definitions(IMGUI PRIVATE "IMGUI_USE_STB_SPRINTF")
+message(STATUS "Compiling 'Dear ImGui' from https://github.com/ocornut/imgui.git -- ${IMGUI_INCLUDE_DIRS}")
+
+#
+# ImGui Color Text Editor
+#
+set(IMGUITEXTEDIT_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/ext/ImGuiColorTextEdit)
+include_directories(
     ${IMGUITEXTEDIT_INCLUDE_DIR}
-    ${TINYXML2_INCLUDE_DIR}
-    ${TINYFD_INCLUDE_DIR}
-    ${STB_INCLUDE_DIR}
-    ${DIRENT_INCLUDE_DIR}
-    ${OBJLOADER_INCLUDE_DIR}
+)
+add_library(IMGUITEXTEDIT "${CMAKE_CURRENT_SOURCE_DIR}/ext/ImGuiColorTextEdit/TextEditor.cpp")
+set_property(TARGET IMGUITEXTEDIT PROPERTY CXX_STANDARD 17)
+message(STATUS "Compiling 'ImGuiColorTextEdit' from https://github.com/BalazsJako/ImGuiColorTextEdit -- ${IMGUITEXTEDIT_INCLUDE_DIR}")
+
+
+#
+# OSCPack
+#
+if(UNIX)
+    set(OSCPACK_PLATFORM_DIR ${CMAKE_CURRENT_SOURCE_DIR}/ext/OSCPack/ip/posix/)
+elseif(WIN32)
+    set(OSCPACK_PLATFORM_DIR ${CMAKE_CURRENT_SOURCE_DIR}/ext/OSCPack/ip/win32/)
+endif()
+set(OSCPACK_SRCS
+    ${CMAKE_CURRENT_SOURCE_DIR}/ext/OSCPack/osc/OscTypes.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/ext/OSCPack/osc/OscReceivedElements.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/ext/OSCPack/osc/OscPrintReceivedElements.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/ext/OSCPack/osc/OscOutboundPacketStream.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/ext/OSCPack/ip/IpEndpointName.cpp
+    ${OSCPACK_PLATFORM_DIR}/NetworkingUtils.cpp
+    ${OSCPACK_PLATFORM_DIR}/UdpSocket.cpp
+)
+set(OSCPACK_LIBRARIES OSCPACK)
+set(OSCPACK_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/ext/OSCPack)
+include_directories(
+    ${OSCPACK_INCLUDE_DIR}
+)
+add_library(OSCPACK "${OSCPACK_SRCS}")
+message(STATUS "Compiling 'OSCPack' from http://www.rossbencina.com/code/oscpack -- ${OSCPACK_INCLUDE_DIR}")
+
+
+#####
+##### Ressources
+#####
+
+set(RSC_DIR ${CMAKE_CURRENT_SOURCE_DIR}/rsc)
+
+#
+# Fonts
+#
+
+file(GLOB_RECURSE ROBOTO_REGULAR "${RSC_DIR}/*/Roboto-Regular.ttf")
+if(NOT ROBOTO_REGULAR)
+    file(GLOB_RECURSE ROBOTO_REGULAR "/usr/share/fonts/*/Roboto-Regular.ttf")
+    message(STATUS "Copy ${ROBOTO_REGULAR} to ${RSC_DIR}/fonts")
+    file(COPY ${ROBOTO_REGULAR} DESTINATION ${RSC_DIR}/fonts)
+    set(ROBOTO_REGULAR "${RSC_DIR}/fonts/Roboto-Regular.ttf")
+endif()
+
+file(GLOB_RECURSE ROBOTO_BOLD "${RSC_DIR}/*/Roboto-Bold.ttf")
+if(NOT ROBOTO_BOLD)
+    file(GLOB_RECURSE ROBOTO_BOLD "/usr/share/fonts/*/Roboto-Bold.ttf")
+    message(STATUS "Copy ${ROBOTO_BOLD} to ${RSC_DIR}/fonts")
+    file(COPY ${ROBOTO_BOLD} DESTINATION ${RSC_DIR}/fonts)
+    set(ROBOTO_BOLD "${RSC_DIR}/fonts/Roboto-Bold.ttf")
+endif()
+
+file(GLOB_RECURSE ROBOTO_ITALIC "${RSC_DIR}/*/Roboto-Italic.ttf")
+if(NOT ROBOTO_ITALIC)
+    file(GLOB_RECURSE ROBOTO_ITALIC "/usr/share/fonts/*/Roboto-Italic.ttf")
+    message(STATUS "Copy ${ROBOTO_ITALIC} to ${RSC_DIR}/fonts")
+    file(COPY ${ROBOTO_ITALIC} DESTINATION ${RSC_DIR}/fonts)
+    set(ROBOTO_ITALIC "${RSC_DIR}/fonts/Roboto-Italic.ttf")
+endif()
+
+file(GLOB_RECURSE HACK_REGULAR "${RSC_DIR}/*/Hack-Regular.ttf")
+if(NOT HACK_REGULAR)
+    file(GLOB_RECURSE HACK_REGULAR "/usr/share/fonts/*/Hack-Regular.ttf")
+    message(STATUS "Copy ${HACK_REGULAR} to ${RSC_DIR}/fonts")
+    file(COPY ${HACK_REGULAR} DESTINATION ${RSC_DIR}/fonts)
+    set(HACK_REGULAR "${RSC_DIR}/fonts/Hack-Regular.ttf")
+endif()
+
+file(GLOB_RECURSE AWESOME_SOLID "${RSC_DIR}/*/fa-solid-900.ttf")
+if(NOT AWESOME_SOLID)
+    file(GLOB_RECURSE AWESOME_SOLID "/usr/share/fonts/*/fa-solid-900.ttf")
+    message(STATUS "Copy ${AWESOME_SOLID} to ${RSC_DIR}/fonts")
+    file(COPY ${AWESOME_SOLID} DESTINATION ${RSC_DIR}/fonts)
+    set(AWESOME_SOLID "${RSC_DIR}/fonts/fa-solid-900.ttf")
+endif()
+
+file(GLOB_RECURSE AWESOME_REGULAR "${RSC_DIR}/*/fa-regular-400.ttf")
+if(NOT AWESOME_REGULAR)
+    file(GLOB_RECURSE AWESOME_REGULAR "/usr/share/fonts/*/fa-regular-400.ttf")
+    message(STATUS "Copy ${AWESOME_REGULAR} to ${RSC_DIR}/fonts")
+    file(COPY ${AWESOME_REGULAR} DESTINATION ${RSC_DIR}/fonts)
+    set(AWESOME_REGULAR "${RSC_DIR}/fonts/fa-regular-400.ttf")
+endif()
+
+include_directories(
+    "${RSC_DIR}/fonts"
 )
 
 
-set(VMIX_BINARY "vimix")
-set(VMIX_SRCS
-    main.cpp
-    Log.cpp
-    Shader.cpp
-    ImageShader.cpp
-    ImageProcessingShader.cpp
-    UpdateCallback.cpp
-    Scene.cpp
-    Primitives.cpp
-    Mesh.cpp
-    Decorations.cpp
-    View.cpp
-    Source.cpp
-    Session.cpp
-    Selection.cpp
-    SessionSource.cpp
-    SessionVisitor.cpp
-    GarbageVisitor.cpp
-    SessionCreator.cpp
-    Mixer.cpp
-    Settings.cpp
-    Screenshot.cpp
-    Resource.cpp
-    FileDialog.cpp
-    MediaPlayer.cpp
-    MediaSource.cpp
-    FrameBuffer.cpp
-    RenderingManager.cpp
-    UserInterfaceManager.cpp
-    PickingVisitor.cpp
-    BoundingBoxVisitor.cpp
-    DrawVisitor.cpp
-    SearchVisitor.cpp
-    ImGuiToolkit.cpp
-    ImGuiVisitor.cpp
-    GstToolkit.cpp
-    GlmToolkit.cpp
-    SystemToolkit.cpp
-    tinyxml2Toolkit.cpp
-)
+#
+# CMake RC module
+#
 
+# Include the CMake RC module
+include(CMakeRC)
+message(STATUS "Using 'CMakeRC ' from https://github.com/vector-of-bool/cmrc.git -- ${CMAKE_MODULE_PATH}.")
+
+# set the files to package
 set(VMIX_RSC_FILES
+    ${ROBOTO_REGULAR}
+    ${ROBOTO_BOLD}
+    ${ROBOTO_ITALIC}
+    ${HACK_REGULAR}
+    ${AWESOME_REGULAR}
+    ${AWESOME_SOLID}
     ./rsc/shaders/simple.fs
     ./rsc/shaders/simple.vs
     ./rsc/shaders/image.fs
+    ./rsc/shaders/mask_elipse.fs
+    ./rsc/shaders/mask_box.fs
+    ./rsc/shaders/mask_round.fs
+    ./rsc/shaders/mask_horizontal.fs
+    ./rsc/shaders/mask_vertical.fs
+    ./rsc/shaders/mask_draw.fs
     ./rsc/shaders/image.vs
     ./rsc/shaders/imageprocessing.fs
-    ./rsc/fonts/Hack-Regular.ttf
-    ./rsc/fonts/Roboto-Regular.ttf
-    ./rsc/fonts/Roboto-Bold.ttf
-    ./rsc/fonts/Roboto-Italic.ttf
-    ./rsc/fonts/fa-regular-400.ttf
-    ./rsc/fonts/fa-solid-900.ttf
+    ./rsc/shaders/imageblending.fs
     ./rsc/images/mask_vignette.png
     ./rsc/images/mask_halo.png
     ./rsc/images/mask_glow.png
@@ -266,6 +493,7 @@ set(VMIX_RSC_FILES
     ./rsc/images/mask_linear_left.png
     ./rsc/images/mask_linear_right.png
     ./rsc/images/vimix_256x256.png
+    ./rsc/images/vimix_crow_white.png
     ./rsc/images/icons.dds
     ./rsc/images/gradient_0_cross_linear.png
     ./rsc/images/gradient_1_black_linear.png
@@ -274,180 +502,151 @@ set(VMIX_RSC_FILES
     ./rsc/images/transparencygrid.png
     ./rsc/images/shadow.dds
     ./rsc/images/glow.dds
+    ./rsc/images/checker.dds
     ./rsc/images/shadow_perspective.dds
+    ./rsc/images/soft_shadow.dds
     ./rsc/mesh/disk.ply
+    ./rsc/mesh/circle.ply
+    ./rsc/mesh/corner.ply
     ./rsc/mesh/shadow.ply
     ./rsc/mesh/glow.ply
-    ./rsc/mesh/target.ply
+    ./rsc/mesh/border_round_left.ply
     ./rsc/mesh/border_round.ply
     ./rsc/mesh/border_top.ply
+    ./rsc/mesh/border_perspective_round_left.ply
+    ./rsc/mesh/border_perspective_round.ply
+    ./rsc/mesh/border_perspective_top.ply
     ./rsc/mesh/border_sharp.ply
+    ./rsc/mesh/border_large_round_left.ply
     ./rsc/mesh/border_large_round.ply
     ./rsc/mesh/border_large_top.ply
     ./rsc/mesh/border_handles_rotation.ply
+    ./rsc/mesh/border_handles_scale.ply
     ./rsc/mesh/border_handles_overlay.ply
+    ./rsc/mesh/border_handles_overlay_filled.ply
     ./rsc/mesh/border_handles_sharp.ply
+    ./rsc/mesh/border_handles_menu.ply
+    ./rsc/mesh/border_handles_crop.ply
+    ./rsc/mesh/border_handles_lock.ply
+    ./rsc/mesh/border_handles_lock_open.ply
+    ./rsc/mesh/border_handles_shadow.ply
     ./rsc/mesh/border_large_sharp.ply
     ./rsc/mesh/border_vertical_overlay.ply
     ./rsc/mesh/perspective_layer.ply
+    ./rsc/mesh/perspective_axis_left.ply
+    ./rsc/mesh/perspective_axis_right.ply
     ./rsc/mesh/shadow_perspective.ply
     ./rsc/mesh/point.ply
-    ./rsc/mesh/circle.ply
+    ./rsc/mesh/square_point.ply
+    ./rsc/mesh/triangle_point.ply
     ./rsc/mesh/icon_video.ply
     ./rsc/mesh/icon_image.ply
     ./rsc/mesh/icon_render.ply
+    ./rsc/mesh/icon_gear.ply
+    ./rsc/mesh/icon_camera.ply
+    ./rsc/mesh/icon_share.ply
     ./rsc/mesh/icon_clone.ply
     ./rsc/mesh/icon_vimix.ply
+    ./rsc/mesh/icon_group_vimix.ply
     ./rsc/mesh/icon_circles.ply
     ./rsc/mesh/icon_dots.ply
     ./rsc/mesh/icon_empty.ply
+    ./rsc/mesh/icon_lock.ply
+    ./rsc/mesh/icon_unlock.ply
+    ./rsc/mesh/icon_circle.ply
+    ./rsc/mesh/icon_square.ply
+    ./rsc/mesh/icon_cross.ply
+    ./rsc/mesh/icon_clock.ply
+    ./rsc/mesh/icon_clock_hand.ply
+    ./rsc/mesh/icon_grid.ply
+    ./rsc/mesh/icon_rightarrow.ply
+    ./rsc/mesh/icon_crop.ply
+    ./rsc/mesh/icon_eye.ply
+    ./rsc/mesh/icon_eye_slash.ply
+    ./rsc/mesh/icon_tv.ply
+    ./rsc/mesh/icon_cube.ply
+    ./rsc/mesh/icon_sequence.ply
+    ./rsc/mesh/icon_receive.ply
     ./rsc/mesh/h_line.ply
     ./rsc/mesh/h_mark.ply
+    ./rsc/shaders/filters/default.glsl
+    ./rsc/shaders/filters/bloom.glsl
+    ./rsc/shaders/filters/bokeh.glsl
+    ./rsc/shaders/filters/talk.glsl
+    ./rsc/shaders/filters/fisheye.glsl
+    ./rsc/shaders/filters/blur.glsl
+    ./rsc/shaders/filters/blur_1.glsl
+    ./rsc/shaders/filters/blur_2.glsl
+    ./rsc/shaders/filters/lens_1.glsl
+    ./rsc/shaders/filters/lens_2.glsl
+    ./rsc/shaders/filters/hashedblur.glsl
+    ./rsc/shaders/filters/circularblur.glsl
+    ./rsc/shaders/filters/hashederosion.glsl
+    ./rsc/shaders/filters/hasheddilation.glsl
+    ./rsc/shaders/filters/sharp.glsl
+    ./rsc/shaders/filters/sharpen.glsl
+    ./rsc/shaders/filters/sharpen_1.glsl
+    ./rsc/shaders/filters/sharpen_2.glsl
+    ./rsc/shaders/filters/contour_2.glsl
+    ./rsc/shaders/filters/sharpenedge.glsl
+    ./rsc/shaders/filters/chromakey.glsl
+    ./rsc/shaders/filters/lumakey.glsl
+    ./rsc/shaders/filters/coloralpha.glsl
+    ./rsc/shaders/filters/bilinear.glsl
+    ./rsc/shaders/filters/edge.glsl
+    ./rsc/shaders/filters/sobel.glsl
+    ./rsc/shaders/filters/freichen.glsl
+    ./rsc/shaders/filters/kuwahara.glsl
+    ./rsc/shaders/filters/pixelate.glsl
+    ./rsc/shaders/filters/focus.glsl
+    ./rsc/shaders/filters/denoise.glsl
+    ./rsc/shaders/filters/noise.glsl
+    ./rsc/shaders/filters/grain.glsl
+    ./rsc/shaders/filters/stippling.glsl
+    ./rsc/shaders/filters/dithering.glsl
+    ./rsc/shaders/filters/erosion.glsl
+    ./rsc/shaders/filters/dilation.glsl
+    ./rsc/shaders/filters/tophat.glsl
+    ./rsc/shaders/filters/blackhat.glsl
+    ./rsc/shaders/filters/resample_double.glsl
+    ./rsc/shaders/filters/resample_half.glsl
+    ./rsc/shaders/filters/resample_quarter.glsl
+    ./rsc/shaders/filters/earlybird.glsl
+    ./rsc/shaders/filters/logo.glsl
+    ./rsc/shaders/filters/whitebalance.glsl
 )
 
-### DEFINE THE TARGET (OS specific)
-
-IF(APPLE)
-
-    # set icon
-    set(MACOSX_BUNDLE_ICON vimix.icns)
-    set(MACOSX_BUNDLE_ICON_FILE ${CMAKE_SOURCE_DIR}/osx/${MACOSX_BUNDLE_ICON})
-    # set where in the bundle to put the icns file
-    set_source_files_properties(${MACOSX_BUNDLE_ICON_FILE} PROPERTIES MACOSX_PACKAGE_LOCATION Resources)
-
-    # create the application
-    add_executable(${VMIX_BINARY} MACOSX_BUNDLE
-        ${VMIX_SRCS}
-        ${IMGUITEXTEDIT_SRC}
-        ${MACOSX_BUNDLE_ICON_FILE}
-    )
-
-    # set the Info.plist file
-    set(MACOSX_BUNDLE_PLIST_FILE ${CMAKE_SOURCE_DIR}/osx/Info.plist)
-    set_target_properties(${VMIX_BINARY} PROPERTIES MACOSX_BUNDLE_INFO_PLIST ${MACOSX_BUNDLE_PLIST_FILE})
-
-ELSE(APPLE)
-
-    add_executable(${VMIX_BINARY}
-        ${VMIX_SRCS}
-        ${IMGUITEXTEDIT_SRC}
-    )
-
-ENDIF(APPLE)
-
-
-### COMPILE THE TARGET (all OS)
-
-set_property(TARGET ${VMIX_BINARY} PROPERTY CXX_STANDARD 17)
-set_property(TARGET ${VMIX_BINARY} PROPERTY C_STANDARD 11)
-
-target_compile_definitions(${VMIX_BINARY} PUBLIC "IMGUI_IMPL_OPENGL_LOADER_GLAD")
-
 cmrc_add_resource_library(vmix-resources ALIAS vmix::rc NAMESPACE vmix WHENCE rsc ${VMIX_RSC_FILES})
-message(STATUS "Using 'CMakeRC ' from https://github.com/vector-of-bool/cmrc.git -- ${CMAKE_MODULE_PATH}.")
 
 
-target_link_libraries(${VMIX_BINARY} LINK_PRIVATE 
-    ${GLFW_LIBRARY}
-    ${OPENGL_LIBRARY}
-    GLAD
-    ${CMAKE_DL_LIBS}
-    ${GOBJECT_LIBRARIES}
-    ${GSTREAMER_LIBRARY}
-    ${GSTREAMER_BASE_LIBRARY}
-    ${GSTREAMER_APP_LIBRARY}
-    ${GSTREAMER_AUDIO_LIBRARY}
-    ${GSTREAMER_VIDEO_LIBRARY}
-    ${GSTREAMER_PBUTILS_LIBRARY}
-    ${GSTREAMER_GL_LIBRARY}
-    ${GSTREAMER_PLAYER_LIBRARY}
-    ${NFD_LIBRARY}
-    ${PNG_LIBRARY}
-    ${THREAD_LIBRARY}
-    TINYXML2
-    TINYFD
-    IMGUI
-    glm::glm
-    vmix::rc
-)
-
-macro_display_feature_log()
-
-
-### DEFINE THE PACKAGING (all OS)
+#####
+##### DEFINE THE PACKAGING (all OS)
+#####
 
 SET(CPACK_PACKAGE_NAME "vimix")
-SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY "vimix\n Real-time video mixing for live performance.")
+SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY "vimix\nReal-time video mixing for live performance.")
 SET(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_SOURCE_DIR}/README.md")
-SET(CPACK_PACKAGE_CONTACT "bruno.herbelin@gmail.com")
 SET(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_SOURCE_DIR}/COPYING.txt")
-SET(CPACK_PACKAGE_VERSION_MAJOR "0")
-SET(CPACK_PACKAGE_VERSION_MINOR "1")
-#SET(CPACK_PACKAGE_VERSION_PATCH "${GLMIXER_WC_REVISION}")
+SET(CPACK_PACKAGE_CONTACT "bruno.herbelin@gmail.com")
+SET(CPACK_PACKAGE_HOMEPAGE_URL "https://brunoherbelin.github.io/vimix")
+SET(CPACK_PACKAGE_VERSION_MAJOR "${VIMIX_VERSION_MAJOR}")
+SET(CPACK_PACKAGE_VERSION_MINOR "${VIMIX_VERSION_MINOR}")
+SET(CPACK_PACKAGE_VERSION_PATCH "${VIMIX_VERSION_PATCH}")
 SET(CPACK_PACKAGE_VENDOR "Bruno Herbelin")
 SET(CPACK_SOURCE_IGNORE_FILES
     "/\\\\.git/"
     "/\\\\.gitignore$"
     "/\\\\.gitmodules$"
 )
+set(CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME}_${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH}_${CPACK_SYSTEM_NAME}")
+set(CPACK_STRIP_FILES TRUE)
 
 
-### DEFINE THE PACKAGING (OS specific)
+#####
+##### Build Application
+#####
+add_subdirectory(src)
 
-IF(APPLE)
-
-    # Bundle target
-    set(CPACK_GENERATOR "DragNDrop")
-
-    # OSX cpack info
-    set(CPACK_SYSTEM_NAME  "OSX_${CMAKE_OSX_DEPLOYMENT_TARGET}_${CMAKE_OSX_ARCHITECTURES}")
-    set(CPACK_BUNDLE_NAME  ${CPACK_PACKAGE_NAME})
-    set(CPACK_BUNDLE_ICON  ${MACOSX_BUNDLE_ICON_FILE})
-    set(CPACK_BUNDLE_PLIST ${MACOSX_BUNDLE_PLIST_FILE})
-
-    set(APPS "\${CMAKE_INSTALL_PREFIX}/vimix.app")
-    #    set( APPS "\$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/vimix${CMAKE_EXECUTABLE_SUFFIX}")
-
-    install(TARGETS ${VMIX_BINARY}
-            CONFIGURATIONS Release RelWithDebInfo
-            BUNDLE  DESTINATION . COMPONENT Runtime
-            RUNTIME DESTINATION bin COMPONENT Runtime
-    )
-
-    set(plugin_dest_dir vimix.app/Contents/MacOS/)
-    install(DIRECTORY "${PKG_GSTREAMER_PLUGIN_DIR}" DESTINATION "${plugin_dest_dir}" COMPONENT Runtime)
-    install(DIRECTORY "/usr/local/Cellar/gst-plugins-base/1.16.2/lib/gstreamer-1.0" DESTINATION "${plugin_dest_dir}" COMPONENT Runtime)
-    install(DIRECTORY "/usr/local/Cellar/gst-plugins-good/1.16.2/lib/gstreamer-1.0" DESTINATION "${plugin_dest_dir}" COMPONENT Runtime)
-    install(DIRECTORY "/usr/local/Cellar/gst-plugins-bad/1.16.2_3/lib/gstreamer-1.0" DESTINATION "${plugin_dest_dir}" COMPONENT Runtime)
-    install(DIRECTORY "/usr/local/Cellar/gst-plugins-ugly/1.16.2_1/lib/gstreamer-1.0" DESTINATION "${plugin_dest_dir}" COMPONENT Runtime)
-    install(DIRECTORY "/usr/local/Cellar/gst-libav/1.16.2/lib/gstreamer-1.0" DESTINATION "${plugin_dest_dir}" COMPONENT Runtime)
-
-    # package runtime fixup bundle
-    install(CODE "
-            file(GLOB_RECURSE GSTPLUGINS \"\${CMAKE_INSTALL_PREFIX}/${plugin_dest_dir}/gstreamer-1.0/*.so\")
-            include(BundleUtilities)
-            set(BU_CHMOD_BUNDLE_ITEMS TRUE)
-            fixup_bundle(\"${APPS}\" \"\${GSTPLUGINS}\" \"\")
-            "
-            COMPONENT Runtime
-    )
-
-    set(CPACK_BINARY_DRAGNDROP ON)
-
-ELSE(APPLE)
-
-    set(APPS "\${CMAKE_INSTALL_PREFIX}/bin/vimix")
-
-    install(TARGETS ${VMIX_BINARY}
-            CONFIGURATIONS Release RelWithDebInfo
-            RUNTIME DESTINATION bin COMPONENT Runtime
-    )
-
-
-ENDIF(APPLE)
-
-# Package full name
-set(CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME}_${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}_${CPACK_SYSTEM_NAME}")
 
 # To Create a package, run "cpack"
 include(CPack)

CODE_OF_CONDUCT.md

@@ -0,0 +1,128 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, religion, or sexual identity
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the
+  overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+.
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series
+of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or
+permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior,  harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within
+the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.0, available at
+https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct
+enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at
+https://www.contributor-covenant.org/translations.

Decorations.cpp

@@ -1,409 +0,0 @@
-#include <glm/gtc/matrix_transform.hpp>
-#include <glm/gtx/vector_angle.hpp>
-#include <glm/gtx/component_wise.hpp>
-
-#include "Decorations.h"
-
-#include "Visitor.h"
-#include "BoundingBoxVisitor.h"
-#include "ImageShader.h"
-#include "GlmToolkit.h"
-#include "Log.h"
-
-
-Frame::Frame(CornerType corner, BorderType border, ShadowType shadow) : Node(), side_(nullptr), top_(nullptr), shadow_(nullptr), square_(nullptr)
-{
-    static Mesh *shadows[3] = {nullptr};
-    if (shadows[0] == nullptr)  {
-        shadows[0] = new Mesh("mesh/glow.ply", "images/glow.dds");
-        shadows[1] = new Mesh("mesh/shadow.ply", "images/shadow.dds");
-        shadows[2] = new Mesh("mesh/shadow_perspective.ply", "images/shadow_perspective.dds");
-    }
-    static Mesh *frames[4] = {nullptr};
-    if (frames[0] == nullptr)  {
-        frames[0] = new Mesh("mesh/border_round.ply");
-        frames[1] = new Mesh("mesh/border_top.ply");
-        frames[2] = new Mesh("mesh/border_large_round.ply");
-        frames[3] = new Mesh("mesh/border_large_top.ply");
-    }
-    static LineSquare *sharpframethin = new LineSquare( 3 );
-    static LineSquare *sharpframelarge = new LineSquare( 5 );
-
-    if (corner == SHARP) {
-        if (border == LARGE)
-            square_ = sharpframelarge;
-        else
-            square_ = sharpframethin;
-    }
-    else {
-        // Round corners
-        if (border == THIN) {
-            side_  = frames[0];
-            top_   = frames[1];
-        }
-        else{
-            side_  = frames[2];
-            top_   = frames[3];
-        }
-    }
-
-    switch (shadow) {
-    default:
-    case NONE:
-        break;
-    case GLOW:
-        shadow_ = shadows[0];
-        break;
-    case DROP:
-        shadow_ = shadows[1];
-        break;
-    case PERSPECTIVE:
-        shadow_ = shadows[2];
-        break;
-    }
-
-//    switch (type) {
-//    case SHARP_LARGE:
-//        square_ = sharpframe;
-//        shadow_ = shadows[0];
-//        break;
-//    case SHARP_THIN:
-//        square_ = sharpframe;
-//        break;
-//    case ROUND_LARGE:
-//        side_  = frames[2];
-//        top_   = frames[3];
-//        shadow_ = shadows[1];
-//        break;
-//    default:
-//    case ROUND_THIN:
-//        side_  = frames[0];
-//        top_   = frames[1];
-//        shadow_ = shadows[1];
-//        break;
-//    case ROUND_THIN_PERSPECTIVE:
-//        side_  = frames[0];
-//        top_   = frames[1];
-//        shadow_ = shadows[2];
-//        break;
-//    }
-
-    color = glm::vec4( 1.f, 1.f, 1.f, 1.f);
-}
-
-Frame::~Frame()
-{
-
-}
-
-void Frame::update( float dt )
-{
-    Node::update(dt);
-    if(top_)
-        top_->update(dt);
-    if(side_)
-        side_->update(dt);
-    if(shadow_)
-        shadow_->update(dt);
-    if(square_)
-        square_->update(dt);
-}
-
-void Frame::draw(glm::mat4 modelview, glm::mat4 projection)
-{
-    if ( !initialized() ) {
-        if(side_  && !side_->initialized())
-            side_->init();
-        if(top_  && !top_->initialized())
-            top_->init();
-        if(shadow_ && !shadow_->initialized())
-            shadow_->init();
-        if(square_ && !square_->initialized())
-            square_->init();
-        init();
-    }
-
-    if ( visible_ ) {
-
-        glm::mat4 ctm = modelview * transform_;
-
-        // shadow (scaled)
-        if(shadow_){
-            shadow_->shader()->color.a = 0.98f;
-            shadow_->draw( ctm, projection);
-        }
-
-        // top (scaled)
-        if(top_) {
-            top_->shader()->color = color;
-            top_->draw( ctm, projection);
-        }
-
-        // top (scaled)
-        if(square_) {
-            square_->shader()->color = color;
-            square_->draw( ctm, projection);
-        }
-
-        if(side_) {
-
-            side_->shader()->color = color;
-
-            // get scale
-            glm::vec4 scale = ctm * glm::vec4(1.f, 1.0f, 0.f, 0.f);
-
-            // get rotation
-            glm::vec3 rot(0.f);
-            glm::vec4 vec = ctm * glm::vec4(1.f, 0.f, 0.f, 0.f);
-            rot.z = glm::orientedAngle( glm::vec3(1.f, 0.f, 0.f), glm::normalize(glm::vec3(vec)), glm::vec3(0.f, 0.f, 1.f) );
-
-            if(side_) {
-
-                // left side
-                vec = ctm * glm::vec4(1.f, 0.f, 0.f, 1.f);
-                side_->draw( GlmToolkit::transform(vec, rot, glm::vec3(scale.y, scale.y, 1.f)), projection );
-
-                // right side
-                vec = ctm * glm::vec4(-1.f, 0.f, 0.f, 1.f);
-                side_->draw( GlmToolkit::transform(vec, rot, glm::vec3(-scale.y, scale.y, 1.f)), projection );
-
-            }
-        }
-    }
-}
-
-
-void Frame::accept(Visitor& v)
-{
-    Node::accept(v);
-    v.visit(*this);
-}
-
-Handles::Handles(Type type) : Node(), type_(type)
-{
-    static Mesh *handle_rotation_ = new Mesh("mesh/border_handles_rotation.ply");
-    static Mesh *handle_corner    = new Mesh("mesh/border_handles_overlay.ply");
-
-    color   = glm::vec4( 1.f, 1.f, 0.f, 1.f);
-    if ( type_ == ROTATE ) {
-        handle_ = handle_rotation_;
-    }
-    else {
-        handle_ = handle_corner;
-    }
-
-}
-
-Handles::~Handles()
-{
-}
-
-void Handles::update( float dt )
-{
-    Node::update(dt);
-    handle_->update(dt);
-}
-
-void Handles::draw(glm::mat4 modelview, glm::mat4 projection)
-{
-    if ( !initialized() ) {
-        if(handle_ && !handle_->initialized())
-            handle_->init();
-        init();
-    }
-
-    if ( visible_ ) {
-
-        // set color
-        handle_->shader()->color = color;
-
-        glm::mat4 ctm;
-        glm::vec3 rot(0.f);
-        glm::vec4 vec = modelview * glm::vec4(1.f, 0.f, 0.f, 0.f);
-        rot.z = glm::orientedAngle( glm::vec3(1.f, 0.f, 0.f), glm::normalize(glm::vec3(vec)), glm::vec3(0.f, 0.f, 1.f) );
-//        vec = modelview * glm::vec4(0.f, 1.f, 0.f, 1.f);
-//        glm::vec3 scale( vec.x > 0.f ? 1.f : -1.f, vec.y > 0.f ? 1.f : -1.f, 1.f);
-//        glm::vec3 scale(1.f, 1.f, 1.f);
-
-//        Log::Info(" (0,1) becomes (%f, %f)", scale.x, scale.y);
-
-        if ( type_ == RESIZE ) {
-
-            // 4 corners
-            vec = modelview * glm::vec4(1.f, -1.f, 0.f, 1.f);
-            ctm = GlmToolkit::transform(vec, rot, glm::vec3(1.f));
-            handle_->draw( ctm, projection );
-
-            vec = modelview * glm::vec4(1.f, 1.f, 0.f, 1.f);
-            ctm = GlmToolkit::transform(vec, rot, glm::vec3(1.f));
-            handle_->draw( ctm, projection );
-
-            vec = modelview * glm::vec4(-1.f, -1.f, 0.f, 1.f);
-            ctm = GlmToolkit::transform(vec, rot, glm::vec3(1.f));
-            handle_->draw( ctm, projection );
-
-            vec = modelview * glm::vec4(-1.f, 1.f, 0.f, 1.f);
-            ctm = GlmToolkit::transform(vec, rot, glm::vec3(1.f));
-            handle_->draw( ctm, projection );
-        }
-        else if ( type_ == RESIZE_H ){
-            // left and right
-            vec = modelview * glm::vec4(1.f, 0.f, 0.f, 1.f);
-            ctm = GlmToolkit::transform(vec, rot, glm::vec3(1.f));
-            handle_->draw( ctm, projection );
-
-            vec = modelview * glm::vec4(-1.f, 0.f, 0.f, 1.f);
-            ctm = GlmToolkit::transform(vec, rot, glm::vec3(1.f));
-            handle_->draw( ctm, projection );
-        }
-        else if ( type_ == RESIZE_V ){
-            // top and bottom
-            vec = modelview * glm::vec4(0.f, 1.f, 0.f, 1.f);
-            ctm = GlmToolkit::transform(vec, rot, glm::vec3(1.f));
-            handle_->draw( ctm, projection );
-
-            vec = modelview * glm::vec4(0.f, -1.f, 0.f, 1.f);
-            ctm = GlmToolkit::transform(vec, rot, glm::vec3(1.f));
-            handle_->draw( ctm, projection );
-        }
-        else if ( type_ == ROTATE ){
-            // one icon in top right corner
-            // 1. Fixed displacement by (0.12,0.12) along the rotation..
-            ctm = GlmToolkit::transform(glm::vec4(0.f), rot, glm::vec3(1.f));
-            glm::vec4 pos = ctm * glm::vec4(0.12f, 0.12f, 0.f, 1.f);
-//            Log::Info(" (0.12,0.12) becomes (%f, %f)", pos.x, pos.y);
-            // 2. ..from the top right corner (1,1)
-            vec = ( modelview * glm::vec4(1.f, 1.f, 0.f, 1.f) ) + pos;
-            ctm = GlmToolkit::transform(vec, rot, glm::vec3(1.f));
-
-// TODO fix problem with negative scale
-//            glm::vec4 target = modelview * glm::vec4(1.2f, 1.2f, 0.f, 1.f);
-
-//            vec = modelview * glm::vec4(1.f, 1.f, 0.f, 1.f);
-//            glm::vec4 dv = target - vec;
-
-//            Log::Info("dv  (%f, %f)", dv.x, dv.y);
-//            float m = dv.x < dv.y ? dv.x : dv.y;
-//            Log::Info("min  %f", m);
-
-//            ctm = GlmToolkit::transform( glm::vec3(target), rot, glm::vec3(1.f));
-
-            handle_->draw( ctm, projection );
-        }
-    }
-}
-
-
-void Handles::accept(Visitor& v)
-{
-    Node::accept(v);
-    v.visit(*this);
-}
-
-
-Symbol::Symbol(Type t, glm::vec3 pos) : Node(), type_(t)
-{
-    static Mesh *icons[9] = {nullptr};
-    if (icons[0] == nullptr)  {
-        icons[POINT]   = new Mesh("mesh/point.ply");
-        icons[IMAGE]   = new Mesh("mesh/icon_image.ply");
-        icons[VIDEO]   = new Mesh("mesh/icon_video.ply");
-        icons[SESSION] = new Mesh("mesh/icon_vimix.ply");
-        icons[CLONE]   = new Mesh("mesh/icon_clone.ply");
-        icons[RENDER]  = new Mesh("mesh/icon_render.ply");
-        icons[DOTS]    = new Mesh("mesh/icon_dots.ply");
-        icons[CIRCLES] = new Mesh("mesh/icon_circles.ply");
-        icons[EMPTY]   = new Mesh("mesh/icon_empty.ply");
-    }
-
-    symbol_ = icons[type_];
-    translation_ = pos;
-    color = glm::vec4( 1.f, 1.f, 1.f, 1.f);
-}
-
-Symbol::~Symbol()
-{
-
-}
-
-void Symbol::draw(glm::mat4 modelview, glm::mat4 projection)
-{
-    if ( !initialized() ) {
-        if(symbol_ && !symbol_->initialized())
-            symbol_->init();
-        init();
-    }
-
-    if ( visible_ && symbol_) {
-
-        // set color
-        symbol_->shader()->color = color;
-
-        glm::mat4 ctm = modelview * transform_;
-        // correct for aspect ratio
-        glm::vec4 vec = ctm * glm::vec4(1.f, 1.0f, 0.f, 0.f);
-        ctm *= glm::scale(glm::identity<glm::mat4>(), glm::vec3( vec.y / vec.x, 1.f, 1.f));
-
-        symbol_->draw( ctm, projection);
-    }
-}
-
-
-void Symbol::accept(Visitor& v)
-{
-    Node::accept(v);
-    v.visit(*this);
-}
-
-
-SelectionBox::SelectionBox()
-{
-//    color = glm::vec4( 1.f, 1.f, 1.f, 1.f);
-    color = glm::vec4( 1.f, 0.f, 0.f, 1.f);
-    square_ = new LineSquare( 3 );
-
-}
-
-void SelectionBox::draw (glm::mat4 modelview, glm::mat4 projection)
-{
-    if ( !initialized() ) {
-        square_->init();
-        init();
-    }
-
-    if (visible_) {
-
-        // use a visitor bounding box to calculate extend of all selected nodes
-        BoundingBoxVisitor vbox;
-
-        // visit every child of the selection
-        for (NodeSet::iterator node = children_.begin();
-             node != children_.end(); node++) {
-            // reset the transform before
-            vbox.setModelview(glm::identity<glm::mat4>());
-            (*node)->accept(vbox);
-        }
-
-        // get the bounding box
-        bbox_ = vbox.bbox();
-
-//        Log::Info("                                       -------- visitor box (%f, %f)-(%f, %f)", bbox_.min().x, bbox_.min().y, bbox_.max().x, bbox_.max().y);
-
-        // set color
-        square_->shader()->color = color;
-
-        // compute transformation from bounding box
-//        glm::mat4 ctm = modelview * GlmToolkit::transform(glm::vec3(0.f), glm::vec3(0.f), glm::vec3(1.f));
-        glm::mat4 ctm = modelview * GlmToolkit::transform(bbox_.center(), glm::vec3(0.f), bbox_.scale());
-
-        // draw bbox
-//        square_->draw( modelview, projection);
-        square_->draw( ctm, projection);
-
-        // DEBUG
-//        visible_=false;
-    }
-
-}
-
-

Decorations.h

@@ -1,91 +0,0 @@
-#ifndef DECORATIONS_H
-#define DECORATIONS_H
-
-
-#include <string>
-#include <glm/glm.hpp>
-
-#include "Primitives.h"
-#include "Mesh.h"
-
-class Frame : public Node
-{
-public:
-
-    typedef enum { ROUND = 0, SHARP } CornerType;
-    typedef enum { THIN = 0, LARGE } BorderType;
-    typedef enum { NONE = 0, GLOW, DROP, PERSPECTIVE } ShadowType;
-
-    Frame(CornerType corner, BorderType border, ShadowType shadow);
-    ~Frame();
-
-    void update (float dt) override;
-    void draw (glm::mat4 modelview, glm::mat4 projection) override;
-    void accept (Visitor& v) override;
-
-    Mesh *border() const { return side_; }
-    glm::vec4 color;
-
-protected:
-    Mesh *side_;
-    Mesh *top_;
-    Mesh *shadow_;
-    LineSquare *square_;
-};
-
-class Handles : public Node
-{
-public:
-    typedef enum { RESIZE = 0, RESIZE_H, RESIZE_V, ROTATE } Type;
-    Handles(Type type);
-    ~Handles();
-
-    void update (float dt) override;
-    void draw (glm::mat4 modelview, glm::mat4 projection) override;
-    void accept (Visitor& v) override;
-
-    Type type() const { return type_; }
-    Primitive *handle() const { return handle_; }
-    glm::vec4 color;
-
-protected:
-    Primitive *handle_;
-    Type type_;
-
-};
-
-class Symbol : public Node
-{
-public:
-    typedef enum { POINT = 0, IMAGE, VIDEO, SESSION, CLONE, RENDER, DOTS, CIRCLES, EMPTY } Type;
-    Symbol(Type t = POINT, glm::vec3 pos = glm::vec3(0.f));
-    ~Symbol();
-
-    void draw (glm::mat4 modelview, glm::mat4 projection) override;
-    void accept (Visitor& v) override;
-
-    Type type() const { return type_; }
-    glm::vec4 color;
-
-protected:
-    Mesh *symbol_;
-    Type type_;
-};
-
-class SelectionBox : public Group
-{
-public:
-    SelectionBox();
-
-    void draw (glm::mat4 modelview, glm::mat4 projection) override;
-
-    glm::vec4 color;
-
-protected:
-    LineSquare *square_;
-    GlmToolkit::AxisAlignedBoundingBox bbox_;
-
-};
-
-
-#endif // DECORATIONS_H

DrawVisitor.cpp

@@ -1,76 +0,0 @@
-
-#include <glm/gtc/matrix_transform.hpp>
-
-#include "defines.h"
-#include "DrawVisitor.h"
-#include "Scene.h"
-
-
-DrawVisitor::DrawVisitor(Node *nodetodraw, glm::mat4 projection)
-{
-    target_ = nodetodraw;
-    modelview_ = glm::identity<glm::mat4>();
-    projection_ = projection;
-    done_ = false;
-    num_duplicat_ = 1;
-    transform_duplicat_ = glm::identity<glm::mat4>();
-}
-
-
-void DrawVisitor::loop(int num, glm::mat4 transform)
-{
-    num_duplicat_ = CLAMP(num, 1, 10000);
-    transform_duplicat_ = transform;
-}
-
-void DrawVisitor::visit(Node &n)
-{
-    // draw the target
-    if ( n.id() == target_->id()) {
-
-        for (int i = 0; i < num_duplicat_; ++i) {
-            // draw multiple copies if requested
-            n.draw(modelview_, projection_);
-            modelview_ *= transform_duplicat_;
-        }
-
-        done_ = true;
-    }
-
-    if (done_) return;
-
-    // update transform
-    modelview_ *= n.transform_;
-}
-
-
-void DrawVisitor::visit(Group &n)
-{
-    // no need to traverse deeper if this node was drawn already
-    if (done_) return;
-
-    // traverse children
-    glm::mat4 mv = modelview_;
-    for (NodeSet::iterator node = n.begin(); !done_ && node != n.end(); node++) {
-        if ( (*node)->visible_ )
-            (*node)->accept(*this);
-        modelview_ = mv;
-    }
-}
-
-void DrawVisitor::visit(Scene &n)
-{
-    n.root()->accept(*this);
-}
-
-void DrawVisitor::visit(Switch &n)
-{
-    glm::mat4 mv = modelview_;
-    n.activeChild()->accept(*this);
-    modelview_ = mv;
-}
-
-void DrawVisitor::visit(Primitive &n)
-{
-
-}

FileDialog.h

@@ -1,119 +0,0 @@
-#ifndef __IMGUI_FILE_DIALOG_H_
-#define __IMGUI_FILE_DIALOG_H_
-
-#include "imgui.h"
-
-#include <vector>
-#include <string>
-#include <map>
-
-#include <future>
-#include <functional>
-#include <thread>
-#include <atomic>
-#include <mutex>
-#include <string>
-#include <vector>
-#include <list>
-
-#define MAX_FILE_DIALOG_NAME_BUFFER 1024
-
-struct FileInfoStruct
-{
-	char type = ' ';
-	std::string filePath;
-	std::string fileName;
-	std::string ext;
-};
-
-class FileDialog
-{
-private:
-	std::vector<FileInfoStruct> m_FileList;
-	std::map<std::string, ImVec4> m_FilterColor;
-	std::string m_SelectedFileName;
-	std::string m_SelectedExt;
-	std::string m_CurrentPath;
-	std::vector<std::string> m_CurrentPath_Decomposition;
-	std::string m_Name;
-	bool m_ShowDialog;
-	bool m_ShowDrives;
-
-public:
-	static char FileNameBuffer[MAX_FILE_DIALOG_NAME_BUFFER];
-	static char DirectoryNameBuffer[MAX_FILE_DIALOG_NAME_BUFFER];
-	static char SearchBuffer[MAX_FILE_DIALOG_NAME_BUFFER];
-	static int FilterIndex;
-	bool IsOk;
-	bool m_AnyWindowsHovered;
-	bool m_CreateDirectoryMode;
-
-private:
-	std::string dlg_key;
-	std::string dlg_name;
-	const char *dlg_filters;
-	std::string dlg_path;
-	std::string dlg_defaultFileName;
-	std::string dlg_defaultExt;
-	std::function<void(std::string, bool*)> dlg_optionsPane;
-	size_t dlg_optionsPaneWidth;
-	std::string searchTag;
-	std::string dlg_userString;
-
-public:
-	static FileDialog* Instance()
-	{
-		static FileDialog *_instance = new FileDialog();
-		return _instance;
-	}
-
-    static void RenderCurrent();
-    // Open an Open File dialog for TEXT file
-    static void SetCurrentOpenText();
-    // Open an Open File dialog for IMAGE file
-    static void SetCurrentOpenImage();
-    // Open an Open File dialog for MEDIA file
-    static void SetCurrentOpenMedia();
-
-protected:
-
-	FileDialog(); // Prevent construction
-	FileDialog(const FileDialog&) {}; // Prevent construction by copying
-	FileDialog& operator =(const FileDialog&) { return *this; }; // Prevent assignment
-	~FileDialog(); // Prevent unwanted destruction
-
-public:
-	void OpenDialog(const std::string& vKey, const char* vName, const char* vFilters,
-		const std::string& vPath, const std::string& vDefaultFileName,
-		std::function<void(std::string, bool*)> vOptionsPane, size_t vOptionsPaneWidth = 250, const std::string& vUserString = "");
-	void OpenDialog(const std::string& vKey, const char* vName, const char* vFilters,
-		const std::string& vDefaultFileName,
-		std::function<void(std::string, bool*)> vOptionsPane, size_t vOptionsPaneWidth = 250, const std::string& vUserString = "");
-	void OpenDialog(const std::string& vKey, const char* vName, const char* vFilters,
-		const std::string& vPath, const std::string& vDefaultFileName, const std::string& vUserString = "");
-	void OpenDialog(const std::string& vKey, const char* vName, const char* vFilters,
-		const std::string& vFilePathName, const std::string& vUserString = "");
-
-	void CloseDialog(const std::string& vKey);
-	bool Render(const std::string& vKey, ImVec2 geometry);
-	std::string GetFilepathName();
-	std::string GetCurrentPath();
-	std::string GetCurrentFileName();
-	std::string GetCurrentFilter();
-	std::string GetUserString();
-
-	void SetFilterColor(std::string vFilter, ImVec4 vColor);
-    bool GetFilterColor(std::string vFilter, ImVec4 *vColor);
-    void ClearFilterColor();
-
-private:
-	void SetPath(const std::string& vPath);
-	void ScanDir(const std::string& vPath);
-	void SetCurrentDir(const std::string& vPath);
-	bool CreateDir(const std::string& vPath);
-	void ComposeNewPath(std::vector<std::string>::iterator vIter);
-	void GetDrives();
-};
-
-
-#endif // __IMGUI_FILE_DIALOG_H_

FrameBuffer.cpp

@@ -1,208 +0,0 @@
-#include "FrameBuffer.h"
-#include "ImageShader.h"
-#include "Resource.h"
-#include "Settings.h"
-#include "Log.h"
-
-
-#include <glad/glad.h>
-
-const char* FrameBuffer::aspect_ratio_name[4] = { "4:3", "3:2", "16:10", "16:9" };
-glm::vec2 FrameBuffer::aspect_ratio_size[4] = { glm::vec2(4.f,3.f), glm::vec2(3.f,2.f), glm::vec2(16.f,10.f), glm::vec2(16.f,9.f) };
-const char* FrameBuffer::resolution_name[4] = { "720p", "1080p", "1440", "4K" };
-float FrameBuffer::resolution_height[4] = { 720.f, 1080.f, 1440.f, 2160.f };
-
-
-glm::vec3 FrameBuffer::getResolutionFromParameters(int ar, int h)
-{
-    float width = aspect_ratio_size[ar].x * resolution_height[h] / aspect_ratio_size[ar].y;
-    glm::vec3 res = glm::vec3( width, resolution_height[h] , 0.f);
-
-    return res;
-}
-
-FrameBuffer::FrameBuffer(glm::vec3 resolution, bool useAlpha, bool multiSampling): textureid_(0), intermediate_textureid_(0), framebufferid_(0), intermediate_framebufferid_(0), use_alpha_(useAlpha), use_multi_sampling_(multiSampling)
-{
-    attrib_.viewport = glm::ivec2(resolution);
-    attrib_.clear_color = glm::vec4(0.f, 0.f, 0.f, use_alpha_ ? 0.f : 1.f);
-}
-
-FrameBuffer::FrameBuffer(uint width, uint height, bool useAlpha, bool multiSampling): textureid_(0), intermediate_textureid_(0), framebufferid_(0), intermediate_framebufferid_(0), use_alpha_(useAlpha), use_multi_sampling_(multiSampling)
-{
-    attrib_.viewport = glm::ivec2(width, height);
-    attrib_.clear_color = glm::vec4(0.f, 0.f, 0.f, use_alpha_ ? 0.f : 1.f);
-}
-
-void FrameBuffer::init()
-{
-    // generate texture
-    glGenTextures(1, &textureid_);
-    glBindTexture(GL_TEXTURE_2D, textureid_);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-    glTexImage2D(GL_TEXTURE_2D, 0, use_alpha_ ? GL_RGBA : GL_RGB, attrib_.viewport.x, attrib_.viewport.y,
-                     0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
-    glBindTexture(GL_TEXTURE_2D, 0);
-
-    // create a framebuffer object
-    glGenFramebuffers(1, &framebufferid_);
-    glBindFramebuffer(GL_FRAMEBUFFER, framebufferid_);
-
-    // take settings into account: no multisampling for level 0
-    use_multi_sampling_ &= Settings::application.render.multisampling > 0;
-
-    if (use_multi_sampling_){
-
-        // create a multisample texture
-        glGenTextures(1, &intermediate_textureid_);
-        glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, intermediate_textureid_);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-        glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, Settings::application.render.multisampling,
-                                use_alpha_ ? GL_RGBA : GL_RGB, attrib_.viewport.x, attrib_.viewport.y, GL_TRUE);
-        glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, 0);
-
-        // attach the multisampled texture to FBO (currently binded)
-        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE, intermediate_textureid_, 0);
-
-        // create an intermediate FBO
-        glGenFramebuffers(1, &intermediate_framebufferid_);
-        glBindFramebuffer(GL_FRAMEBUFFER, intermediate_framebufferid_);
-
-        // attach the 2D texture to intermediate FBO
-        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, textureid_, 0);
-
-//        Log::Info("New FBO %d Multi Sampling ", framebufferid_);
-
-    }
-    else {
-
-        // direct attach the 2D texture to FBO
-        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, textureid_, 0);
-
-//        Log::Info("New FBO %d Single Sampling ", framebufferid_);
-    }
-
-    checkFramebufferStatus();
-    glBindFramebuffer(GL_FRAMEBUFFER, 0);
-
-}
-
-FrameBuffer::~FrameBuffer()
-{
-    if (framebufferid_)
-        glDeleteFramebuffers(1, &framebufferid_);
-}
-
-
-uint FrameBuffer::texture() const
-{
-    if (framebufferid_ == 0)
-        return Resource::getTextureBlack();
-
-    return textureid_;
-}
-
-float FrameBuffer::aspectRatio() const
-{
-    return static_cast<float>(attrib_.viewport.x) / static_cast<float>(attrib_.viewport.y);
-}
-
-
-glm::vec3 FrameBuffer::resolution() const
-{
-    return glm::vec3(attrib_.viewport.x, attrib_.viewport.y, 0.f);
-}
-
-void FrameBuffer::bind()
-{
-    if (!framebufferid_)
-        init();
-
-    glBindFramebuffer(GL_FRAMEBUFFER, framebufferid_);
-}
-
-void FrameBuffer::begin()
-{
-    bind();
-
-    Rendering::manager().pushAttrib(attrib_);
-
-    glClear(GL_COLOR_BUFFER_BIT);
-}
-
-void FrameBuffer::end()
-{    
-    // if multisampling frame buffer
-    if (use_multi_sampling_) {
-        // blit the multisample FBO into unisample FBO to generate 2D texture
-        // Doing this blit will automatically resolve the multisampled FBO.
-        glBindFramebuffer(GL_READ_FRAMEBUFFER, framebufferid_);
-        glBindFramebuffer(GL_DRAW_FRAMEBUFFER, intermediate_framebufferid_);
-        glBlitFramebuffer(0, 0, attrib_.viewport.x, attrib_.viewport.y,
-                          0, 0, attrib_.viewport.x, attrib_.viewport.y, GL_COLOR_BUFFER_BIT, GL_NEAREST);
-    }
-
-    FrameBuffer::release();
-
-    Rendering::manager().popAttrib();
-}
-
-void FrameBuffer::release()
-{
-    glBindFramebuffer(GL_FRAMEBUFFER, 0);
-}
-
-bool FrameBuffer::blit(FrameBuffer *other)
-{
-    if (!framebufferid_ || !other || !other->framebufferid_)
-        return false;
-
-    glBindFramebuffer(GL_READ_FRAMEBUFFER, framebufferid_);
-    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, other->framebufferid_);
-    // blit to the frame buffer object
-    glBlitFramebuffer(0, 0, attrib_.viewport.x, attrib_.viewport.y,
-                      0, 0, other->width(), other->height(), GL_COLOR_BUFFER_BIT, GL_NEAREST);
-    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
-
-    return true;
-}
-
-void FrameBuffer::checkFramebufferStatus()
-{
-    GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
-    switch (status){
-        case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
-            Log::Warning("GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT​ is returned if any of the framebuffer attachment points are framebuffer incomplete.");
-            break;
-        case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
-            Log::Warning("GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT​ is returned if the framebuffer does not have at least one image attached to it.");
-            break;
-        case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER:
-            Log::Warning("GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER​ is returned if the value of GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE​ is GL_NONE​ for any color attachment point(s) named by GL_DRAWBUFFERi​.");
-            break;
-        case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER:
-            Log::Warning("GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER​ is returned if GL_READ_BUFFER​ is not GL_NONE​ and the value of GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE​ is GL_NONE​ for the color attachment point named by GL_READ_BUFFER.");
-            break;
-        case GL_FRAMEBUFFER_UNSUPPORTED:
-            Log::Warning("GL_FRAMEBUFFER_UNSUPPORTED​ is returned if the combination of internal formats of the attached images violates an implementation-dependent set of restrictions.");
-            break;
-        case GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE:
-            Log::Warning("GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE​ is returned if the value of GL_RENDERBUFFER_SAMPLES​ is not the same for all attached renderbuffers; if the value of GL_TEXTURE_SAMPLES​ is the not same for all attached textures; or, if the attached images are a mix of renderbuffers and textures, the value of GL_RENDERBUFFER_SAMPLES​ does not match the value of GL_TEXTURE_SAMPLES.\nGL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE​ is also returned if the value of GL_TEXTURE_FIXED_SAMPLE_LOCATIONS​ is not the same for all attached textures; or, if the attached images are a mix of renderbuffers and textures, the value of GL_TEXTURE_FIXED_SAMPLE_LOCATIONS​ is not GL_TRUE​ for all attached textures.");
-            break;
-        case GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS:
-            Log::Warning("GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS​ is returned if any framebuffer attachment is layered, and any populated attachment is not layered, or if all populated color attachments are not from textures of the same target.");
-            break;
-        case GL_FRAMEBUFFER_UNDEFINED:
-            Log::Warning(" GL_FRAMEBUFFER_UNDEFINED​ is returned if target​ is the default framebuffer, but the default framebuffer does not exist.");
-            break;
-        case GL_FRAMEBUFFER_COMPLETE:
-#ifndef NDEBUG
-            Log::Info("Framebuffer created %d x %d.", width(), height());
-#endif
-            break;
-    }
-}
-

FrameBuffer.h

@@ -1,58 +0,0 @@
-#ifndef FRAMEBUFFER_H
-#define FRAMEBUFFER_H
-
-#include "Scene.h"
-#include "RenderingManager.h"
-
-class FrameBuffer {
-
-public:
-    // size descriptions
-    static const char* aspect_ratio_name[4];
-    static glm::vec2 aspect_ratio_size[4];
-    static const char* resolution_name[4];
-    static float resolution_height[4];
-    static glm::vec3 getResolutionFromParameters(int ar, int h);
-
-    FrameBuffer(glm::vec3 resolution, bool useAlpha = false, bool multiSampling = false);
-    FrameBuffer(uint width, uint height, bool useAlpha = false, bool multiSampling = false);
-    ~FrameBuffer();
-
-    // bind the FrameBuffer as current to draw into
-    void bind();
-    // unbind any framebuffer object
-    static void release();
-    // Bind & push attribs to prepare draw
-    void begin();
-    // pop attrib and unbind to end draw
-    void end();
-
-    // blit copy to another, returns true on success
-    bool blit(FrameBuffer *other);
-
-    // clear color
-    inline void setClearColor(glm::vec4 color) { attrib_.clear_color = color; }
-    inline glm::vec4 clearColor() const { return attrib_.clear_color; }
-
-    // width & height
-    inline uint width() const { return attrib_.viewport.x; }
-    inline uint height() const { return attrib_.viewport.y; }
-    glm::vec3 resolution() const;
-    float aspectRatio() const;
-
-    // texture index for draw
-    uint texture() const;
-
-private:
-    void init();
-    void checkFramebufferStatus();
-
-    RenderingAttrib attrib_;
-    uint textureid_, intermediate_textureid_;
-    uint framebufferid_, intermediate_framebufferid_;
-    bool use_alpha_, use_multi_sampling_;
-};
-
-
-
-#endif // FRAMEBUFFER_H

GarbageVisitor.cpp

@@ -1,159 +0,0 @@
-#include <algorithm>
-
-#include "Log.h"
-#include "Scene.h"
-#include "GarbageVisitor.h"
-
-
-GarbageVisitor::GarbageVisitor(Node *nodetocollect) : Visitor()
-{
-    targets_.push_front(nodetocollect);
-    current_ = nullptr;
-    found_ = false;
-}
-
-GarbageVisitor::GarbageVisitor(Source *sourcetocollect) : Visitor()
-{
-    targets_.push_front(sourcetocollect->group(View::MIXING));
-    targets_.push_front(sourcetocollect->group(View::GEOMETRY));
-    targets_.push_front(sourcetocollect->group(View::RENDERING));
-    current_ = nullptr;
-    found_ = false;
-}
-
-
-void GarbageVisitor::visit(Node &n)
-{
-    // found the target
-//    if (n.id() == target_->id())
-//    if ( &n == target_ )
-    if ( std::count(targets_.begin(), targets_.end(), &n) )
-    {
-        // end recursive
-        found_ = true;
-
-        // take the node out of the Tree
-        if (current_)
-            current_->detatch(&n);
-
-    }
-
-}
-
-GarbageVisitor::~GarbageVisitor()
-{
-    // actually delete the Node
-
-}
-
-
-void GarbageVisitor::visit(Group &n)
-{
-    // no need to go further if the node was found (or is this group)
-    if (found_)
-        return;
-
-    // current group
-    current_ = &n;
-
-    // loop over members of a group
-    // and stop when found
-    for (NodeSet::iterator node = n.begin(); !found_ && node != n.end(); node++) {
-        // visit the child node
-        (*node)->accept(*this);
-        // un-stack recursive browsing
-        current_ = &n;
-    }
-
-}
-
-void GarbageVisitor::visit(Scene &n)
-{
-    n.root()->accept(*this);
-}
-
-void GarbageVisitor::visit(Switch &n)
-{
-
-}
-
-void GarbageVisitor::visit(Primitive &n)
-{
-
-}
-
-void GarbageVisitor::visit(Surface &n)
-{
-
-}
-
-void GarbageVisitor::visit(ImageSurface &n)
-{
-
-}
-
-void GarbageVisitor::visit(FrameBufferSurface &n)
-{
-
-}
-
-void GarbageVisitor::visit(MediaSurface &n)
-{
-
-}
-
-void GarbageVisitor::visit(MediaPlayer &n)
-{
-
-}
-
-void GarbageVisitor::visit(Shader &n)
-{
-
-}
-
-void GarbageVisitor::visit(ImageShader &n)
-{
-
-}
-
-void GarbageVisitor::visit(ImageProcessingShader &n)
-{
-
-}
-
-void GarbageVisitor::visit(LineStrip &n)
-{
-
-}
-
-void GarbageVisitor::visit(LineSquare &)
-{
-
-}
-
-void GarbageVisitor::visit(LineCircle &n)
-{
-
-}
-
-void GarbageVisitor::visit(Mesh &n)
-{
-
-}
-
-void GarbageVisitor::visit(Frame &n)
-{
-
-}
-
-
-void GarbageVisitor::visit (Source& s)
-{
-
-}
-
-void GarbageVisitor::visit (MediaSource& s)
-{
-
-}

GarbageVisitor.h

@@ -1,47 +0,0 @@
-#ifndef GARBAGEVISITOR_H
-#define GARBAGEVISITOR_H
-
-#include <list>
-
-#include "Source.h"
-#include "Visitor.h"
-
-
-class GarbageVisitor : public Visitor
-{
-    Group *current_;
-    std::list<Node *> targets_;
-    bool found_;
-
-public:
-    GarbageVisitor(Source *sourcetocollect);
-    GarbageVisitor(Node *nodetocollect);
-    ~GarbageVisitor();
-
-    void visit(Scene& n) override;
-    void visit(Node& n) override;
-    void visit(Group& n) override;
-    void visit(Switch& n) override;
-    void visit(Primitive& n) override;
-
-    void visit(Surface& n) override;
-    void visit(ImageSurface& n) override;
-    void visit(MediaSurface& n) override;
-    void visit(FrameBufferSurface& n) override;
-    void visit(LineStrip& n) override;
-    void visit(LineSquare&) override;
-    void visit(LineCircle& n) override;
-    void visit(Mesh& n) override;
-    void visit(Frame& n) override;
-
-    void visit(MediaPlayer& n) override;
-    void visit(Shader& n) override;
-    void visit(ImageShader& n) override;
-    void visit(ImageProcessingShader& n) override;
-
-    void visit (Source& s) override;
-    void visit (MediaSource& s) override;
-
-};
-
-#endif // GARBAGEVISITOR_H

GlmToolkit.cpp

@@ -1,168 +0,0 @@
-// Freely inspired from https://github.com/alter-rokuz/glm-aabb.git
-
-#include "GlmToolkit.h"
-
-#include <glm/gtc/matrix_access.hpp>
-#include <glm/gtc/matrix_transform.hpp>
-#include <glm/gtc/random.hpp>
-
-glm::mat4 GlmToolkit::transform(glm::vec3 translation, glm::vec3 rotation, glm::vec3 scale)
-{
-    glm::mat4 View = glm::translate(glm::identity<glm::mat4>(), translation);
-    View = glm::rotate(View, rotation.x, glm::vec3(1.f, 0.f, 0.f));
-    View = glm::rotate(View, rotation.y, glm::vec3(0.f, 1.f, 0.f));
-    View = glm::rotate(View, rotation.z, glm::vec3(0.f, 0.f, 1.f));
-    glm::mat4 Model = glm::scale(glm::identity<glm::mat4>(), scale);
-    return View * Model;
-}
-
-
-GlmToolkit::AxisAlignedBoundingBox::AxisAlignedBoundingBox() {
-    mMin = glm::vec3(1.f);
-    mMax = glm::vec3(-1.f);
-}
-
-void GlmToolkit::AxisAlignedBoundingBox::extend(const glm::vec3& point) // TODO why ref to point?
-{
-    if (isNull()) {
-        mMin = point;
-        mMax = point;
-    }
-    // general case
-    else  {
-        mMin = glm::min(point, mMin);
-        mMax = glm::max(point, mMax);
-    }
-}
-
-void GlmToolkit::AxisAlignedBoundingBox::extend(std::vector<glm::vec3> points)
-{
-    for (auto p = points.begin(); p != points.end(); p++)
-        extend(*p);
-}
-
-
-void GlmToolkit::AxisAlignedBoundingBox::extend(const AxisAlignedBoundingBox& bb)
-{
-    if (bb.isNull())
-        return;
-
-    if (isNull()) {
-        mMin = bb.mMin;
-        mMax = bb.mMax;
-    }
-    // general case
-    else {
-        mMin = glm::min(bb.mMin, mMin);
-        mMax = glm::max(bb.mMax, mMax);
-    }
-}
-
-glm::vec3 GlmToolkit::AxisAlignedBoundingBox::center(bool ignore_z) const
-{
-    glm::vec3 ret = glm::vec3(0.f);
-
-    if (!isNull())
-    {
-      glm::vec3 d = mMax - mMin;
-      ret = mMin + (d * 0.5f);
-    }
-
-    if (ignore_z)
-        ret.z = 0.f;
-
-    return ret;
-}
-
-glm::vec3 GlmToolkit::AxisAlignedBoundingBox::scale(bool ignore_z) const
-{
-    glm::vec3 ret = glm::vec3(1.f);
-
-    if (!isNull())
-    {
-      glm::vec3 d = mMax - mMin;
-      ret = d * 0.5f;
-    }
-
-    if (ignore_z)
-        ret.z = 1.f;
-
-    return ret;
-}
-
-bool GlmToolkit::AxisAlignedBoundingBox::intersect(const AxisAlignedBoundingBox& bb, bool ignore_z) const
-{
-    if (isNull() || bb.isNull())
-        return false;
-
-    if (    (mMax.x < bb.mMin.x) || (mMin.x > bb.mMax.x) ||
-            (mMax.y < bb.mMin.y) || (mMin.y > bb.mMax.y) ||
-            ( !ignore_z && ((mMax.z < bb.mMin.z) || (mMin.z > bb.mMax.z)) ) )
-    {
-        return false;
-    }
-
-    return true;
-}
-
-bool GlmToolkit::AxisAlignedBoundingBox::contains(const AxisAlignedBoundingBox& bb, bool ignore_z) const
-{
-    if ( !intersect(bb, ignore_z))
-        return false;
-
-    if (    (mMin.x <= bb.mMin.x) && (mMax.x >= bb.mMax.x) &&
-            (mMin.y <= bb.mMin.y) && (mMax.y >= bb.mMax.y) &&
-            ( ignore_z || ((mMin.z <= bb.mMin.z) && (mMax.z >= bb.mMax.z)) )  )
-    {
-        return true;
-    }
-
-    return false;
-}
-
-bool GlmToolkit::AxisAlignedBoundingBox::contains(glm::vec3 point, bool ignore_z) const
-{
-    if (    (mMax.x < point.x) || (mMin.x > point.x) ||
-            (mMax.y < point.y) || (mMin.y > point.y) ||
-            ( !ignore_z && ((mMax.z < point.z) || (mMin.z > point.z)) ) )
-        return false;
-
-    return true;
-}
-
-
-GlmToolkit::AxisAlignedBoundingBox GlmToolkit::AxisAlignedBoundingBox::translated(glm::vec3 t)
-{
-    GlmToolkit::AxisAlignedBoundingBox bb;
-    bb = *this;
-
-    bb.mMin += t;
-    bb.mMax += t;
-
-    return bb;
-}
-
-GlmToolkit::AxisAlignedBoundingBox GlmToolkit::AxisAlignedBoundingBox::scaled(glm::vec3 s)
-{
-    GlmToolkit::AxisAlignedBoundingBox bb;
-    bb = *this;
-
-    bb.mMin *= s;
-    bb.mMax *= s;
-
-    return bb;
-}
-
-GlmToolkit::AxisAlignedBoundingBox GlmToolkit::AxisAlignedBoundingBox::transformed(glm::mat4 m)
-{
-    GlmToolkit::AxisAlignedBoundingBox bb;
-    glm::vec4 vec;
-    vec = m * glm::vec4(mMin, 1.f);
-    bb.mMin = glm::vec3(vec);
-
-    vec = m * glm::vec4(mMax, 1.f);
-    bb.mMax = glm::vec3(vec);
-
-    return bb;
-}
-

GlmToolkit.h

@@ -1,50 +0,0 @@
-#ifndef GLMTOOLKIT_H
-#define GLMTOOLKIT_H
-
-
-#include <vector>
-#include <glm/glm.hpp>
-
-namespace GlmToolkit
-{
-
-glm::mat4 transform(glm::vec3 translation, glm::vec3 rotation, glm::vec3 scale);
-
-
-class AxisAlignedBoundingBox
-{
-    glm::vec3 mMin;
-    glm::vec3 mMax;
-
-public:
-    AxisAlignedBoundingBox();
-
-    void operator = (const AxisAlignedBoundingBox &D ) {
-        mMin = D.mMin;
-        mMax = D.mMax;
-    }
-
-    // test
-    inline bool isNull() const { return mMin.x > mMax.x || mMin.y > mMax.y || mMin.z > mMax.z;}
-    inline glm::vec3 min() const { return mMin; }
-    inline glm::vec3 max() const { return mMax; }
-    glm::vec3 center(bool ignore_z = true) const;
-    glm::vec3 scale(bool ignore_z = true) const;
-    bool intersect(const AxisAlignedBoundingBox& bb, bool ignore_z = true) const;
-    bool contains(const AxisAlignedBoundingBox& bb, bool ignore_z = true) const;
-    bool contains(glm::vec3 point, bool ignore_z = true) const;
-
-    // build
-    void extend(const glm::vec3& point);
-    void extend(std::vector<glm::vec3> points);
-    void extend(const AxisAlignedBoundingBox& bb);
-
-    AxisAlignedBoundingBox translated(glm::vec3 t);
-    AxisAlignedBoundingBox scaled(glm::vec3 s);
-    AxisAlignedBoundingBox transformed(glm::mat4 m);
-};
-
-}
-
-
-#endif // GLMTOOLKIT_H

GstToolkit.cpp

@@ -1,94 +0,0 @@
-#include <sstream>
-#include <iomanip>
-using namespace std;
-
-#include "GstToolkit.h"
-
-string GstToolkit::time_to_string(guint64 t)
-{
-    if (t == GST_CLOCK_TIME_NONE)
-        return "00:00:00.00";
-
-    guint ms =  GST_TIME_AS_MSECONDS(t);
-    guint s = ms / 1000;
-
-    ostringstream oss;
-    if (s / 3600)
-        oss << setw(2) << setfill('0') << s / 3600 << ':';
-    if ((s % 3600) / 60)
-        oss << setw(2) << setfill('0') << (s % 3600) / 60 << ':';
-    oss << setw(2) << setfill('0') << (s % 3600) % 60 << '.';
-    oss << setw(2) << setfill('0') << (ms % 1000) / 10;
-
-    // fixed length string (11 chars) HH:mm:ss.ii"
-    return oss.str();
-}
-
-
-list<string> GstToolkit::all_plugins()
-{
-    list<string> pluginlist;
-    GList *l, *g;
-
-    l = gst_registry_get_plugin_list (gst_registry_get ());
-
-    for (g = l; g; g = g->next) {
-        GstPlugin *plugin = GST_PLUGIN (g->data);
-        pluginlist.push_front( string( gst_plugin_get_name (plugin) ) );
-    }
-
-    gst_plugin_list_free (l);
-
-    return pluginlist;
-}
-
-
-list<string> GstToolkit::all_plugin_features(string pluginname)
-{
-    list<string> featurelist;
-    GList *l, *g;
-
-    l = gst_registry_get_feature_list_by_plugin (gst_registry_get (), pluginname.c_str());
-
-    for (g = l; g; g = g->next) {
-        GstPluginFeature *feature = GST_PLUGIN_FEATURE (g->data);
-        featurelist.push_front( string( gst_plugin_feature_get_name (feature) ) );
-    }
-
-    gst_plugin_feature_list_free (l);
-
-    return featurelist;
-}
-
-bool GstToolkit::enable_feature (string name, bool enable) {
-    GstRegistry *registry = NULL;
-    GstElementFactory *factory = NULL;
-
-    registry = gst_registry_get();
-    if (!registry) return false;
-
-    factory = gst_element_factory_find (name.c_str());
-    if (!factory) return false;
-
-    if (enable) {
-        gst_plugin_feature_set_rank (GST_PLUGIN_FEATURE (factory), GST_RANK_PRIMARY + 1);
-    }
-    else {
-        gst_plugin_feature_set_rank (GST_PLUGIN_FEATURE (factory), GST_RANK_NONE);
-    }
-
-    gst_registry_add_feature (registry, GST_PLUGIN_FEATURE (factory));
-    return true;
-}
-
-
-string GstToolkit::gst_version()
-{
-    std::ostringstream oss;
-    oss << GST_VERSION_MAJOR << '.' << GST_VERSION_MINOR << '.';
-    oss << std::setw(2) << setfill('0') << GST_VERSION_MICRO ;
-    if (GST_VERSION_NANO > 0)
-        oss << ( (GST_VERSION_NANO < 2 ) ? " - (CVS)" : " - (Prerelease)");
-
-    return oss.str();
-}

GstToolkit.h

@@ -1,22 +0,0 @@
-#ifndef __GSTGUI_TOOLKIT_H_
-#define __GSTGUI_TOOLKIT_H_
-
-#include <gst/gst.h>
-
-#include <string>
-#include <list>
-
-namespace GstToolkit
-{
-
-    std::string time_to_string(guint64 t);
-
-    std::string gst_version();
-    std::list<std::string> all_plugins();
-    std::list<std::string> all_plugin_features(std::string pluginname);
-
-    bool enable_feature (std::string name, bool enable);
-
-}
-
-#endif // __GSTGUI_TOOLKIT_H_

ImGuiToolkit.h

@@ -1,63 +0,0 @@
-#ifndef __IMGUI_TOOLKIT_H_
-#define __IMGUI_TOOLKIT_H_
-
-#include <glib.h>
-#include <string>
-#include <list>
-#include <vector>
-#include <utility>
-#include "rsc/fonts/IconsFontAwesome5.h"
-
-namespace ImGuiToolkit
-{
-    // Icons from resource icon.dds
-    void Icon(int i, int j);
-    void ShowIconsWindow(bool* p_open);
-
-    // utility buttons
-    bool ButtonIcon (int i, int j);
-    bool ButtonIconToggle (int i, int j, int i_toggle, int j_toggle, bool* toggle);
-    bool ButtonIconMultistate (std::vector<std::pair<int, int> > icons, int* state);
-    void ButtonToggle (const char* label, bool* toggle);
-    void ButtonSwitch (const char* label, bool* toggle , const char *help = nullptr);
-    bool IconToggle (int i, int j, int i_toggle, int j_toggle, bool* toggle, const char *tooltips[] = nullptr);
-    void ButtonOpenUrl (const char* url, const ImVec2& size_arg = ImVec2(0,0));
-
-    void HelpMarker (const char* desc);
-
-    // utility sliders
-    void Bar (float value, float in, float out, float min, float max, const char* title, bool expand);
-    bool TimelineSlider (const char* label, guint64 *time, guint64 duration, guint64 step);
-    bool TimelineSliderEdit (const char* label, guint64 *time, guint64 duration, guint64 step,
-                        std::list<std::pair<guint64, guint64> >& segments);
-    
-    // fonts from ressources 'fonts/'
-    typedef enum {
-        FONT_DEFAULT =0,
-        FONT_BOLD,
-        FONT_ITALIC,
-        FONT_MONO,
-        FONT_LARGE
-    } font_style;
-    void SetFont (font_style type, const std::string &ttf_font_name, int pointsize, int oversample = 2);
-    void PushFont (font_style type);
-
-    void WindowText(const char* window_name, ImVec2 window_pos, const char* text);
-    bool WindowButton(const char* window_name, ImVec2 window_pos, const char* text);
-    void WindowDragFloat(const char* window_name, ImVec2 window_pos, float* v, float v_speed, float v_min, float v_max, const char* format);
-
-
-    // color of gui items
-    typedef enum {
-        ACCENT_BLUE =0,
-        ACCENT_ORANGE,
-        ACCENT_GREY
-    } accent_color;
-    void SetAccentColor (accent_color color);
-    struct ImVec4 GetHighlightColor ();
-
-    void ShowStats (bool* p_open, int* p_corner);
-
-}
-
-#endif // __IMGUI_TOOLKIT_H_

ImGuiVisitor.cpp

@@ -1,331 +0,0 @@
-#include "ImGuiVisitor.h"
-
-#include <vector>
-#include <algorithm>
-
-#include <glm/glm.hpp>
-#include <glm/gtc/type_ptr.hpp>
-#include <glm/gtc/constants.hpp>
-
-#include "defines.h"
-#include "Log.h"
-#include "Scene.h"
-#include "Primitives.h"
-#include "ImageShader.h"
-#include "ImageProcessingShader.h"
-#include "MediaPlayer.h"
-#include "MediaSource.h"
-#include "SessionSource.h"
-#include "Settings.h"
-#include "Mixer.h"
-
-#include "imgui.h"
-#include "ImGuiToolkit.h"
-#include "UserInterfaceManager.h"
-#include "SystemToolkit.h"
-
-
-ImGuiVisitor::ImGuiVisitor()
-{
-
-}
-
-void ImGuiVisitor::visit(Node &n)
-{
-
-}
-
-void ImGuiVisitor::visit(Group &n)
-{
-//    std::string id = std::to_string(n.id());
-//    if (ImGui::TreeNode(id.c_str(), "Group %d", n.id()))
-//    {
-        // MODEL VIEW
-
-    if (ImGuiToolkit::ButtonIcon(1, 16)) {
-        n.translation_.x = 0.f;
-        n.translation_.y = 0.f;
-        n.rotation_.z = 0.f;
-        n.scale_.x = 1.f;
-        n.scale_.y = 1.f;
-    }
-    ImGui::SameLine(0, 10);
-    ImGui::Text("Geometry");
-
-    if (ImGuiToolkit::ButtonIcon(6, 15)) {
-        n.translation_.x = 0.f;
-        n.translation_.y = 0.f;
-    }
-    ImGui::SameLine(0, 10);
-    float translation[2] = { n.translation_.x, n.translation_.y};
-    ImGui::SetNextItemWidth(IMGUI_RIGHT_ALIGN);
-    if ( ImGui::SliderFloat2("Position", translation, -5.0, 5.0) )
-    {
-        n.translation_.x = translation[0];
-        n.translation_.y = translation[1];
-    }
-
-    if (ImGuiToolkit::ButtonIcon(18, 9))
-        n.rotation_.z = 0.f;
-    ImGui::SameLine(0, 10);
-    ImGui::SetNextItemWidth(IMGUI_RIGHT_ALIGN);
-    ImGui::SliderAngle("Angle", &(n.rotation_.z), -180.f, 180.f) ;
-
-    if (ImGuiToolkit::ButtonIcon(3, 15))  {
-        n.scale_.x = 1.f;
-        n.scale_.y = 1.f;
-    }
-    ImGui::SameLine(0, 10);
-    float scale[2] = { n.scale_.x, n.scale_.y} ;
-    ImGui::SetNextItemWidth(IMGUI_RIGHT_ALIGN);
-    if ( ImGui::SliderFloat2("Scale", scale, -MAX_SCALE, MAX_SCALE, "%.2f") )
-    {
-        n.scale_.x = CLAMP_SCALE(scale[0]);
-        n.scale_.y = CLAMP_SCALE(scale[1]);
-    }
-
-//        // loop over members of a group
-//        for (NodeSet::iterator node = n.begin(); node != n.end(); node++) {
-//            (*node)->accept(*this);
-//        }
-
-//        ImGui::TreePop();
-//    }
-}
-
-void ImGuiVisitor::visit(Switch &n)
-{
-    if (n.numChildren()>0)
-        n.activeChild()->accept(*this);
-}
-
-void ImGuiVisitor::visit(Scene &n)
-{
-    ImGui::SetNextItemOpen(true, ImGuiCond_Once);
-    if (ImGui::CollapsingHeader("Scene Property Tree"))
-    {
-        n.root()->accept(*this);
-    }
-}
-
-void ImGuiVisitor::visit(Primitive &n)
-{
-    ImGui::PushID(n.id());
-    ImGui::Text("Primitive %d", n.id());
-
-    n.shader()->accept(*this);
-
-    ImGui::PopID();
-}
-
-void ImGuiVisitor::visit(FrameBufferSurface &n)
-{
-    ImGui::Text("Framebuffer");
-}
-
-void ImGuiVisitor::visit(MediaSurface &n)
-{
-    ImGui::Text("%s", n.path().c_str());
-
-    if (n.mediaPlayer())
-        n.mediaPlayer()->accept(*this);
-}
-
-void ImGuiVisitor::visit(MediaPlayer &n)
-{
-    ImGui::Text("Media Player");
-}
-
-void ImGuiVisitor::visit(Shader &n)
-{
-    ImGui::PushID(n.id());
-
-//    if (ImGuiToolkit::ButtonIcon(10, 2)) {
-//        n.blending = Shader::BLEND_OPACITY;
-//        n.color = glm::vec4(1.f, 1.f, 1.f, 1.f);
-//    }
-//    ImGui::SameLine(0, 10);
-//    ImGui::ColorEdit3("Color", glm::value_ptr(n.color), ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_NoLabel ) ;
-//    ImGui::SameLine(0, 5);
-    ImGui::SetNextItemWidth(IMGUI_RIGHT_ALIGN);
-    int mode = n.blending;
-    if (ImGui::Combo("Blending", &mode, "Normal\0Screen\0Inverse\0Addition\0Subtract\0") )
-        n.blending = Shader::BlendMode(mode);
-
-    ImGui::PopID();
-}
-
-void ImGuiVisitor::visit(ImageShader &n)
-{
-    ImGui::PushID(n.id());
-
-    // get index of the mask used in this ImageShader
-    int item_current = n.mask;
-
-//    if (ImGuiToolkit::ButtonIcon(10, 3)) n.mask = 0;
-//    ImGui::SameLine(0, 10);
-    ImGui::SetNextItemWidth(IMGUI_RIGHT_ALIGN);
-    // combo list of masks
-    if ( ImGui::Combo("Mask", &item_current, ImageShader::mask_names, IM_ARRAYSIZE(ImageShader::mask_names) ) )
-    {
-        if (item_current < (int) ImageShader::mask_presets.size())
-            n.mask = item_current;
-        else {
-            // TODO ask for custom mask
-        }
-    }
-
-    ImGui::PopID();
-}
-
-void ImGuiVisitor::visit(ImageProcessingShader &n)
-{
-    ImGui::PushID(n.id());
-
-    if (ImGuiToolkit::ButtonIcon(6, 2)) {
-        ImageProcessingShader defaultvalues;
-        n = defaultvalues;
-    }
-    ImGui::SameLine(0, 10);
-    ImGui::Text("Filters");
-
-    if (ImGuiToolkit::ButtonIcon(6, 4)) n.gamma = glm::vec4(1.f, 1.f, 1.f, 1.f);
-    ImGui::SameLine(0, 10);
-    ImGui::ColorEdit3("GammaColor", glm::value_ptr(n.gamma), ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_NoLabel) ;
-    ImGui::SameLine(0, 5);
-    ImGui::SetNextItemWidth(IMGUI_RIGHT_ALIGN);
-    ImGui::SliderFloat("Gamma", &n.gamma.w, 0.5f, 10.f, "%.2f", 2.f);
-
-//    ImGui::SetNextItemWidth(IMGUI_RIGHT_ALIGN);
-//    ImGui::SliderFloat4("Levels", glm::value_ptr(n.levels), 0.0, 1.0);
-
-    if (ImGuiToolkit::ButtonIcon(4, 1)) {
-        n.brightness = 0.f;
-        n.contrast = 0.f;
-    }
-    ImGui::SameLine(0, 10);
-    ImGui::SetNextItemWidth(IMGUI_RIGHT_ALIGN);
-    float bc[2] = { n.brightness, n.contrast};
-    if ( ImGui::SliderFloat2("B & C", bc, -1.0, 1.0) )
-    {
-        n.brightness = bc[0];
-        n.contrast = bc[1];
-    }
-
-    if (ImGuiToolkit::ButtonIcon(2, 1)) n.saturation = 0.f;
-    ImGui::SameLine(0, 10);
-    ImGui::SetNextItemWidth(IMGUI_RIGHT_ALIGN);
-    ImGui::SliderFloat("Saturation", &n.saturation, -1.0, 1.0);
-
-    if (ImGuiToolkit::ButtonIcon(12, 4)) n.hueshift = 0.f;
-    ImGui::SameLine(0, 10);
-    ImGui::SetNextItemWidth(IMGUI_RIGHT_ALIGN);
-    ImGui::SliderFloat("Hue shift", &n.hueshift, 0.0, 1.0);
-
-    if (ImGuiToolkit::ButtonIcon(3, 1)) n.lumakey = 0.f;
-    ImGui::SameLine(0, 10);
-    ImGui::SetNextItemWidth(IMGUI_RIGHT_ALIGN);
-    ImGui::SliderFloat("Lumakey", &n.lumakey, 0.0, 1.0);
-
-    if (ImGuiToolkit::ButtonIcon(8, 1)) n.threshold = 0.f;
-    ImGui::SameLine(0, 10);
-    ImGui::SetNextItemWidth(IMGUI_RIGHT_ALIGN);
-    ImGui::SliderFloat("Threshold", &n.threshold, 0.0, 1.0, n.threshold < 0.001 ? "None" : "%.2f");
-
-    if (ImGuiToolkit::ButtonIcon(18, 1)) n.nbColors = 0;
-    ImGui::SameLine(0, 10);
-    ImGui::SetNextItemWidth(IMGUI_RIGHT_ALIGN);
-    ImGui::SliderInt("Posterize", &n.nbColors, 0, 16, n.nbColors == 0 ? "None" : "%d colors");
-
-    if (ImGuiToolkit::ButtonIcon(1, 7)) n.filterid = 0;
-    ImGui::SameLine(0, 10);
-    ImGui::SetNextItemWidth(IMGUI_RIGHT_ALIGN);
-    ImGui::Combo("Filter", &n.filterid, ImageProcessingShader::filter_names, IM_ARRAYSIZE(ImageProcessingShader::filter_names) );
-
-    if (ImGuiToolkit::ButtonIcon(7, 1)) n.invert = 0;
-    ImGui::SameLine(0, 10);
-    ImGui::SetNextItemWidth(IMGUI_RIGHT_ALIGN);
-    ImGui::Combo("Invert", &n.invert, "None\0Invert Color\0Invert Luminance\0");
-
-    if (ImGuiToolkit::ButtonIcon(13, 4)) {
-        n.chromakey = glm::vec4(0.f, 0.8f, 0.f, 1.f);
-        n.chromadelta = 0.f;
-    }
-    ImGui::SameLine(0, 10);
-    ImGui::ColorEdit3("Chroma color", glm::value_ptr(n.chromakey), ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_NoLabel  ) ;
-    ImGui::SameLine(0, 5);
-    ImGui::SetNextItemWidth(IMGUI_RIGHT_ALIGN);
-    ImGui::SliderFloat("Chromakey", &n.chromadelta, 0.0, 1.0, n.chromadelta < 0.001 ? "None" : "Tolerance %.2f");
-
-    ImGui::PopID();
-}
-
-
-void ImGuiVisitor::visit (Source& s)
-{
-    // blending
-    s.blendingShader()->accept(*this);
-
-    // preview
-    float preview_width = ImGui::GetContentRegionAvail().x IMGUI_RIGHT_ALIGN;
-    ImVec2 imagesize ( preview_width, preview_width / s.frame()->aspectRatio());
-    ImGui::Image((void*)(uintptr_t) s.frame()->texture(), imagesize);
-
-    // image processing pannel
-    s.processingShader()->accept(*this);
-
-    // geometry direct control
-    s.groupNode(View::GEOMETRY)->accept(*this);
-
-}
-
-void ImGuiVisitor::visit (MediaSource& s)
-{
-    if ( s.mediaplayer()->duration() == GST_CLOCK_TIME_NONE) {
-        ImGuiToolkit::Icon(2,9);
-        ImGui::SameLine(0, 10);
-        ImGui::Text("Image File");
-    }
-    else {
-        ImGuiToolkit::Icon(18,13);
-        ImGui::SameLine(0, 10);
-        ImGui::Text("Video File");
-        if ( ImGui::Button(IMGUI_TITLE_MEDIAPLAYER, ImVec2(IMGUI_RIGHT_ALIGN, 0)) ) {
-            UserInterface::manager().showMediaPlayer( s.mediaplayer());
-        }
-    }
-    ImGuiToolkit::ButtonOpenUrl( SystemToolkit::path_filename(s.path()).c_str(), ImVec2(IMGUI_RIGHT_ALIGN, 0) );
-}
-
-void ImGuiVisitor::visit (SessionSource& s)
-{
-    ImGuiToolkit::Icon(4,9);
-    ImGui::SameLine(0, 10);
-    ImGui::Text("Session File");
-    if ( ImGui::Button( ICON_FA_FILE_UPLOAD " Make Current", ImVec2(IMGUI_RIGHT_ALIGN, 0)) )
-        Mixer::manager().set( s.detach() );
-    if ( ImGui::Button( ICON_FA_FILE_EXPORT " Import", ImVec2(IMGUI_RIGHT_ALIGN, 0)) )
-        Mixer::manager().merge( s.detach() );
-
-    ImGuiToolkit::ButtonOpenUrl( SystemToolkit::path_filename(s.path()).c_str(), ImVec2(IMGUI_RIGHT_ALIGN, 0) );
-}
-
-void ImGuiVisitor::visit (RenderSource& s)
-{
-    ImGuiToolkit::Icon(19,1);
-    ImGui::SameLine(0, 10);
-    ImGui::Text("Rendering Output");
-    if ( ImGui::Button(IMGUI_TITLE_PREVIEW, ImVec2(IMGUI_RIGHT_ALIGN, 0)) )
-        Settings::application.widget.preview = true;
-}
-
-void ImGuiVisitor::visit (CloneSource& s)
-{
-    ImGuiToolkit::Icon(9,2);
-    ImGui::SameLine(0, 10);
-    ImGui::Text("Clone of %s", s.origin()->name().c_str());
-    std::string label = "Select " + s.origin()->name();
-    if ( ImGui::Button(label.c_str(), ImVec2(IMGUI_RIGHT_ALIGN, 0)) )
-        Mixer::manager().setCurrentSource(s.origin());
-}
-

ImGuiVisitor.h

@@ -1,32 +0,0 @@
-#ifndef IMGUIVISITOR_H
-#define IMGUIVISITOR_H
-
-#include "Visitor.h"
-
-class ImGuiVisitor: public Visitor
-{
-public:
-    ImGuiVisitor();
-
-    // Elements of Scene
-    void visit(Scene& n) override;
-    void visit(Node& n) override;
-    void visit(Group& n) override;
-    void visit(Switch& n) override;
-    void visit(Primitive& n) override;
-    void visit(MediaSurface& n) override;
-    void visit(FrameBufferSurface& n) override;
-
-    // Elements with attributes
-    void visit(MediaPlayer& n) override;
-    void visit(Shader& n) override;
-    void visit(ImageShader& n) override;
-    void visit(ImageProcessingShader& n) override;
-    void visit (Source& s) override;
-    void visit (MediaSource& s) override;
-    void visit (SessionSource& s) override;
-    void visit (RenderSource& s) override;
-    void visit (CloneSource& s) override;
-};
-
-#endif // IMGUIVISITOR_H

ImageShader.cpp

@@ -1,79 +0,0 @@
-#include <glad/glad.h>
-
-#include "defines.h"
-#include "Visitor.h"
-#include "ImageShader.h"
-#include "Resource.h"
-
-static ShadingProgram imageShadingProgram("shaders/image.vs", "shaders/image.fs");
-
-const char* ImageShader::mask_names[11] = { "None", "Glow", "Halo", "Circle", "Round", "Vignette", "Top", "Botton", "Left", "Right", "Custom" };
-std::vector< uint > ImageShader::mask_presets;
-
-ImageShader::ImageShader(): Shader(), custom_textureindex(0)
-{
-    // first initialization
-    if ( mask_presets.empty() ) {
-        mask_presets.push_back(Resource::getTextureWhite());
-        mask_presets.push_back(Resource::getTextureImage("images/mask_glow.png"));
-        mask_presets.push_back(Resource::getTextureImage("images/mask_halo.png"));
-        mask_presets.push_back(Resource::getTextureImage("images/mask_circle.png"));
-        mask_presets.push_back(Resource::getTextureImage("images/mask_roundcorner.png"));
-        mask_presets.push_back(Resource::getTextureImage("images/mask_vignette.png"));
-        mask_presets.push_back(Resource::getTextureImage("images/mask_linear_top.png"));
-        mask_presets.push_back(Resource::getTextureImage("images/mask_linear_bottom.png"));
-        mask_presets.push_back(Resource::getTextureImage("images/mask_linear_left.png"));
-        mask_presets.push_back(Resource::getTextureImage("images/mask_linear_right.png"));
-    }
-    // static program shader
-    program_ = &imageShadingProgram;
-    // reset instance
-    reset();
-}
-
-void ImageShader::use()
-{
-    Shader::use();
-
-    program_->setUniform("stipple", stipple);
-
-    glActiveTexture(GL_TEXTURE1);
-    if ( mask < 10 ) {
-        glBindTexture(GL_TEXTURE_2D, mask_presets[mask]);
-
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-    }
-    else
-        glBindTexture(GL_TEXTURE_2D, custom_textureindex);
-    glActiveTexture(GL_TEXTURE0);
-
-}
-
-void ImageShader::reset()
-{
-    Shader::reset();
-
-    // default mask
-    mask = 0;
-    custom_textureindex = mask_presets[0];
-    // no stippling
-    stipple = 0.f;
-}
-
-void ImageShader::operator = (const ImageShader &S )
-{
-    Shader::operator =(S);
-
-    mask = S.mask;
-    custom_textureindex = S.custom_textureindex;
-    stipple = S.stipple;
-}
-
-
-void ImageShader::accept(Visitor& v) {
-    Shader::accept(v);
-    v.visit(*this);
-}

ImageShader.h

@@ -1,35 +0,0 @@
-#ifndef IMAGESHADER_H
-#define IMAGESHADER_H
-
-#include <string>
-#include <map>
-
-#ifdef __APPLE__
-#include <sys/types.h>
-#endif
-
-#include "Shader.h"
-
-class ImageShader : public Shader
-{
-
-public:
-
-    ImageShader();
-//    virtual ~ImageShader() {}
-
-    void use() override;
-    void reset() override;
-    void accept(Visitor& v) override;
-
-    void operator = (const ImageShader &S);
-
-    uint mask;
-    uint custom_textureindex;
-    float stipple;
-
-    static const char* mask_names[11];
-    static std::vector< uint > mask_presets;
-};
-
-#endif // IMAGESHADER_H

MediaPlayer.h

@@ -1,307 +0,0 @@
-#ifndef __GST_MEDIA_PLAYER_H_
-#define __GST_MEDIA_PLAYER_H_
-
-#include <string>
-#include <atomic>
-#include <sstream>
-#include <set>
-#include <list>
-#include <map>
-#include <utility>
-#include <mutex>
-
-#include <gst/gst.h>
-#include <gst/gl/gl.h>
-#include <gst/pbutils/pbutils.h>
-
-// Forward declare classes referenced
-class Visitor;
-
-#define MAX_PLAY_SPEED 20.0
-#define MIN_PLAY_SPEED 0.1
-#define N_VFRAME 3
-
-struct TimeCounter {
-
-    GstClockTime last_time;
-    GstClockTime tic_time;
-    int nbFrames;
-    float fps;
-public:
-    TimeCounter();
-    GstClockTime dt();
-    void tic();
-    void reset();
-    float frameRate() const;
-};
-
-struct MediaSegment
-{
-    GstClockTime begin;
-    GstClockTime end;
-
-    MediaSegment()
-    {
-        begin = GST_CLOCK_TIME_NONE;
-        end = GST_CLOCK_TIME_NONE;
-    }
-
-    MediaSegment(GstClockTime b, GstClockTime e)
-    {
-        if ( b < e ) {
-            begin = b;
-            end = e;
-        } else {
-            begin = GST_CLOCK_TIME_NONE;
-            end = GST_CLOCK_TIME_NONE;
-        }
-    }
-    inline bool is_valid() const
-    {
-        return begin != GST_CLOCK_TIME_NONE && end != GST_CLOCK_TIME_NONE && begin < end;
-    }
-    inline bool operator < (const MediaSegment b) const
-    {
-        return (this->is_valid() && b.is_valid() && this->end < b.begin);
-    }
-    inline bool operator == (const MediaSegment b) const
-    {
-        return (this->begin == b.begin && this->end == b.end);
-    }
-    inline bool operator != (const MediaSegment b) const
-    {
-        return (this->begin != b.begin || this->end != b.end);
-    }
-};
-
-struct containsTime: public std::unary_function<MediaSegment, bool>
-{
-    inline bool operator()(const MediaSegment s) const
-    {
-       return ( s.is_valid() && _t > s.begin && _t < s.end );
-    }
-
-    containsTime(GstClockTime t) : _t(t) { }
-
-private:
-    GstClockTime _t;
-};
-
-
-typedef std::set<MediaSegment> MediaSegmentSet;
-
-class MediaPlayer {
-
-public:
-
-    /**
-     * Constructor of a GStreamer Media
-     */
-    MediaPlayer( std::string name = std::string() );
-    /**
-     * Destructor.
-     */
-    ~MediaPlayer();
-    /** 
-     * Open a media using gstreamer URI 
-     * */
-    void open( std::string path);
-    /**
-     * True if a media was oppenned
-     * */
-    bool isOpen() const;
-    /**
-     * True if problem occured
-     * */
-    bool failed() const;
-    /**
-     * Close the Media
-     * */
-    void close();
-    /**
-     * Update status
-     * Must be called in update loop
-     * */
-    void update();
-
-    void enable(bool on);
-
-    bool isEnabled() const;
-
-    /**
-     * Pause / Play
-     * Can play backward if play speed is negative
-     * */
-    void play(bool on);
-    /**
-     * Get Pause / Play
-     * */
-    bool isPlaying(bool testpipeline = false) const;
-    /**
-     * Speed factor for playing
-     * Can be negative.
-     * */
-    double playSpeed() const;
-    /**
-     * Set the speed factor for playing
-     * Can be negative.
-     * */
-    void setPlaySpeed(double s);
-    /**
-     * True if the player will loop when at begin or end
-     * */
-    typedef enum {
-        LOOP_NONE = 0,
-        LOOP_REWIND = 1,
-        LOOP_BIDIRECTIONAL = 2
-    } LoopMode;
-    LoopMode loop() const;
-    /**
-     * Set the player to loop
-     * */
-    void setLoop(LoopMode mode);
-    /**
-     * Restart from zero
-     * */
-    void rewind();
-    /**
-     * Seek to next frame when paused
-     * Can go backward if play speed is negative
-     * */
-    void seekNextFrame();
-    /**
-     * Seek to any position in media
-     * pos in nanoseconds.
-     * */
-    void seekTo(GstClockTime pos);
-    /**
-     * Jump by 10% of the duration
-     * */
-    void fastForward();
-    /**
-     * Get position time
-     * */
-    GstClockTime position();
-    /**
-     * Get total duration time
-     * */
-    GstClockTime duration();
-    /**
-     * Get duration of one frame
-     * */
-    GstClockTime frameDuration();
-    /**
-     * Get framerate of the media
-     * */
-    double frameRate() const;
-    /**
-     * Get name of Codec of the media
-     * */
-    std::string codec() const;
-    /**
-     * Get rendering update framerate
-     * measured during play
-     * */
-    double updateFrameRate() const;
-    /**
-     * Get the OpenGL texture
-     * Must be called in OpenGL context
-     * */
-    guint texture() const;
-    /**
-     * Get Image properties
-     * */
-    guint width() const;
-    guint height() const;
-    float aspectRatio() const;
-
-    /**
-     * Get name of the media
-     * */
-    std::string uri() const;
-    std::string filename() const;
-
-    /**
-     * Accept visitors
-     * */
-    void accept(Visitor& v);
-
-    /**
-     * @brief registered
-     * @return list of media players currently registered
-     */
-    static std::list<MediaPlayer*> registered() { return registered_; }
-    static std::list<MediaPlayer*>::const_iterator begin() { return registered_.cbegin(); }
-    static std::list<MediaPlayer*>::const_iterator end()   { return registered_.cend(); }
-
-private:
-
-    bool addPlaySegment(GstClockTime begin, GstClockTime end);
-    bool addPlaySegment(MediaSegment s);
-    bool removePlaySegmentAt(GstClockTime t);
-    bool removeAllPlaySegmentOverlap(MediaSegment s);
-    std::list< std::pair<guint64, guint64> > getPlaySegments() const;
-
-    std::string id_;
-    std::string filename_;
-    std::string uri_;
-    guint textureindex_;
-    guint width_;
-    guint height_;
-    guint par_width_;  // width to match pixel aspect ratio
-    GstClockTime position_;
-    GstClockTime start_position_;
-    GstClockTime duration_;
-    GstClockTime frame_duration_;
-    bool (*TimeComparator_)(GstClockTime,GstClockTime);
-    gdouble rate_;
-    LoopMode loop_;
-    std::atomic<bool> need_loop_;
-    TimeCounter timecount_;
-    gdouble framerate_;
-    GstState desired_state_;
-    GstElement *pipeline_;
-    GstDiscoverer *discoverer_;
-    std::stringstream discoverer_message_;
-    std::string codec_name_;
-    GstVideoInfo v_frame_video_info_;
-
-    guint vframe_read_index_;
-    guint vframe_write_index_;
-    GstVideoFrame vframe_[N_VFRAME];
-    std::atomic<bool> vframe_is_full_[N_VFRAME];
-    GstClockTime vframe_position_[N_VFRAME];
-    std::mutex vframe_lock_[N_VFRAME];
-
-    // for PBO
-    guint pbo_[2];
-    guint pbo_index_, pbo_next_index_;
-    guint pbo_size_;
-
-    MediaSegmentSet segments_;
-    MediaSegmentSet::iterator current_segment_;
-
-    bool ready_;
-    bool failed_;
-    bool seekable_;
-    bool isimage_;
-    bool interlaced_;
-    bool enabled_;
-
-    void init_texture();
-    void execute_open();
-    void execute_loop_command();
-    void execute_seek_command(GstClockTime target = GST_CLOCK_TIME_NONE);   
-    bool fill_v_frame(GstBuffer *buf);
-
-    static GstFlowReturn callback_pull_sample_video (GstElement *bin, MediaPlayer *m);
-    static void callback_end_of_video (GstElement *, MediaPlayer *m);
-    static void callback_discoverer_process (GstDiscoverer *discoverer, GstDiscovererInfo *info, GError *err, MediaPlayer *m);
-    static void callback_discoverer_finished(GstDiscoverer *discoverer, MediaPlayer *m);
-
-    static std::list<MediaPlayer*> registered_;
-};
-
-
-
-#endif // __GST_MEDIA_PLAYER_H_

MediaSource.cpp

@@ -1,143 +0,0 @@
-#include <glm/gtc/matrix_transform.hpp>
-
-#include "MediaSource.h"
-
-#include "defines.h"
-#include "ImageShader.h"
-#include "ImageProcessingShader.h"
-#include "Resource.h"
-#include "Primitives.h"
-#include "MediaPlayer.h"
-#include "Visitor.h"
-#include "Log.h"
-
-MediaSource::MediaSource() : Source(), path_("")
-{
-    // create media player
-    mediaplayer_ = new MediaPlayer;
-
-    // create media surface:
-    // - textured with original texture from media player
-    // - crop & repeat UV can be managed here
-    // - additional custom shader can be associated
-    mediasurface_ = new Surface(rendershader_);
-
-}
-
-MediaSource::~MediaSource()
-{
-    // delete media surface & player
-    delete mediasurface_;
-    delete mediaplayer_;
-}
-
-void MediaSource::setPath(const std::string &p)
-{
-    path_ = p;
-    mediaplayer_->open(path_);
-    mediaplayer_->play(true);
-
-    Log::Notify("Opening %s", p.c_str());
-}
-
-std::string MediaSource::path() const
-{
-    return path_;
-}
-
-MediaPlayer *MediaSource::mediaplayer() const
-{
-    return mediaplayer_;
-}
-
-bool MediaSource::failed() const
-{
-    return mediaplayer_->failed();
-}
-
-uint MediaSource::texture() const
-{
-    return mediaplayer_->texture();
-}
-
-void MediaSource::init()
-{
-    if ( mediaplayer_->isOpen() ) {
-
-        // update video
-        mediaplayer_->update();
-
-        // once the texture of media player is created
-        if (mediaplayer_->texture() != Resource::getTextureBlack()) {
-
-            // get the texture index from media player, apply it to the media surface
-            mediasurface_->setTextureIndex( mediaplayer_->texture() );
-
-            // create Frame buffer matching size of media player
-            float height = float(mediaplayer()->width()) / mediaplayer()->aspectRatio();
-            FrameBuffer *renderbuffer = new FrameBuffer(mediaplayer()->width(), (uint)height, true);
-
-            // set the renderbuffer of the source and attach rendering nodes
-            attach(renderbuffer);
-
-            // icon in mixing view
-            if (mediaplayer_->duration() == GST_CLOCK_TIME_NONE) {
-                overlays_[View::MIXING]->attach( new Symbol(Symbol::IMAGE, glm::vec3(0.8f, 0.8f, 0.01f)) );
-                overlays_[View::LAYER]->attach( new Symbol(Symbol::IMAGE, glm::vec3(0.8f, 0.8f, 0.01f)) );
-            }
-            else {
-                overlays_[View::MIXING]->attach( new Symbol(Symbol::VIDEO, glm::vec3(0.8f, 0.8f, 0.01f)) );
-                overlays_[View::LAYER]->attach( new Symbol(Symbol::VIDEO, glm::vec3(0.8f, 0.8f, 0.01f)) );
-            }
-
-            // done init
-            initialized_ = true;
-            Log::Info("Source Media linked to Media %s.", mediaplayer()->uri().c_str());
-
-            // force update of activation mode
-            active_ = true;
-            touch();
-        }
-    }
-
-}
-
-void MediaSource::setActive (bool on)
-{
-    bool was_active = active_;
-
-    Source::setActive(on);
-
-    // change status of media player (only if status changed)
-    if ( active_ != was_active ) {
-        mediaplayer()->enable(active_);
-    }
-}
-
-void MediaSource::update(float dt)
-{
-    Source::update(dt);
-
-    // update video
-    if (active_)
-        mediaplayer_->update();
-}
-
-void MediaSource::render()
-{
-    if (!initialized_)
-        init();
-    else {
-        // render the media player into frame buffer
-        static glm::mat4 projection = glm::ortho(-1.f, 1.f, 1.f, -1.f, -1.f, 1.f);
-        renderbuffer_->begin();
-        mediasurface_->draw(glm::identity<glm::mat4>(), projection);
-        renderbuffer_->end();
-    }
-}
-
-void MediaSource::accept(Visitor& v)
-{
-    Source::accept(v);
-    v.visit(*this);
-}

Mixer.cpp

@@ -1,735 +0,0 @@
-#include <algorithm>
-#include <thread>
-#include <atomic>
-#include <vector>
-#include <chrono>
-
-//  GStreamer
-#include <gst/gst.h>
-
-#include <tinyxml2.h>
-#include "tinyxml2Toolkit.h"
-using namespace tinyxml2;
-
-#include "defines.h"
-#include "Settings.h"
-#include "Log.h"
-#include "View.h"
-#include "SystemToolkit.h"
-//#include "GarbageVisitor.h"
-#include "SessionVisitor.h"
-#include "SessionCreator.h"
-#include "SessionSource.h"
-#include "MediaSource.h"
-
-#include "Mixer.h"
-
-// static semaphore to prevent multiple threads for load / save
-static std::atomic<bool> sessionThreadActive_ = false;
-static std::atomic<bool> sessionSwapRequested_ = false;
-
-// static multithreaded session loading
-static void loadSession(const std::string& filename, Session *session)
-{
-    while (sessionThreadActive_)
-        std::this_thread::sleep_for( std::chrono::milliseconds(50));
-    sessionThreadActive_ = true;
-
-    // actual loading of xml file
-    SessionCreator creator( session );
-
-    if (creator.load(filename)) {
-        // loaded ok
-        session->setFilename(filename);
-
-        // internal update flag
-        sessionSwapRequested_ = true;
-
-        // notification
-        Log::Notify("Session %s loaded. %d source(s) created.", filename.c_str(), session->numSource());
-    }
-    else {
-        // error loading
-        Log::Warning("Failed to load Session file %s.", filename.c_str());
-    }
-
-    sessionThreadActive_ = false;
-}
-
-static std::atomic<bool> sessionImportRequested_ = false;
-static void importSession(const std::string& filename, Session *session)
-{
-    while (sessionThreadActive_)
-        std::this_thread::sleep_for( std::chrono::milliseconds(50));
-    sessionThreadActive_ = true;
-
-    // actual loading of xml file
-    SessionCreator creator( session );
-
-    if (creator.load(filename)) {
-
-        // internal update flag
-        sessionImportRequested_ = true;
-
-        Log::Notify("Session %s loaded. %d source(s) imported.", filename.c_str(), session->numSource());
-    }
-    else {
-        // error loading
-        Log::Warning("Failed to import Session file %s.", filename.c_str());
-    }
-
-    sessionThreadActive_ = false;
-}
-
-// static multithreaded session saving
-static void saveSession(const std::string& filename, Session *session)
-{
-    // reset
-    while (sessionThreadActive_)
-        std::this_thread::sleep_for( std::chrono::milliseconds(50));
-    sessionThreadActive_ = true;
-
-    // creation of XML doc
-    XMLDocument xmlDoc;
-
-    XMLElement *version = xmlDoc.NewElement(APP_NAME);
-    version->SetAttribute("major", XML_VERSION_MAJOR);
-    version->SetAttribute("minor", XML_VERSION_MINOR);
-    version->SetAttribute("size", session->numSource());
-    version->SetAttribute("date", SystemToolkit::date_time_string().c_str());
-    xmlDoc.InsertEndChild(version);
-
-    // 1. list of sources
-    XMLElement *sessionNode = xmlDoc.NewElement("Session");
-    xmlDoc.InsertEndChild(sessionNode);
-    SourceList::iterator iter;
-    for (iter = session->begin(); iter != session->end(); iter++)
-    {
-        SessionVisitor sv(&xmlDoc, sessionNode);
-        // source visitor
-        (*iter)->accept(sv);
-    }
-
-    // 2. config of views
-    XMLElement *views = xmlDoc.NewElement("Views");
-    xmlDoc.InsertEndChild(views);
-    {
-        XMLElement *mixing = xmlDoc.NewElement( "Mixing" );
-        mixing->InsertEndChild( SessionVisitor::NodeToXML(*session->config(View::MIXING), &xmlDoc));
-        views->InsertEndChild(mixing);
-
-        XMLElement *geometry = xmlDoc.NewElement( "Geometry" );
-        geometry->InsertEndChild( SessionVisitor::NodeToXML(*session->config(View::GEOMETRY), &xmlDoc));
-        views->InsertEndChild(geometry);
-
-        XMLElement *layer = xmlDoc.NewElement( "Layer" );
-        layer->InsertEndChild( SessionVisitor::NodeToXML(*session->config(View::LAYER), &xmlDoc));
-        views->InsertEndChild(layer);
-
-        XMLElement *render = xmlDoc.NewElement( "Rendering" );
-        render->InsertEndChild( SessionVisitor::NodeToXML(*session->config(View::RENDERING), &xmlDoc));
-        views->InsertEndChild(render);
-    }
-
-
-    // save file to disk
-    if ( XMLSaveDoc(&xmlDoc, filename) ) {
-        // all ok
-        session->setFilename(filename);
-        // cosmetics saved ok
-        Rendering::manager().mainWindow().setTitle(filename);
-        Settings::application.recentSessions.push(filename);
-        Log::Notify("Session %s saved.", filename.c_str());
-
-        // set session filename
-    }
-    else {
-        // error loading
-        Log::Warning("Failed to save Session file %s.", filename.c_str());
-    }
-
-    sessionThreadActive_ = false;
-}
-
-Mixer::Mixer() : session_(nullptr), back_session_(nullptr), current_view_(nullptr),
-                 update_time_(GST_CLOCK_TIME_NONE), dt_(0.f)
-{
-    // unsused initial empty session
-    session_ = new Session;
-    current_source_ = session_->end();
-    current_source_index_ = -1;
-
-    // auto load if Settings ask to
-    if ( Settings::application.recentSessions.load_at_start &&
-         Settings::application.recentSessions.valid_file &&
-         Settings::application.recentSessions.filenames.size() > 0 )
-        load( Settings::application.recentSessions.filenames.front() );
-    else
-        // initializes with a new empty session
-        clear();
-
-    // this initializes with the current view
-    setView( (View::Mode) Settings::application.current_view );
-}
-
-void Mixer::update()
-{
-    // change session when threaded loading is finished
-    if (sessionSwapRequested_) {
-        sessionSwapRequested_ = false;
-        // successfully loading
-        if ( back_session_ ) {
-            // swap front and back sessions
-            swap();
-            // set session filename
-            Rendering::manager().mainWindow().setTitle(session_->filename());
-            Settings::application.recentSessions.push(session_->filename());
-        }
-    }
-    // merge session when threaded loading is finished
-    if (sessionImportRequested_) {
-        sessionImportRequested_ = false;
-        merge(back_session_);
-        back_session_ = nullptr;
-    }
-
-    // insert source candidate for this session
-    if (candidate_sources_.size() > 0) {
-        // NB: only make the last candidate the current source in Mixing view
-        insertSource(candidate_sources_.front(), candidate_sources_.size() > 1 ? View::INVALID : View::MIXING);
-        candidate_sources_.pop_front();
-    }
-
-    // compute dt
-    if (update_time_ == GST_CLOCK_TIME_NONE)
-        update_time_ = gst_util_get_timestamp ();
-    gint64 current_time = gst_util_get_timestamp ();
-    // dt is in milisecond, with fractional precision (from micro seconds)
-    dt_ = static_cast<float>( GST_TIME_AS_USECONDS(current_time - update_time_) * 0.001f);
-    update_time_ = current_time;
-
-    // update session and associated sources
-    session_->update(dt_);
-
-    // delete sources which failed update (one by one)
-    if (session()->failedSource() != nullptr)
-        deleteSource(session()->failedSource());
-
-    // update views
-    mixing_.update(dt_);
-    geometry_.update(dt_);
-    layer_.update(dt_);
-    transition_.update(dt_);
-
-    // optimize the reordering in depth for views;
-    // deep updates shall be performed only 1 frame
-    View::need_deep_update_ = false;
-}
-
-void Mixer::draw()
-{
-    // draw the current view in the window
-    current_view_->draw();
-
-    // make sure we disable fading of session rendering
-    if (current_view_ != &transition_)
-        session_->fadeIn();
-}
-
-// manangement of sources
-Source * Mixer::createSourceFile(std::string path)
-{
-    // ready to create a source
-    Source *s = nullptr;
-
-    // sanity check
-    if ( SystemToolkit::file_exists( path ) ) {
-
-        // test type of file by extension
-        std::string ext = SystemToolkit::extension_filename(path);
-        if ( ext == "mix" )
-        {
-            // create a session source
-            SessionSource *ss = new SessionSource();
-            ss->load(path);
-            s = ss;
-        }
-        else {
-            // (try to) create media source by default
-            MediaSource *ms = new MediaSource;
-            ms->setPath(path);
-            s = ms;
-        }
-
-        // remember in recent media
-        Settings::application.recentImport.push(path);
-        Settings::application.recentImport.path = SystemToolkit::path_filename(path);
-
-        // propose a new name based on uri
-        renameSource(s, SystemToolkit::base_filename(path));
-
-    }
-    else
-        Log::Notify("File %s does not exist.", path.c_str());
-
-    return s;
-}
-
-Source * Mixer::createSourceRender()
-{
-    // ready to create a source
-    RenderSource *s = new RenderSource(session_);
-
-    // propose a new name based on session name
-    renameSource(s, SystemToolkit::base_filename(session_->filename()));
-
-    return s;
-}
-
-Source * Mixer::createSourceClone(std::string namesource)
-{
-    // ready to create a source
-    Source *s = nullptr;
-
-    // origin to clone is either the given name or the current
-    SourceList::iterator origin = session_->end();
-    if ( !namesource.empty() )
-        origin =session_->find(namesource);
-    else if (current_source_ != session_->end())
-        origin = current_source_;
-
-    // have an origin, can clone it
-    if (origin != session_->end()) {
-
-        // create a source
-        s = (*origin)->clone();
-
-        // get new name
-        renameSource(s, (*origin)->name());
-    }
-
-    return s;
-}
-
-void Mixer::addSource(Source *s)
-{
-    if (s != nullptr)
-        candidate_sources_.push_back(s);
-}
-
-void Mixer::insertSource(Source *s, View::Mode m)
-{
-    if ( s != nullptr )
-    {
-        // Add source to Session
-        SourceList::iterator sit = session_->addSource(s);
-
-        // set a default depth to the new source
-        layer_.setDepth(s);
-
-        // set a default alpha to the new source
-        mixing_.setAlpha(s);
-
-        // add sources Nodes to all views
-        mixing_.scene.ws()->attach(s->group(View::MIXING));
-        geometry_.scene.ws()->attach(s->group(View::GEOMETRY));
-        layer_.scene.ws()->attach(s->group(View::LAYER));
-
-        // if requested to show the source in a given view
-        // (known to work for View::MIXING et TRANSITION: other views untested)
-        if (m != View::INVALID) {
-
-            // switch to this view to show source created
-            setView(m);
-            current_view_->update(0.f);
-            current_view_->centerSource(s);
-
-            // set this new source as current
-            setCurrentSource( sit );
-        }
-    }
-}
-
-void Mixer::deleteSource(Source *s)
-{
-    if ( s != nullptr )
-    {
-        // in case it was the current source...
-        unsetCurrentSource();
-
-        // in case it was selected..
-        selection().remove(s);
-
-        // keep name for log
-        std::string name = s->name();
-
-        // remove source Nodes from all views
-        mixing_.scene.ws()->detatch( s->group(View::MIXING) );
-        geometry_.scene.ws()->detatch( s->group(View::GEOMETRY) );
-        layer_.scene.ws()->detatch( s->group(View::LAYER) );
-        transition_.scene.ws()->detatch( s->group(View::TRANSITION) );
-
-        // delete source
-        session_->deleteSource(s);
-
-        // log
-        Log::Notify("Source %s deleted.", name.c_str());
-    }
-
-    // cancel transition source in TRANSITION view
-    if ( current_view_ == &transition_ ) {
-        // cancel attachment
-        transition_.attach(nullptr);
-        // revert to mixing view
-        setView(View::MIXING);
-    }
-}
-
-
-void Mixer::deleteSelection()
-{
-    while ( !selection().empty() )
-        deleteSource( selection().front());
-
-}
-
-void Mixer::renameSource(Source *s, const std::string &newname)
-{
-    if ( s != nullptr )
-    {
-        // tentative new name
-        std::string tentativename = newname;
-
-        // refuse to rename to an empty name
-        if ( newname.empty() )
-            tentativename = "source";
-
-        // trivial case : same name as current
-        if ( tentativename == s->name() )
-            return;
-
-        // search for a source of the name 'tentativename'
-        std::string basename = tentativename;
-        int count = 1;
-        while ( std::find_if(session_->begin(), session_->end(), Source::hasName(tentativename)) != session_->end() ) {
-            tentativename = basename + std::to_string(++count);
-        }
-
-        // ok to rename
-        s->setName(tentativename);
-    }
-}
-
-void Mixer::setCurrentSource(SourceList::iterator it)
-{
-    // nothing to do if already current
-    if ( current_source_ == it )
-        return;
-
-    // clear current (even if it is invalid)
-    unsetCurrentSource();
-
-    // change current if it is valid
-    if ( it != session_->end() ) {
-        current_source_ = it;
-        current_source_index_ = session_->index(current_source_);
-
-        // set selection for this only source if not already part of a selection
-        if (!selection().contains(*current_source_))
-            selection().set(*current_source_);
-
-        // show status as current
-        (*current_source_)->setMode(Source::CURRENT);
-
-        (*current_source_)->group(View::MIXING)->update_callbacks_.push_back(new BounceScaleCallback);
-        (*current_source_)->group(View::LAYER)->update_callbacks_.push_back(new BounceScaleCallback);
-    }
-
-}
-
-Source * Mixer::findSource (Node *node)
-{
-    SourceList::iterator it = session_->find(node);
-    if (it != session_->end())
-        return *it;
-    return nullptr;
-}
-
-Source * Mixer::findSource (std::string namesource)
-{
-    SourceList::iterator it = session_->find(namesource);
-    if (it != session_->end())
-        return *it;
-    return nullptr;
-}
-
-void Mixer::setCurrentSource(Node *node)
-{
-    setCurrentSource( session_->find(node) );
-}
-
-void Mixer::setCurrentSource(std::string namesource)
-{
-    setCurrentSource( session_->find(namesource) );
-}
-
-void Mixer::setCurrentSource(Source *s)
-{
-    setCurrentSource( session_->find(s) );
-}
-
-void Mixer::setCurrentSource(int index)
-{
-    setCurrentSource( session_->find(index) );
-}
-
-void Mixer::setCurrentNext()
-{
-    SourceList::iterator it = current_source_;
-
-    it++;
-
-    if (it == session_->end())  {
-        it = session_->begin();
-    }
-
-    setCurrentSource( it );
-}
-
-void Mixer::unsetCurrentSource()
-{
-    // discard overlay for previously current source
-    if ( current_source_ != session_->end() ) {
-
-        // current source is part of a selection, just change status
-        if (selection().size() > 1) {
-            (*current_source_)->setMode(Source::SELECTED);
-        }
-        // current source is the only selected source, unselect too
-        else
-        {
-            // remove from selection
-            selection().remove( *current_source_ );
-        }
-
-        // deselect current source
-        current_source_ = session_->end();
-        current_source_index_ = -1;
-    }
-}
-
-int Mixer::indexCurrentSource()
-{
-    return current_source_index_;
-}
-
-Source *Mixer::currentSource()
-{
-    if ( current_source_ == session_->end() )
-        return nullptr;
-    else {
-        return *(current_source_);
-    }
-}
-
-// management of view
-void Mixer::setView(View::Mode m)
-{
-    // special case when leaving transition view
-    if ( current_view_ == &transition_ ) {
-        // get the session detached from the transition view and set it as current session
-        // NB: detatch() can return nullptr, which is then ignored.
-        set ( transition_.detach() );
-    }
-
-    switch (m) {
-    case View::TRANSITION:
-        current_view_ = &transition_;
-        break;
-    case View::GEOMETRY:
-        current_view_ = &geometry_;
-        break;
-    case View::LAYER:
-        current_view_ = &layer_;
-        break;
-    case View::MIXING:
-    default:
-        current_view_ = &mixing_;
-        break;
-    }
-
-    Settings::application.current_view = (int) m;
-}
-
-View *Mixer::view(View::Mode m)
-{
-    switch (m) {
-    case View::TRANSITION:
-        return &transition_;
-    case View::GEOMETRY:
-        return &geometry_;
-    case View::LAYER:
-        return &layer_;
-    case View::MIXING:
-        return &mixing_;
-    default:
-        return current_view_;
-    }
-}
-
-void Mixer::save()
-{
-    if (!session_->filename().empty())
-        saveas(session_->filename());
-}
-
-void Mixer::saveas(const std::string& filename)
-{
-    // optional copy of views config
-    session_->config(View::MIXING)->copyTransform( mixing_.scene.root() );
-    session_->config(View::GEOMETRY)->copyTransform( geometry_.scene.root() );
-    session_->config(View::LAYER)->copyTransform( layer_.scene.root() );
-
-    // launch a thread to save the session
-    std::thread (saveSession, filename, session_).detach();
-}
-
-void Mixer::load(const std::string& filename)
-{
-    if (back_session_)
-        delete back_session_;
-
-    // create empty session
-    back_session_ = new Session;
-
-    // launch a thread to load the session into back_session
-    std::thread (loadSession, filename, back_session_).detach();
-}
-
-void Mixer::open(const std::string& filename)
-{
-    if (Settings::application.smooth_transition)
-    {
-        // create special SessionSource to be used for the smooth transition
-        SessionSource *ts = new SessionSource();
-        ts->load(filename);
-        // propose a new name based on uri
-        renameSource(ts, SystemToolkit::base_filename(filename));
-
-        // insert source and switch to transition view
-        insertSource(ts, View::TRANSITION);
-
-        // attach the SessionSource to the transition view
-        transition_.attach(ts);
-    }
-    else
-        load(filename);
-}
-
-void Mixer::import(const std::string& filename)
-{
-    if (back_session_)
-        delete back_session_;
-
-    // create empty session
-    back_session_ = new Session;
-
-    // launch a thread to load the session into back_session
-    std::thread (importSession, filename, back_session_).detach();
-}
-
-void Mixer::merge(Session *session)
-{
-    if (session) {
-
-        for ( Source *s = session->popSource(); s != nullptr; s = session->popSource())
-            insertSource(s);
-
-        delete session;
-    }
-}
-
-void Mixer::swap()
-{
-    if (!back_session_)
-        return;
-
-    if (session_) {
-        // clear selection
-        selection().clear();
-        // detatch current session's nodes from views
-        for (auto source_iter = session_->begin(); source_iter != session_->end(); source_iter++)
-        {
-            mixing_.scene.ws()->detatch( (*source_iter)->group(View::MIXING) );
-            geometry_.scene.ws()->detatch( (*source_iter)->group(View::GEOMETRY) );
-            layer_.scene.ws()->detatch( (*source_iter)->group(View::LAYER) );
-            transition_.scene.ws()->detatch( (*source_iter)->group(View::TRANSITION) );
-        }
-    }
-
-    // swap back and front
-    Session *tmp = session_;
-    session_ = back_session_;
-    back_session_ = tmp;
-
-    // attach new session's nodes to views
-    for (auto source_iter = session_->begin(); source_iter != session_->end(); source_iter++)
-    {
-        mixing_.scene.ws()->attach( (*source_iter)->group(View::MIXING) );
-        geometry_.scene.ws()->attach( (*source_iter)->group(View::GEOMETRY) );
-        layer_.scene.ws()->attach( (*source_iter)->group(View::LAYER) );
-    }
-
-    // optional copy of views config
-    mixing_.scene.root()->copyTransform( session_->config(View::MIXING) );
-    geometry_.scene.root()->copyTransform( session_->config(View::GEOMETRY) );
-    layer_.scene.root()->copyTransform( session_->config(View::LAYER) );
-
-    // set resolution
-    session_->setResolution( session_->config(View::RENDERING)->scale_ );
-
-    // request complete update for views
-    View::need_deep_update_ = true;
-
-    // no current source
-    current_source_ = session_->end();
-    current_source_index_ = -1;
-
-    // reset timer
-    update_time_ = GST_CLOCK_TIME_NONE;
-
-    // delete back
-    delete back_session_;
-    back_session_ = nullptr;
-}
-
-void Mixer::clear()
-{
-    // delete previous back session if needed
-    if (back_session_)
-        delete back_session_;
-
-    // create empty session
-    back_session_ = new Session;   
-
-    // swap current with empty
-    sessionSwapRequested_ = true;
-
-    Log::Info("New session ready.");
-}
-
-void Mixer::set(Session *s)
-{
-    if ( s == nullptr )
-        return;
-
-    // delete previous back session if needed
-    if (back_session_)
-        delete back_session_;
-
-    // set to new given session
-    back_session_ = s;
-
-    // swap current with given session
-    sessionSwapRequested_ = true;
-}

Mixer.h

@@ -1,101 +0,0 @@
-#ifndef MIXER_H
-#define MIXER_H
-
-#include "View.h"
-#include "Session.h"
-#include "Selection.h"
-
-class Mixer
-{
-    // Private Constructor
-    Mixer();
-    Mixer(Mixer const& copy);            // Not Implemented
-    Mixer& operator=(Mixer const& copy); // Not Implemented
-
-public:
-
-    static Mixer& manager()
-    {
-        // The only instance
-        static Mixer _instance;
-        return _instance;
-    }
-
-    static Selection& selection()
-    {
-        // The only instance
-        static Selection _selection;
-        return _selection;
-    }
-
-    // update session and all views
-    void update();
-    inline float dt() const { return dt_;}
-
-    // draw session and current view
-    void draw();
-
-    // creation of sources
-    Source * createSourceFile   (std::string path);
-    Source * createSourceClone  (std::string namesource = "");
-    Source * createSourceRender ();
-
-    // operations on sources
-    void addSource    (Source *s);
-    void deleteSource (Source *s);
-    void renameSource (Source *s, const std::string &newname);
-    void deleteSelection();
-
-    // current source
-    void setCurrentSource (Source *s);
-    void setCurrentSource (std::string namesource);
-    void setCurrentSource (Node *node);
-    void setCurrentSource (int index);
-    void setCurrentNext ();
-    void unsetCurrentSource ();
-    int  indexCurrentSource ();
-    Source * currentSource ();
-
-    // browsing into sources
-    Source * findSource (Node *node);
-    Source * findSource (std::string name);
-
-    // management of view
-    View *view   (View::Mode m = View::INVALID);
-    void setView (View::Mode m);
-
-    // manipulate, load and save sessions
-    inline Session *session () const { return session_; }
-    void clear  ();
-    void save   ();
-    void saveas (const std::string& filename);
-    void load   (const std::string& filename);
-    void open   (const std::string& filename);
-    void import (const std::string& filename);
-    void merge  (Session *s);
-    void set    (Session *s);
-
-protected:
-
-    Session *session_;
-    Session *back_session_;
-    void swap();
-
-    SourceList candidate_sources_;
-    void insertSource(Source *s, View::Mode m = View::INVALID);
-
-    void setCurrentSource(SourceList::iterator it);
-    SourceList::iterator current_source_;
-    int current_source_index_;
-
-    View *current_view_;
-    MixingView mixing_;
-    GeometryView geometry_;
-    LayerView layer_;
-    TransitionView transition_;
-
-    gint64 update_time_;
-    float dt_;
-};
-
-#endif // MIXER_H

PickingVisitor.cpp

@@ -1,177 +0,0 @@
-#include "PickingVisitor.h"
-
-#include "Log.h"
-#include "Primitives.h"
-#include "Decorations.h"
-
-#include "GlmToolkit.h"
-#include <glm/gtc/type_ptr.hpp>
-#include <glm/gtc/matrix_access.hpp>
-#include <glm/gtc/matrix_transform.hpp>
-#include <glm/gtx/string_cast.hpp>
-#include <glm/gtx/vector_angle.hpp>
-
-
-PickingVisitor::PickingVisitor(glm::vec3 coordinates) : Visitor()
-{
-    modelview_ = glm::mat4(1.f);
-    points_.push_back( coordinates );
-}
-
-PickingVisitor::PickingVisitor(glm::vec3 selectionstart, glm::vec3 selection_end) : Visitor()
-{
-    modelview_ = glm::mat4(1.f);
-    points_.push_back( selectionstart );
-    points_.push_back( selection_end );
-}
-
-void PickingVisitor::visit(Node &n)
-{
-    // use the transform modified during update
-    modelview_ *= n.transform_;
-
-//      modelview_ *= transform(n.translation_, n.rotation_, n.scale_);
-//    Log::Info("Node %d", n.id());
-//    Log::Info("%s", glm::to_string(modelview_).c_str());
-}
-
-void PickingVisitor::visit(Group &n)
-{
-    if (!n.visible_)
-        return;
-
-    glm::mat4 mv = modelview_;
-    for (NodeSet::iterator node = n.begin(); node != n.end(); node++) {
-        if ( (*node)->visible_ )
-            (*node)->accept(*this);
-        modelview_ = mv;
-    }
-}
-
-void PickingVisitor::visit(Switch &n)
-{
-    if (!n.visible_ || n.numChildren()<1)
-        return;
-
-    glm::mat4 mv = modelview_;
-    n.activeChild()->accept(*this);
-    modelview_ = mv;
-}
-
-void PickingVisitor::visit(Primitive &n)
-{
-    // TODO: generic visitor for primitive with random shape ?
-
-}
-
-void PickingVisitor::visit(Surface &n)
-{
-    if (!n.visible_)
-        return;
-
-    // if more than one point given for testing: test overlap
-    if (points_.size() > 1) {
-        // create bounding box for those points (2 in practice)
-        GlmToolkit::AxisAlignedBoundingBox bb_points;
-        bb_points.extend(points_);
-
-        // apply inverse transform
-        bb_points = bb_points.transformed(glm::inverse(modelview_)) ;
-
-        // test bounding box for overlap with inverse transform bbox
-        if ( bb_points.intersect( n.bbox() ) )
-//            if ( n.bbox().contains( bb_points ) )
-            // add this surface to the nodes picked
-            nodes_.push_back( std::pair(&n, glm::vec2(0.f)) );
-    }
-    // only one point
-    else if (points_.size() > 0) {
-
-        // apply inverse transform to the point of interest
-        glm::vec4 P = glm::inverse(modelview_) * glm::vec4( points_[0], 1.f );
-
-        // test bounding box for picking from a single point
-        if ( n.bbox().contains( glm::vec3(P)) )
-            // add this surface to the nodes picked
-            nodes_.push_back( std::pair(&n, glm::vec2(P)) );
-    }
-}
-
-void PickingVisitor::visit(Frame &n)
-{
-//    if (n.border())
-//        n.border()->accept(*this);
-}
-
-void PickingVisitor::visit(Handles &n)
-{
-    // discard if not visible or if not exactly one point given for picking
-    if (!n.visible_ || points_.size() != 1)
-        return;
-
-    // apply inverse transform to the point of interest
-    glm::vec4 P = glm::inverse(modelview_) * glm::vec4( points_[0], 1.f );
-
-    // inverse transform to check the scale
-    glm::vec4 S = glm::inverse(modelview_) * glm::vec4( 0.05f, 0.05f, 0.f, 0.f );
-    float scale = glm::length( glm::vec2(S) );
-
-    bool picked = false;
-    if ( n.type() == Handles::RESIZE ) {
-        // 4 corners
-        picked = ( glm::length(glm::vec2(+1.f, +1.f)- glm::vec2(P)) < scale ||
-                   glm::length(glm::vec2(+1.f, -1.f)- glm::vec2(P)) < scale ||
-                   glm::length(glm::vec2(-1.f, +1.f)- glm::vec2(P)) < scale ||
-                   glm::length(glm::vec2(-1.f, -1.f)- glm::vec2(P)) < scale );
-    }
-    else if ( n.type() == Handles::RESIZE_H ){
-        // left & right
-        picked = ( glm::length(glm::vec2(+1.f, 0.f)- glm::vec2(P)) < scale ||
-                   glm::length(glm::vec2(-1.f, 0.f)- glm::vec2(P)) < scale );
-    }
-    else if ( n.type() == Handles::RESIZE_V ){
-        // top & bottom
-        picked = ( glm::length(glm::vec2(0.f, +1.f)- glm::vec2(P)) < scale ||
-                   glm::length(glm::vec2(0.f, -1.f)- glm::vec2(P)) < scale );
-    }
-    else if ( n.type() == Handles::ROTATE ){
-        // the icon for rotation is on the right top corner at (0.12, 0.12) in scene coordinates
-        glm::vec4 vec = glm::inverse(modelview_) * glm::vec4( 0.1f, 0.1f, 0.f, 0.f );
-        float l = glm::length( glm::vec2(vec) );
-        picked  = glm::length( glm::vec2( 1.f + l, 1.f + l) - glm::vec2(P) ) < 1.5f * scale;
-    }
-
-    if ( picked )
-        // add this to the nodes picked
-        nodes_.push_back( std::pair(&n, glm::vec2(P)) );
-
-}
-
-void PickingVisitor::visit(LineSquare &)
-{
-//    // apply inverse transform to the point of interest
-//    glm::vec4 P = glm::inverse(modelview_) * glm::vec4( point_A_, 0.f, 1.f );
-
-//    // lower left corner
-//    glm::vec3 LL = glm::vec3( -1.f, -1.f, 0.f );
-//    // up right corner
-//    glm::vec3 UR = glm::vec3( 1.f, 1.f, 0.f );
-
-//    // if P is over a line [LL UR] rectangle:
-//    // TODO
-}
-
-void PickingVisitor::visit(LineCircle &n)
-{
-//    // apply inverse transform to the point of interest
-//    glm::vec4 P = glm::inverse(modelview_) * glm::vec4( point_A_, 0.f, 1.f );
-
-//    float r = glm::length( glm::vec2(P) );
-//    if ( r < 1.02 && r > 0.98)
-//        nodes_.push_back( std::pair(&n, glm::vec2(P)) );
-}
-
-void PickingVisitor::visit(Scene &n)
-{
-    n.root()->accept(*this);
-}

PickingVisitor.h

@@ -1,37 +0,0 @@
-#ifndef PICKINGVISITOR_H
-#define PICKINGVISITOR_H
-
-#include <glm/glm.hpp>
-#include <vector>
-#include <utility>
-
-#include "Visitor.h"
-
-class PickingVisitor: public Visitor
-{
-    std::vector<glm::vec3> points_;
-    glm::mat4 modelview_;
-    std::vector< std::pair<Node *, glm::vec2> > nodes_;
-
-public:
-
-    PickingVisitor(glm::vec3 coordinates);
-    PickingVisitor(glm::vec3 selectionstart, glm::vec3 selection_end);
-    std::vector< std::pair<Node *, glm::vec2> > picked() { return nodes_; }
-
-    // Elements of Scene
-    void visit(Scene& n) override;
-    void visit(Node& n) override;
-    void visit(Group& n) override;
-    void visit(Switch& n) override;
-    void visit(Primitive& n) override;
-
-    void visit(Surface& n) override;
-    void visit(Frame& n) override;
-    void visit(Handles& n) override;
-    void visit(LineSquare&) override;
-    void visit(LineCircle& n) override;
-
-};
-
-#endif // PICKINGVISITOR_H

Primitives.cpp

@@ -1,391 +0,0 @@
-#include "Primitives.h"
-#include "ImageShader.h"
-#include "Resource.h"
-#include "FrameBuffer.h"
-#include "MediaPlayer.h"
-#include "Visitor.h"
-#include "Log.h"
-
-#include <glad/glad.h>
-
-#include <glm/gtc/type_ptr.hpp>
-#include <glm/gtc/matrix_access.hpp>
-#include <glm/gtc/matrix_transform.hpp>
-#include <glm/gtc/constants.hpp>
-
-#define GLM_ENABLE_EXPERIMENTAL
-#include <glm/gtx/rotate_vector.hpp>
-
-
-
-Surface::Surface(Shader *s) : Primitive(s), textureindex_(0)
-{
-    // geometry for a trianglulated simple rectangle surface with UV
-    //  (0,0) B +---+ D (1,0)
-    //          |\  |
-    //          | \ |
-    //          |  \|
-    //  (0,1) A +---+ C (1,1)
-
-    points_ = std::vector<glm::vec3> { glm::vec3( -1.f, -1.f, 0.f ), glm::vec3( -1.f, 1.f, 0.f ),
-            glm::vec3( 1.f, -1.f, 0.f ), glm::vec3( 1.f, 1.f, 0.f ) };
-    colors_ = std::vector<glm::vec4> { glm::vec4( 1.f, 1.f, 1.f , 1.f ), glm::vec4(  1.f, 1.f, 1.f, 1.f  ),
-            glm::vec4( 1.f, 1.f, 1.f, 1.f ), glm::vec4( 1.f, 1.f, 1.f, 1.f ) };
-    texCoords_ = std::vector<glm::vec2> { glm::vec2( 0.f, 1.f ), glm::vec2( 0.f, 0.f ),
-            glm::vec2( 1.f, 1.f ), glm::vec2( 1.f, 0.f ) };
-    indices_ = std::vector<uint> { 0, 1, 2, 3 };
-    drawMode_ = GL_TRIANGLE_STRIP;
-}
-
-
-Surface::~Surface()
-{
-    // do NOT delete vao_ (unique)
-    vao_ = 0;
-}
-
-void Surface::init()
-{
-    // use static unique vertex array object
-    static uint unique_vao_ = 0;
-    static uint unique_drawCount = 0;
-    if (unique_vao_) {
-        // 1. only init Node (not the primitive vao)
-        Node::init();
-        // 2. use the global vertex array object
-        vao_ = unique_vao_;
-        drawCount_ = unique_drawCount;
-        // compute AxisAlignedBoundingBox
-        bbox_.extend(points_);
-        // arrays of vertices are not needed anymore
-        points_.clear();
-        colors_.clear();
-        texCoords_.clear();
-        indices_.clear();
-    }
-    else {
-        // 1. init the Primitive (only once)
-        Primitive::init();
-        // 2. remember global vertex array object
-        unique_vao_ = vao_;
-        unique_drawCount = drawCount_;
-        // 3. unique_vao_ will NOT be deleted
-    }
-
-}
-
-void Surface::accept(Visitor& v)
-{
-    Primitive::accept(v);
-    v.visit(*this);
-}
-
-void Surface::draw(glm::mat4 modelview, glm::mat4 projection)
-{
-    if ( !initialized() )
-        init();
-
-    if ( textureindex_ )
-        glBindTexture(GL_TEXTURE_2D, textureindex_);
-    else
-        glBindTexture(GL_TEXTURE_2D, Resource::getTextureBlack());
-
-    Primitive::draw(modelview, projection);
-
-    glBindTexture(GL_TEXTURE_2D, 0);
-}
-
-ImageSurface::ImageSurface(const std::string& path, Shader *s) : Surface(s), resource_(path)
-{
-
-}
-
-void ImageSurface::init()
-{
-    Surface::init();
-
-    // load image if specified (should always be the case)
-    if ( !resource_.empty()) {
-        textureindex_ = Resource::getTextureImage(resource_);
-    }
-}
-
-void ImageSurface::accept(Visitor& v)
-{
-    Surface::accept(v);
-    v.visit(*this);
-}
-
-MediaSurface::MediaSurface(const std::string& p, Shader *s) : Surface(s)
-{
-    path_ = p;
-    mediaplayer_ = new MediaPlayer;
-}
-
-MediaSurface::~MediaSurface()
-{
-    delete mediaplayer_;
-}
-
-void MediaSurface::init()
-{
-    Surface::init();
-
-    mediaplayer_->open(path_);
-    mediaplayer_->play(true);
-}
-
-void MediaSurface::draw(glm::mat4 modelview, glm::mat4 projection)
-{
-    if ( !initialized() )
-        init();
-
-    // set the texture to the media player once openned
-    // TODO: avoid to repeat with a static flag?
-    if ( mediaplayer_->isOpen() )
-        textureindex_ = mediaplayer_->texture();
-
-    Surface::draw(modelview, projection);
-}
-
-void MediaSurface::update( float dt )
-{
-    if ( mediaplayer_->isOpen() ) {
-        mediaplayer_->update();
-        scale_.x = mediaplayer_->aspectRatio();
-    }
-
-    Primitive::update( dt );
-}
-
-void MediaSurface::accept(Visitor& v)
-{
-    Surface::accept(v);
-    v.visit(*this);
-}
-
-
-FrameBufferSurface::FrameBufferSurface(FrameBuffer *fb, Shader *s) : Surface(s), frame_buffer_(fb)
-{
-
-}
-
-void FrameBufferSurface::init()
-{
-    Surface::init();
-
-    // set aspect ratio
-    scale_.x = frame_buffer_->aspectRatio();
-
-}
-
-void FrameBufferSurface::draw(glm::mat4 modelview, glm::mat4 projection)
-{
-    if ( !initialized() )
-        init();
-
-    glBindTexture(GL_TEXTURE_2D, frame_buffer_->texture());
-
-    Primitive::draw(modelview, projection);
-
-    glBindTexture(GL_TEXTURE_2D, 0);
-}
-
-void FrameBufferSurface::accept(Visitor& v)
-{
-    Surface::accept(v);
-    v.visit(*this);
-}
-
-
-Points::Points(std::vector<glm::vec3> points, glm::vec4 color, uint pointsize) : Primitive(new Shader)
-{
-    for(size_t i = 0; i < points.size(); ++i)
-    {
-        points_.push_back( points[i] );
-        colors_.push_back( color );
-        indices_.push_back ( i );
-    }
-
-    drawMode_ = GL_POINTS; // TODO implement drawing of points as Mesh
-    pointsize_ = pointsize;
-}
-
-
-
-void Points::draw(glm::mat4 modelview, glm::mat4 projection)
-{
-    if ( !initialized() )
-        init();
-
-    glPointSize(pointsize_);
-
-    Primitive::draw(modelview, projection);
-
-    glPointSize(1);
-}
-
-void Points::accept(Visitor& v)
-{
-    Primitive::accept(v);
-    v.visit(*this);
-}
-
-LineStrip::LineStrip(std::vector<glm::vec3> points, std::vector<glm::vec4> colors, uint linewidth) : Primitive(new Shader), linewidth_(linewidth)
-{
-    for(size_t i = 0; i < points.size(); ++i)
-    {
-        points_.push_back( points[i] );
-        colors_.push_back( colors[i] );
-        indices_.push_back ( i );
-    }
-
-    drawMode_ = GL_LINE_STRIP;
-}
-
-void LineStrip::draw(glm::mat4 modelview, glm::mat4 projection)
-{
-    if ( !initialized() )
-        init();
-
-   // glLineWidth(linewidth_ * 2.f * Rendering::manager().mainWindow().dpiScale());
-
-    glm::mat4 mv = modelview;
-    glm::mat4 scale = glm::scale(glm::identity<glm::mat4>(), glm::vec3(1.001f, 1.001f, 1.f));
-
-    // TODO FIXME drawing multiple times is not correct to draw lines of different width
-    // TODO Draw LineStrip using polygons
-    for (uint i = 0 ; i < linewidth_ ; ++i ) {
-        Primitive::draw(mv, projection);
-        mv *= scale;
-    }
-
-   // glLineWidth(1);
-}
-
-void LineStrip::accept(Visitor& v)
-{
-    Primitive::accept(v);
-    v.visit(*this);
-}
-
-
-
-static const std::vector<glm::vec3> square_points {
-            glm::vec3( -1.f, -1.f, 0.f ), glm::vec3( -1.f, 1.f, 0.f ),
-            glm::vec3( 1.f, 1.f, 0.f ), glm::vec3( 1.f, -1.f, 0.f ),
-            glm::vec3( -1.f, -1.f, 0.f )
-};
-
-static const std::vector<glm::vec4> square_colors {
-            glm::vec4( 1.f, 1.f, 1.f, 1.f ), glm::vec4( 1.f, 1.f, 1.f, 1.f ),
-            glm::vec4( 1.f, 1.f, 1.f, 1.f ), glm::vec4( 1.f, 1.f, 1.f, 1.f ),
-            glm::vec4( 1.f, 1.f, 1.f, 1.f )
-};
-
-LineSquare::LineSquare(uint linewidth) : LineStrip(square_points, square_colors, linewidth)
-{
-}
-
-void LineSquare::init()
-{
-    // use static unique vertex array object
-    static uint unique_vao_ = 0;
-    static uint unique_drawCount = 0;
-    if (unique_vao_) {
-        // 1. only init Node (not the primitive vao)
-        Node::init();
-        // 2. use the global vertex array object
-        vao_ = unique_vao_;
-        drawCount_ = unique_drawCount;
-        // compute AxisAlignedBoundingBox
-        bbox_.extend(points_);
-        // arrays of vertices are not needed anymore
-        points_.clear();
-        colors_.clear();
-        texCoords_.clear();
-        indices_.clear();
-    }
-    else {
-        // 1. init the Primitive (only once)
-        Primitive::init();
-        // 2. remember global vertex array object
-        unique_vao_ = vao_;
-        unique_drawCount = drawCount_;
-    }
-}
-
-void LineSquare::accept(Visitor& v)
-{
-    Primitive::accept(v);
-    v.visit(*this);
-}
-
-LineSquare::~LineSquare()
-{
-    // do NOT delete vao_ (unique)
-    vao_ = 0;
-}
-
-
-LineCircle::LineCircle(uint linewidth) : LineStrip(std::vector<glm::vec3>(), std::vector<glm::vec4>(), linewidth)
-{
-    static int N = 72;
-    static float a =  glm::two_pi<float>() / static_cast<float>(N);
-    static glm::vec4 circle_color_points = glm::vec4(1.f, 1.f, 1.f, 1.f);
-    // loop to build a circle
-    glm::vec3 P(1.f, 0.f, 0.f);
-    for (int i = 0; i < N ; i++ ){
-        points_.push_back( glm::vec3(P) );
-        colors_.push_back( circle_color_points );
-        indices_.push_back ( i );
-
-        P = glm::rotateZ(P, a);
-    }
-    // close loop
-    points_.push_back( glm::vec3(1.f, 0.f, 0.f) );
-    colors_.push_back( circle_color_points );
-    indices_.push_back ( N );
-}
-
-void LineCircle::init()
-{
-    // use static unique vertex array object
-    static uint unique_vao_ = 0;
-    static uint unique_drawCount = 0;
-    if (unique_vao_) {
-        // 1. only init Node (not the primitive vao)
-        Node::init();
-        // 2. use the global vertex array object
-        vao_ = unique_vao_;
-        drawCount_ = unique_drawCount;        
-        // replace AxisAlignedBoundingBox
-        bbox_.extend(points_);
-        // arrays of vertices are not needed anymore (STATIC DRAW of vertex object)
-        points_.clear();
-        colors_.clear();
-        texCoords_.clear();
-        indices_.clear();
-    }
-    else {
-        // 1. init the Primitive (only once)
-        Primitive::init();
-        // 2. remember global vertex array object
-        unique_vao_ = vao_;
-        unique_drawCount = drawCount_;
-        // 3. unique_vao_ will NOT be deleted because LineCircle::deleteGLBuffers_() is empty
-    }
-}
-
-void LineCircle::accept(Visitor& v)
-{
-    Primitive::accept(v);
-    v.visit(*this);
-}
-
-
-LineCircle::~LineCircle()
-{
-    // do NOT delete vao_ (unique)
-    vao_ = 0;
-}

README.md

@@ -1,43 +1,122 @@
 # vimix
-Live Video Mixer
+Live Video Mixing
 
-*/!\ Work in progress*
+vimix performs graphical mixing and blending of several movie clips and
+computer generated graphics, with image processing effects in real-time.
 
-v-mix is the successor for GLMixer - https://sourceforge.net/projects/glmixer/
+Its intuitive and hands-on user interface gives direct control on image opacity and
+shape for producing live graphics during concerts and VJ-ing sessions.
 
+The output image is typically projected full-screen on an external
+monitor or a projector, and can be streamed live (SRT, Shmdata) or recorded (without audio).
+
+vimix is the successor for GLMixer - https://sourceforge.net/projects/glmixer/
+
+# License
+
+GPL-3.0-or-later
+See [LICENSE](https://github.com/brunoherbelin/vimix/blob/master/LICENSE)
+
+# Install vimix
+
+Check the [Quick Installation Guide](https://github.com/brunoherbelin/vimix/wiki/Quick-Installation-Guide)
+
+### Linux
+
+Download and install a released [flatpak package](https://flathub.org/apps/details/io.github.brunoherbelin.Vimix)
+
+    ~$ flatpak install --user vimix
+    
+NB: Building your flatpak package is an option for testing the latest beta version from git ; instructions are [here](https://github.com/brunoherbelin/vimix/tree/master/flatpak).
+    
+
+Download and install a released [snap package](https://snapcraft.io/vimix)  (slower release frequency)
+
+    ~$ snap install vimix
+    
+Install the stable debian package (slower release frequency)
+
+    ~$ sudo apt install vimix
+
+### Mac OSX
+
+Download and open a release package from https://github.com/brunoherbelin/vimix/releases
+
+NB: You'll need to accept the exception in OSX security preference.
+
+# Build vimix
 
 ## Clone
 
-    git clone --recursive https://github.com/brunoherbelin/vimix.git
+    ~$ git clone --recursive https://github.com/brunoherbelin/vimix.git
+
+This will create the directory 'vimix', download the latest version of vimix code,
+and (recursively) clone all the internal git dependencies.
+
+To only update a cloned git copy:
+
+    ~$ git pull
 
 ## Compile
 
-```
-cmake -G Ninja
-ninja
-```
+First time after git clone:
+
+    ~$ mkdir vimix-build
+    ~$ cd vimix-build
+    ~$ cmake -DCMAKE_BUILD_TYPE=Release ../vimix
+    
+Compile (or re-compile after pull):
+    
+    ~$ cmake --build .
 
 ### Dependencies
 
 **Compiling tools:**
 
 - gcc
+- make
 - cmake
-- Ninja
+- git
 
 **Libraries:**
 
 - gstreamer
-- libpng
+- gst-plugins (libav, base, good, bad & ugly)
 - libglfw3
+- libicu (icu-i18n icu-uc icu-io)
+
+Optionnal:
+
+- glm
+- stb
+- TinyXML2
+- AbletonLink
+- Shmdata
+
+#### Install Dependencies
+
+**Ubuntu**
+
+    ~$ apt-get install build-essential cmake libpng-dev libglfw3-dev libgstreamer1.0-dev libgstreamer-plugins-base1.0-dev gstreamer1.0-libav libicu-dev libgtk-3-dev 
+
+Optionnal:
+
+    ~$ apt-get install libglm-dev libstb-dev libtinyxml2-dev ableton-link-dev 
+    
+
+Follow the instructions to [install Shmdata](https://gitlab.com/sat-mtl/tools/shmdata).
+
+**OSX with Brew**
+
+    ~$ brew install cmake libpng glfw gstreamer gst-libav gst-plugins-bad gst-plugins-base gst-plugins-good gst-plugins-ugly icu4c
 
 
-#### Ubuntu
+### Memcheck
 
-**tools:**
+To generate memory usage plots in [massif format](https://valgrind.org/docs/manual/ms-manual.html):
 
-    apt-get install build-essential cmake ninja-build
-
-**libs:**
-
-    apt-get install libpng-dev libglfw3-dev libgstreamer1.0-dev libgstreamer-plugins-base1.0-dev
+    $ G_SLICE=always-malloc valgrind --tool=massif ./vimix
+    
+To check for memory leaks:
+    
+    $ G_SLICE=always-malloc valgrind --leak-check=full --log-file=vimix_mem.txt ./vimix

RenderingManager.cpp

@@ -1,823 +0,0 @@
-#include <cstring>
-#include <thread>
-#include <mutex>
-#include <chrono>
-#include <stdlib.h>
-
-// Desktop OpenGL function loader
-#include <glad/glad.h>  // Initialized with gladLoadGLLoader()
-
-// Include glfw3.h after our OpenGL definitions
-#define GLFW_INCLUDE_GLEXT
-#include <GLFW/glfw3.h>
-
-#ifdef APPLE
-#include "osx/CocoaToolkit.h"
-#define GLFW_EXPOSE_NATIVE_COCOA
-#define GLFW_EXPOSE_NATIVE_NSGL
-#else
-#define GLFW_EXPOSE_NATIVE_X11
-#define GLFW_EXPOSE_NATIVE_GLX
-#endif
-#include <GLFW/glfw3native.h>
-
-#include <glm/gtc/matrix_transform.hpp> // glm::translate, glm::rotate, glm::scale
-#include <glm/ext/matrix_clip_space.hpp> // glm::perspective
-
-// Include GStreamer
-#include <gst/gl/gl.h>
-#include <gst/gl/gstglcontext.h>
-
-#ifdef GLFW_EXPOSE_NATIVE_COCOA
-#include <gst/gl/cocoa/gstgldisplay_cocoa.h>
-#endif
-#ifdef GLFW_EXPOSE_NATIVE_GLX
-#include <gst/gl/x11/gstgldisplay_x11.h>
-#endif
-
-// standalone image loader
-#include <stb_image.h>
-
-// vmix
-#include "defines.h"
-#include "Log.h"
-#include "Resource.h"
-#include "Settings.h"
-#include "Primitives.h"
-#include "Mixer.h"
-#include "SystemToolkit.h"
-#include "UserInterfaceManager.h"
-#include "RenderingManager.h"
-
-// local statics
-static GstGLContext *global_gl_context = NULL;
-static GstGLDisplay *global_display = NULL;
-
-static std::map<GLFWwindow *, RenderingWindow*> GLFW_window_;
-
-static void glfw_error_callback(int error, const char* description)
-{
-    Log::Error("Glfw Error %d: %s",  error, description);
-}
-
-static void WindowRefreshCallback( GLFWwindow * )
-{
-    Rendering::manager().draw();
-}
-
-static void WindowResizeCallback( GLFWwindow *w, int width, int height)
-{
-    int id = GLFW_window_[w]->id();
-    if (!Settings::application.windows[id].fullscreen) {
-        Settings::application.windows[id].w = width;
-        Settings::application.windows[id].h = height;
-    }
-}
-
-static void WindowMoveCallback( GLFWwindow *w, int x, int y)
-{
-    int id = GLFW_window_[w]->id();
-    if (!Settings::application.windows[id].fullscreen) {
-        Settings::application.windows[id].x = x;
-        Settings::application.windows[id].y = y;
-    }
-}
-
-static void WindowEscapeFullscreen( GLFWwindow *w, int key, int scancode, int action, int)
-{
-    if (action == GLFW_PRESS && key == GLFW_KEY_ESCAPE)
-    {
-        // escape fullscreen
-        GLFW_window_[w]->setFullscreen(nullptr);
-    }
-}
-
-static void WindowToggleFullscreen( GLFWwindow *w, int button, int action, int)
-{
-    static double seconds = 0.f;
-
-    if (button == GLFW_MOUSE_BUTTON_LEFT && action == GLFW_PRESS)
-    {
-        // detect double clic
-        if ( glfwGetTime() - seconds < 0.2f ) {
-            // toggle fullscreen
-            GLFW_window_[w]->toggleFullscreen();
-        }
-        // for next clic detection
-        seconds = glfwGetTime();
-    }
-}
-
-Rendering::Rendering()
-{
-//    main_window_ = nullptr;
-    request_screenshot_ = false;
-}
-
-bool Rendering::init()
-{
-    // Setup window
-    glfwSetErrorCallback(glfw_error_callback);
-    if (!glfwInit()){
-        Log::Error("Failed to Initialize GLFW.");
-        return false;
-    }
-
-    // Decide GL+GLSL versions GL 3.3 + GLSL 150
-    glsl_version = "#version 150";
-    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
-    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
-    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);  // 3.2+ only
-#if __APPLE__
-    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);            // Required on Mac
-#endif
-
-    //
-    // OpenGL Multisampling main window
-    //
-    glfwWindowHint(GLFW_SAMPLES, Settings::application.render.multisampling);
-    main_.init(0);
-    // set application icon
-    main_.setIcon("images/vimix_256x256.png");
-    // additional window callbacks for main window
-    glfwSetWindowRefreshCallback( main_.window(), WindowRefreshCallback );
-    glfwSetDropCallback( main_.window(), Rendering::FileDropped);
-
-    //
-    // Gstreamer setup
-    //
-    std::string plugins_path = SystemToolkit::path_filename(Settings::application.executable);
-    plugins_path += "gstreamer-1.0";
-    if ( SystemToolkit::file_exists(plugins_path)) {
-        Log::Info("Found Gstreamer plugins in %s", plugins_path.c_str());
-        g_setenv ("GST_PLUGIN_SYSTEM_PATH", plugins_path.c_str(), TRUE);
-    }
-    g_setenv ("GST_GL_API", "opengl3", TRUE);
-    gst_init (NULL, NULL);
-#if GST_GL_HAVE_PLATFORM_WGL
-    global_gl_context = gst_gl_context_new_wrapped (display, (guintptr) wglGetCurrentContext (),
-                                                    GST_GL_PLATFORM_WGL, GST_GL_API_OPENGL);
-#elif GST_GL_HAVE_PLATFORM_CGL
-//    global_display = GST_GL_DISPLAY ( glfwGetCocoaMonitor(main_.window()) );
-    global_display = GST_GL_DISPLAY (gst_gl_display_cocoa_new ());
-
-    global_gl_context = gst_gl_context_new_wrapped (global_display,
-                                         (guintptr) 0,
-                                         GST_GL_PLATFORM_CGL, GST_GL_API_OPENGL);
-#elif GST_GL_HAVE_PLATFORM_GLX
-    global_display = (GstGLDisplay*) gst_gl_display_x11_new_with_display( glfwGetX11Display() );
-    global_gl_context = gst_gl_context_new_wrapped (global_display,
-                                        (guintptr) glfwGetGLXContext(main_.window()),
-                                        GST_GL_PLATFORM_GLX, GST_GL_API_OPENGL);
-#endif
-
-
-    //
-    // output window
-    //
-    glfwWindowHint(GLFW_SAMPLES, 0); // no need for multisampling in displaying output
-    output_.init(1, main_.window());
-    output_.setIcon("images/vimix_256x256.png");
-    // special callbacks for user input in output window
-    glfwSetKeyCallback( output_.window(), WindowEscapeFullscreen);
-    glfwSetMouseButtonCallback( output_.window(), WindowToggleFullscreen);
-
-    return true;
-}
-
-
-void Rendering::show()
-{
-    // show output window
-    output_.show();
-
-    // show main window
-    main_.show();
-
-    // show menu on first show
-    UserInterface::manager().showPannel(NAV_MENU);
-}
-
-bool Rendering::isActive()
-{
-    return !glfwWindowShouldClose(main_.window());
-}
-
-
-void Rendering::pushFrontDrawCallback(RenderingCallback function)
-{
-    draw_callbacks_.push_front(function);
-}
-
-void Rendering::pushBackDrawCallback(RenderingCallback function)
-{
-    draw_callbacks_.push_back(function);
-}
-
-void Rendering::draw()
-{
-
-    // operate on main window context
-    main_.makeCurrent();
-
-    // User Interface step 1
-    UserInterface::manager().NewFrame();
-
-    // Custom draw
-    std::list<Rendering::RenderingCallback>::iterator iter;
-    for (iter=draw_callbacks_.begin(); iter != draw_callbacks_.end(); iter++)
-    {
-        (*iter)();
-    }
-
-    // User Interface step 2
-    UserInterface::manager().Render();
-
-    // perform screenshot if requested
-    if (request_screenshot_) {
-        // glfwMakeContextCurrent(main_window_);
-        screenshot_.captureGL(0, 0, main_.width(), main_.height());
-        request_screenshot_ = false;
-    }
-
-    // draw output window (and swap buffer output)
-    output_.draw( Mixer::manager().session()->frame() );
-
-    // swap GL buffers
-    glfwSwapBuffers(main_.window());
-    glfwSwapBuffers(output_.window());
-
-    // Poll and handle events (inputs, window resize, etc.)
-    // You can read the io.WantCaptureMouse, io.WantCaptureKeyboard flags to tell if dear imgui wants to use your inputs.
-    // - When io.WantCaptureMouse is true, do not dispatch mouse input data to your main application.
-    // - When io.WantCaptureKeyboard is true, do not dispatch keyboard input data to your main application.
-    // Generally you may always pass all inputs to dear imgui, and hide them from your application based on those two flags.
-    glfwPollEvents();
-
-    // no g_main_loop_run(loop) : update global GMainContext
-    g_main_context_iteration(NULL, FALSE);
-}
-
-
-void Rendering::terminate()
-{
-    // close window
-    glfwDestroyWindow(output_.window());
-    glfwDestroyWindow(main_.window());
-    glfwTerminate();
-}
-
-
-void Rendering::close()
-{
-    glfwSetWindowShouldClose(main_.window(), true);
-}
-
-
-void Rendering::pushAttrib(RenderingAttrib ra)
-{
-    // push it to top of pile
-    draw_attributes_.push_front(ra);
-
-    // apply Changes to OpenGL
-    glViewport(0, 0, ra.viewport.x, ra.viewport.y);
-    glClearColor(ra.clear_color.r, ra.clear_color.g, ra.clear_color.b, ra.clear_color.a);
-}
-
-void Rendering::popAttrib()
-{
-    // pops the top of the pile
-    if (draw_attributes_.size() > 0)
-        draw_attributes_.pop_front();
-
-    // set attribute element to default
-    RenderingAttrib ra = currentAttrib();
-
-    // apply Changes to OpenGL
-    glViewport(0, 0, ra.viewport.x, ra.viewport.y);
-    glClearColor(ra.clear_color.r, ra.clear_color.g, ra.clear_color.b, ra.clear_color.a);
-}
-
-RenderingAttrib Rendering::currentAttrib()
-{
-    // default rendering attrib is the main window's
-    RenderingAttrib ra = main_.attribs();
-
-    // but if there is an element at top, return it
-    if (draw_attributes_.size() > 0)
-        ra = draw_attributes_.front();
-    return ra;
-}
-
-glm::mat4 Rendering::Projection()
-{
-    static glm::mat4 projection = glm::ortho(-SCENE_UNIT, SCENE_UNIT, -SCENE_UNIT, SCENE_UNIT, -SCENE_DEPTH, 1.f);
-    glm::mat4 scale = glm::scale(glm::identity<glm::mat4>(), glm::vec3(1.f, main_.aspectRatio(), 1.f));
-
-    return projection * scale;
-}
-
-
-glm::vec3 Rendering::unProject(glm::vec2 screen_coordinate, glm::mat4 modelview)
-{
-    glm::vec3 coordinates = glm::vec3( screen_coordinate.x, main_.height() - screen_coordinate.y, 0.f);
-    glm::vec4 viewport = glm::vec4( 0.f, 0.f, main_.width(), main_.height());
-
-//    Log::Info("unproject %d x %d", main_window_attributes_.viewport.x, main_window_attributes_.viewport.y);
-
-    glm::vec3 point = glm::unProject(coordinates, modelview, Projection(), viewport);
-
-    return point;
-}
-
-
-glm::vec2 Rendering::project(glm::vec3 scene_coordinate, glm::mat4 modelview, bool to_framebuffer)
-{
-    glm::vec4 viewport;
-    if (to_framebuffer)
-        viewport= glm::vec4( 0.f, 0.f, main_.width(), main_.height());
-    else
-        viewport= glm::vec4( 0.f, 0.f, main_.width() / main_.dpiScale(), main_.height() / main_.dpiScale());
-    glm::vec3 P = glm::project( scene_coordinate, modelview, Projection(), viewport );
-
-    return glm::vec2(P.x, viewport.w - P.y);
-}
-
-void Rendering::FileDropped(GLFWwindow *, int path_count, const char* paths[])
-{
-    for (int i = 0; i < path_count; ++i) {
-        std::string filename(paths[i]);
-        if (filename.empty())
-            break;
-        // try to create a source
-        Mixer::manager().addSource ( Mixer::manager().createSourceFile( filename ) );
-    }
-    if (path_count>0) {
-        UserInterface::manager().showPannel();
-        Rendering::manager().mainWindow().show();
-    }
-}
-
-
-Screenshot *Rendering::currentScreenshot()
-{
-    return &screenshot_;
-}
-
-void Rendering::requestScreenshot()
-{
-    request_screenshot_ = true;
-}
-
-
-// custom surface with a new VAO
-class WindowSurface : public Primitive {
-
-public:
-    WindowSurface(Shader *s = new ImageShader);
-};
-
-WindowSurface::WindowSurface(Shader *s) : Primitive(s)
-{
-    points_ = std::vector<glm::vec3> { glm::vec3( -1.f, -1.f, 0.f ), glm::vec3( -1.f, 1.f, 0.f ),
-            glm::vec3( 1.f, -1.f, 0.f ), glm::vec3( 1.f, 1.f, 0.f ) };
-    colors_ = std::vector<glm::vec4> { glm::vec4( 1.f, 1.f, 1.f , 1.f ), glm::vec4(  1.f, 1.f, 1.f, 1.f  ),
-            glm::vec4( 1.f, 1.f, 1.f, 1.f ), glm::vec4( 1.f, 1.f, 1.f, 1.f ) };
-    texCoords_ = std::vector<glm::vec2> { glm::vec2( 0.f, 1.f ), glm::vec2( 0.f, 0.f ),
-            glm::vec2( 1.f, 1.f ), glm::vec2( 1.f, 0.f ) };
-    indices_ = std::vector<uint> { 0, 1, 2, 3 };
-    drawMode_ = GL_TRIANGLE_STRIP;
-}
-
-
-RenderingWindow::RenderingWindow() : window_(nullptr), master_(nullptr),
-    id_(-1), dpi_scale_(1.f), textureid_(0), fbo_(0), surface_(nullptr)
-{
-}
-
-RenderingWindow::~RenderingWindow()
-{    
-    if (surface_ != nullptr)
-        delete surface_;
-    if (fbo_ != 0)
-        glDeleteFramebuffers(1, &fbo_);
-}
-
-void RenderingWindow::setTitle(const std::string &title)
-{
-    std::string fulltitle = Settings::application.windows[id_].name;
-    if ( !title.empty() )
-        fulltitle += " -- " + title;
-
-    glfwSetWindowTitle(window_, fulltitle.c_str());
-}
-
-void RenderingWindow::setIcon(const std::string &resource)
-{
-    size_t fpsize = 0;
-    const char *fp = Resource::getData(resource, &fpsize);
-    if (fp != nullptr) {
-        GLFWimage icon;
-        icon.pixels = stbi_load_from_memory( (const stbi_uc*)fp, fpsize, &icon.width, &icon.height, nullptr, 4 );
-        glfwSetWindowIcon( window_, 1, &icon );
-        free( icon.pixels );
-    }
-}
-
-bool RenderingWindow::isFullscreen ()
-{
-    return (glfwGetWindowMonitor(window_) != nullptr);
-//    return Settings::application.windows[id_].fullscreen;
-}
-
-GLFWmonitor *RenderingWindow::monitorAt(int x, int y)
-{
-    // default to primary monitor
-    GLFWmonitor *mo = glfwGetPrimaryMonitor();
-
-    // list all monitors
-    int count_monitors = 0;
-    GLFWmonitor** monitors = glfwGetMonitors(&count_monitors);
-    // if there is more than one monitor
-    if (count_monitors > 1) {
-        // pick at the coordinates given or at pos of window
-        // try every monitor
-        int i = 0;
-        for (; i < count_monitors;  i++) {
-            int workarea_x, workarea_y, workarea_width, workarea_height;
-            glfwGetMonitorWorkarea(monitors[i], &workarea_x, &workarea_y, &workarea_width, &workarea_height);
-            if ( x >= workarea_x && x <= workarea_x + workarea_width &&
-                 y >= workarea_y && y <= workarea_y + workarea_height)
-                break;
-        }
-        // found the monitor containing this point !
-        if ( i < count_monitors)
-            mo = monitors[i];
-    }
-
-    return mo;
-}
-
-GLFWmonitor *RenderingWindow::monitorNamed(const std::string &name)
-{
-    // default to primary monitor
-    GLFWmonitor *mo = glfwGetPrimaryMonitor();
-
-    // list all monitors
-    int count_monitors = 0;
-    GLFWmonitor** monitors = glfwGetMonitors(&count_monitors);
-    // if there is more than one monitor
-    if (count_monitors > 1) {
-        // pick at the coordinates given or at pos of window
-        // try every monitor
-        int i = 0;
-        for (; i < count_monitors;  i++) {
-            if ( std::string( glfwGetMonitorName(monitors[i])) == name )
-                break;
-        }
-        // found the monitor with this name
-        if ( i < count_monitors)
-            mo = monitors[i];
-    }
-
-    return mo;
-}
-
-GLFWmonitor *RenderingWindow::monitor()
-{
-    // pick at the coordinates given or at pos of window
-    int x, y;
-    glfwGetWindowPos(window_, &x, &y);
-
-    return monitorAt(x, y);
-}
-
-void RenderingWindow::setFullscreen(GLFWmonitor *mo)
-{
-    // if in fullscreen mode
-    if (mo == nullptr) {
-        // set to window mode
-        glfwSetInputMode( window_, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
-        glfwSetWindowMonitor( window_, nullptr, Settings::application.windows[id_].x,
-                                                Settings::application.windows[id_].y,
-                                                Settings::application.windows[id_].w,
-                                                Settings::application.windows[id_].h, 0 );
-        Settings::application.windows[id_].fullscreen = false;
-    }
-    // not in fullscreen mode
-    else {
-        // set to fullscreen mode
-        Settings::application.windows[id_].fullscreen = true;
-        Settings::application.windows[id_].monitor = glfwGetMonitorName(mo);
-
-        const GLFWvidmode * mode = glfwGetVideoMode(mo);
-        glfwSetWindowMonitor( window_, mo, 0, 0, mode->width, mode->height, mode->refreshRate);
-        glfwSetInputMode( window_, GLFW_CURSOR, GLFW_CURSOR_HIDDEN);
-    }
-}
-
-void RenderingWindow::toggleFullscreen()
-{
-    // if in fullscreen mode
-    if (isFullscreen()) {
-        // exit fullscreen
-        setFullscreen(nullptr);
-    }
-    // not in fullscreen mode
-    else {
-        // enter fullscreen in monitor where the window is
-        setFullscreen(monitor());
-    }
-}
-
-int RenderingWindow::width()
-{
-    return window_attributes_.viewport.x;
-}
-
-int RenderingWindow::height()
-{
-     return window_attributes_.viewport.y;
-}
-
-int RenderingWindow::maxHeight()
-{
-    int workarea_x, workarea_y, workarea_width, workarea_height;
-    glfwGetMonitorWorkarea(monitor(), &workarea_x, &workarea_y, &workarea_width, &workarea_height);
-
-    return workarea_height * dpi_scale_;
-}
-
-float RenderingWindow::aspectRatio()
-{
-    return static_cast<float>(window_attributes_.viewport.x) / static_cast<float>(window_attributes_.viewport.y);
-}
-
-bool RenderingWindow::init(int id, GLFWwindow *share)
-{
-    id_ = id;
-    master_ = share;
-
-    // access Settings
-    Settings::WindowConfig winset = Settings::application.windows[id_];
-
-    // do not show at creation
-    glfwWindowHint(GLFW_FOCUSED, GLFW_FALSE);
-    glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE);
-    glfwWindowHint(GLFW_AUTO_ICONIFY, GLFW_FALSE);
-
-    // create the window normal
-    window_ = glfwCreateWindow(winset.w, winset.h, winset.name.c_str(), NULL, master_);
-    if (window_ == NULL){
-        Log::Error("Failed to create GLFW Window %d", id_);
-        return false;
-    }
-
-    // set position
-    glfwSetWindowPos(window_, winset.x, winset.y);
-
-    /// CALLBACKS
-    // store global ref to pointers (used by callbacks)
-    GLFW_window_[window_] = this;
-    // window position and resize callbacks
-    glfwSetWindowSizeCallback( window_, WindowResizeCallback );
-//    glfwSetFramebufferSizeCallback( window_, WindowResizeCallback );
-    glfwSetWindowPosCallback( window_, WindowMoveCallback );
-
-    // take opengl context ownership
-    glfwMakeContextCurrent(window_);
-
-    //
-    // Initialize OpenGL loader on first call
-    //
-    static bool glad_initialized = false;
-    if ( !glad_initialized ) {
-        bool err = gladLoadGLLoader((GLADloadproc) glfwGetProcAddress) == 0;
-        if (err) {
-            Log::Error("Failed to initialize GLAD OpenGL loader.");
-            return false;
-        }
-        glad_initialized = true;
-    }
-
-    // get rendering area
-    glfwGetFramebufferSize(window_, &(window_attributes_.viewport.x), &(window_attributes_.viewport.y));
-    // DPI scaling (retina)
-    dpi_scale_ = float(window_attributes_.viewport.y) / float(winset.h);
-
-    // This hint can improve the speed of texturing when perspective-correct texture coordinate interpolation isn't needed
-    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
-    // This hint can improve the speed of shading when dFdx dFdy aren't needed in GLSL
-    glHint(GL_FRAGMENT_SHADER_DERIVATIVE_HINT, GL_FASTEST);
-
-    // if not main window
-    if ( master_ != NULL ) {
-        // Disable vsync
-        glfwSwapInterval(Settings::application.render.vsync);
-        // no need for multisampling
-        glDisable(GL_MULTISAMPLE);
-        // clear to black
-        window_attributes_.clear_color = glm::vec4(0.f, 0.f, 0.f, 1.f);
-        // give back context ownership
-        glfwMakeContextCurrent(master_);
-    }
-    else {
-        // Enable vsync on main window
-        glfwSwapInterval(0);
-        // enable Antialiasing multisampling
-        if (Settings::application.render.multisampling > 0) {
-            glEnable(GL_MULTISAMPLE);
-            glHint(GL_MULTISAMPLE_FILTER_HINT_NV, GL_NICEST);
-        }
-        // clear to grey
-        window_attributes_.clear_color = glm::vec4(COLOR_BGROUND, 1.f);
-    }
-
-    return true;
-}
-
-void RenderingWindow::show()
-{
-    glfwShowWindow(window_);
-
-    if ( Settings::application.windows[id_].fullscreen ) {
-        GLFWmonitor *mo = monitorNamed(Settings::application.windows[id_].monitor);
-        setFullscreen(mo);
-    }
-
-}
-
-
-void RenderingWindow::makeCurrent()
-{
-    // handle window resize
-    glfwGetFramebufferSize(window_, &(window_attributes_.viewport.x), &(window_attributes_.viewport.y));
-
-    // ensure main context is current
-    glfwMakeContextCurrent(window_);
-
-    // set and clear
-    glViewport(0, 0, window_attributes_.viewport.x, window_attributes_.viewport.y);
-    glClearColor(window_attributes_.clear_color.r, window_attributes_.clear_color.g,
-                 window_attributes_.clear_color.b, window_attributes_.clear_color.a);
-    glClear(GL_COLOR_BUFFER_BIT);
-}
-
-// TODO update parameters for draw on resize event (not every frame)
-
-void RenderingWindow::draw(FrameBuffer *fb)
-{
-    if (!window_ || !fb)
-        return;
-
-    // only draw if window is not iconified
-    if( !glfwGetWindowAttrib(window_, GLFW_ICONIFIED ) ) {
-
-        // update viewport (could be done with callback)
-        glfwGetFramebufferSize(window_, &(window_attributes_.viewport.x), &(window_attributes_.viewport.y));
-
-        // take context ownership
-        glfwMakeContextCurrent(window_);
-
-        // setup attribs
-        Rendering::manager().pushAttrib(window_attributes_);
-        glClear(GL_COLOR_BUFFER_BIT);
-
-        // blit framebuffer
-        if (Settings::application.render.blit) {
-
-            if ( textureid_ != fb->texture()) {
-
-                textureid_ = fb->texture();
-
-                // create a new fbo in this opengl context
-                if (fbo_ != 0)
-                    glDeleteFramebuffers(1, &fbo_);
-                glGenFramebuffers(1, &fbo_);
-                glBindFramebuffer(GL_FRAMEBUFFER, fbo_);
-
-                // attach the 2D texture to local FBO
-                glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, textureid_, 0);
-
-                Log::Info("Blit to output window enabled.");
-            }
-
-            // calculate scaling factor of frame buffer inside window
-            int rx, ry, rw, rh;
-            float renderingAspectRatio = fb->aspectRatio();
-            if (aspectRatio() < renderingAspectRatio) {
-                int nh = (int)( float(window_attributes_.viewport.x) / renderingAspectRatio);
-                rx = 0;
-                ry = (window_attributes_.viewport.y - nh) / 2;
-                rw = window_attributes_.viewport.x;
-                rh = (window_attributes_.viewport.y + nh) / 2;
-            } else {
-                int nw = (int)( float(window_attributes_.viewport.y) * renderingAspectRatio );
-                rx = (window_attributes_.viewport.x - nw) / 2;
-                ry = 0;
-                rw = (window_attributes_.viewport.x + nw) / 2;
-                rh = window_attributes_.viewport.y;
-            }
-
-            // select fbo texture read target
-            glBindFramebuffer(GL_READ_FRAMEBUFFER, fbo_);
-
-            // select screen target
-            glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
-
-            // blit operation from fbo (containing texture) to screen
-            glBlitFramebuffer(0, fb->height(), fb->width(), 0, rx, ry, rw, rh, GL_COLOR_BUFFER_BIT, GL_LINEAR);
-
-        }
-        // draw geometry
-        else
-        {
-            // VAO is not shared between multiple contexts of different windows
-            // so we have to create a new VAO for rendering the surface in this window
-            if (surface_ == 0)
-                surface_ = new WindowSurface;
-
-            // calculate scaling factor of frame buffer inside window
-            float windowAspectRatio = aspectRatio();
-            float renderingAspectRatio = fb->aspectRatio();
-            glm::vec3 scale;
-            if (windowAspectRatio < renderingAspectRatio)
-                scale = glm::vec3(1.f, windowAspectRatio / renderingAspectRatio, 1.f);
-            else
-                scale = glm::vec3(renderingAspectRatio / windowAspectRatio, 1.f, 1.f);
-
-            // make sure previous shader in another glcontext is disabled
-            ShadingProgram::enduse();
-
-            // draw
-            glBindTexture(GL_TEXTURE_2D, fb->texture());
-            //            surface->shader()->color.a = 0.4f; // TODO alpha blending ?
-            static glm::mat4 projection = glm::ortho(-1.f, 1.f, -1.f, 1.f, -1.f, 1.f);
-            surface_->draw(glm::scale(glm::identity<glm::mat4>(), scale), projection);
-
-            // done drawing (unload shader from this glcontext)
-            ShadingProgram::enduse();
-            glBindTexture(GL_TEXTURE_2D, 0);
-        }
-
-        // restore attribs
-        Rendering::manager().popAttrib();
-
-    }
-
-    // give back context ownership
-    glfwMakeContextCurrent(master_);
-}
-
-
-//
-// Discarded because not working under OSX - kept in case it would become useful
-//
-// Linking pipeline to the rendering instance ensures the opengl contexts
-// created by gstreamer inside plugins (e.g. glsinkbin) is the same
-//
-
-static GstBusSyncReply
-bus_sync_handler (GstBus *, GstMessage * msg, gpointer )
-{
-    if (GST_MESSAGE_TYPE(msg) == GST_MESSAGE_NEED_CONTEXT) {
-        const gchar* contextType;
-        gst_message_parse_context_type(msg, &contextType);
-
-        if (!g_strcmp0(contextType, GST_GL_DISPLAY_CONTEXT_TYPE)) {
-            GstContext *displayContext = gst_context_new(GST_GL_DISPLAY_CONTEXT_TYPE, TRUE);
-            gst_context_set_gl_display(displayContext, global_display);
-            gst_element_set_context(GST_ELEMENT(msg->src), displayContext);
-            gst_context_unref (displayContext);
-
-            g_info ("Managed %s\n", contextType);
-        }
-        if (!g_strcmp0(contextType, "gst.gl.app_context")) {
-            GstContext *appContext = gst_context_new("gst.gl.app_context", TRUE);
-            GstStructure* structure = gst_context_writable_structure(appContext);
-            gst_structure_set(structure, "context", GST_TYPE_GL_CONTEXT, global_gl_context, nullptr);
-            gst_element_set_context(GST_ELEMENT(msg->src), appContext);
-            gst_context_unref (appContext);
-
-            g_info ("Managed %s\n", contextType);
-        }
-    }
-
-    gst_message_unref (msg);
-
-    return GST_BUS_DROP;
-}
-
-void Rendering::LinkPipeline( GstPipeline *pipeline )
-{
-    // capture bus signals to force a unique opengl context for all GST elements
-    GstBus* m_bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
-    gst_bus_set_sync_handler (m_bus, (GstBusSyncHandler) bus_sync_handler, pipeline, NULL);
-    gst_object_unref (m_bus);
-
-
-    // GstBus*  m_bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
-    // gst_bus_enable_sync_message_emission (m_bus);
-    // g_signal_connect (m_bus, "sync-message", G_CALLBACK (bus_sync_handler), pipeline);
-    // gst_object_unref (m_bus);
-}

Screenshot.cpp

@@ -1,135 +0,0 @@
-#include "Screenshot.h"
-
-#include <memory.h>
-#include <assert.h>
-#include <thread>
-#include <atomic>
-
-#include <glad/glad.h>
-
-// standalone image loader
-#include <stb_image.h>
-#include <stb_image_write.h>
-
-
-
-Screenshot::Screenshot()
-{
-    Width = Height = 0;
-    Data = nullptr;
-    Pbo = 0;
-    Pbo_size = 0;
-    Pbo_full = false;
-}
-
-Screenshot::~Screenshot()
-{
-    if (Data)  free(Data);
-}
-
-bool Screenshot::isFull()
-{
-    return Pbo_full;
-}
-
-void Screenshot::captureGL(int x, int y, int w, int h)
-{
-    Width = w - x;
-    Height = h - y;
-    unsigned int size = Width * Height * 4;
-
-    // create BPO
-    if (Pbo == 0)
-        glGenBuffers(1, &Pbo);
-
-    // bind
-    glBindBuffer(GL_PIXEL_PACK_BUFFER, Pbo);
-
-    // init
-    if (Pbo_size != size) {
-        Pbo_size = size;
-        if (Data)  free(Data);
-        Data = (unsigned char*) malloc(Pbo_size);
-        glBufferData(GL_PIXEL_PACK_BUFFER, Pbo_size, NULL, GL_STREAM_READ);
-    }
-
-    // screenshot to PBO (fast)
-    glPixelStorei(GL_PACK_ALIGNMENT, 1);
-    glReadPixels(x, y, w, h, GL_RGBA, GL_UNSIGNED_BYTE, 0);
-    Pbo_full = true;
-
-    // done
-    glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
-}
-
-void Screenshot::save(std::string filename)
-{
-    // is there something to save?
-    if (Pbo && Pbo_size > 0 && Pbo_full) {
-
-        // bind buffer
-        glBindBuffer(GL_PIXEL_PACK_BUFFER, Pbo);
-
-        // get pixels (quite fast)
-        unsigned char* ptr = (unsigned char*) glMapBuffer(GL_PIXEL_PACK_BUFFER, GL_READ_ONLY);
-        if (NULL != ptr) {
-            memmove(Data, ptr, Pbo_size);
-            glUnmapBuffer(GL_PIXEL_PACK_BUFFER);
-        }
-
-        // initiate saving in thread (slow)
-        std::thread(storeToFile, this, filename).detach();
-
-        // ready for next
-        Pbo_full = false;
-    }
-
-}
-
-void Screenshot::RemoveAlpha()
-{
-    unsigned int* p = (unsigned int*)Data;
-    int n = Width * Height;
-    while (n-- > 0)
-    {
-        *p |= 0xFF000000;
-        p++;
-    }
-}
-
-void Screenshot::FlipVertical()
-{
-    int comp = 4;
-    int stride = Width * comp;
-    unsigned char* line_tmp = new unsigned char[stride];
-    unsigned char* line_a = (unsigned char*)Data;
-    unsigned char* line_b = (unsigned char*)Data + (stride * (Height - 1));
-    while (line_a < line_b)
-    {
-        memcpy(line_tmp, line_a, stride);
-        memcpy(line_a, line_b, stride);
-        memcpy(line_b, line_tmp, stride);
-        line_a += stride;
-        line_b -= stride;
-    }
-    delete[] line_tmp;
-}
-
-// Thread to perform slow operation of saving to file
-void Screenshot::storeToFile(Screenshot *s, std::string filename)
-{
-    static std::atomic<bool> ScreenshotSavePending_ = false;
-    // only one save at a time
-    if (ScreenshotSavePending_)
-        return;
-    ScreenshotSavePending_ = true;
-    // got data to save ?
-    if (s && s->Data) {
-        // make it usable
-        s->RemoveAlpha();
-        s->FlipVertical();
-        // save file
-        stbi_write_png(filename.c_str(), s->Width, s->Height, 4, s->Data, s->Width * 4);
-    }
-    ScreenshotSavePending_ = false;
-}

SearchVisitor.cpp

@@ -1,41 +0,0 @@
-#include "SearchVisitor.h"
-
-#include "Scene.h"
-
-SearchVisitor::SearchVisitor(Node *node) : Visitor(), node_(node), found_(false)
-{
-
-}
-
-
-void SearchVisitor::visit(Node &n)
-{
-    if ( !found_ && node_ == &n ){
-        found_ = true;
-    }
-}
-
-void SearchVisitor::visit(Group &n)
-{
-    if (found_)
-        return;
-
-    for (NodeSet::iterator node = n.begin(); node != n.end(); node++) {
-        (*node)->accept(*this);
-        if (found_)
-            break;
-    }
-}
-
-void SearchVisitor::visit(Switch &n)
-{
-    if (n.numChildren()>0)
-        n.activeChild()->accept(*this);
-}
-
-
-void SearchVisitor::visit(Scene &n)
-{
-    // search only in workspace
-    n.ws()->accept(*this);
-}

SearchVisitor.h

@@ -1,25 +0,0 @@
-#ifndef SEARCHVISITOR_H
-#define SEARCHVISITOR_H
-
-#include "Visitor.h"
-
-class SearchVisitor: public Visitor
-{
-    Node *node_;
-    bool found_;
-
-public:
-    SearchVisitor(Node *node);
-    inline bool found() const { return found_; }
-    inline Node *node() const { return found_ ? node_ : nullptr; }
-
-    // Elements of Scene
-    void visit(Scene& n);
-    void visit(Node& n);
-    void visit(Primitive&) {}
-    void visit(Group& n);
-    void visit(Switch& n);
-
-};
-
-#endif // SEARCHVISITOR_H

Session.cpp

@@ -1,212 +0,0 @@
-#include <algorithm>
-
-#include "defines.h"
-#include "Settings.h"
-#include "FrameBuffer.h"
-#include "Session.h"
-#include "GarbageVisitor.h"
-
-#include "Log.h"
-
-Session::Session() : filename_(""), failedSource_(nullptr), active_(true)
-{
-    config_[View::RENDERING] = new Group;
-    config_[View::RENDERING]->scale_ = render_.resolution();
-
-    config_[View::GEOMETRY] = new Group;
-    config_[View::GEOMETRY]->scale_ = Settings::application.views[View::GEOMETRY].default_scale;
-    config_[View::GEOMETRY]->translation_ = Settings::application.views[View::GEOMETRY].default_translation;
-
-    config_[View::LAYER] = new Group;
-    config_[View::LAYER]->scale_ = Settings::application.views[View::LAYER].default_scale;
-    config_[View::LAYER]->translation_ = Settings::application.views[View::LAYER].default_translation;
-
-    config_[View::MIXING] = new Group;
-    config_[View::MIXING]->scale_ = Settings::application.views[View::MIXING].default_scale;
-    config_[View::MIXING]->translation_ = Settings::application.views[View::MIXING].default_translation;
-}
-
-
-Session::~Session()
-{
-    // delete all sources
-    for(auto it = sources_.begin(); it != sources_.end(); ) {
-        // erase this source from the list
-        it = deleteSource(*it);
-    }
-
-}
-
-void Session::setActive (bool on)
-{
-    if (active_ != on) {
-        active_ = on;
-        for(auto it = sources_.begin(); it != sources_.end(); it++) {
-            (*it)->setActive(active_);
-        }
-    }
-}
-
-// update all sources
-void Session::update(float dt)
-{
-    failedSource_ = nullptr;
-
-    // pre-render of all sources
-    for( SourceList::iterator it = sources_.begin(); it != sources_.end(); it++){
-
-        if ( (*it)->failed() ) {
-            failedSource_ = (*it);
-        }
-        else {
-            // render the source
-            (*it)->render();
-            // update the source
-            (*it)->update(dt);
-        }
-    }
-
-    // update the scene tree
-    render_.update(dt);
-
-    // draw render view in Frame Buffer
-    render_.draw();
-}
-
-
-SourceList::iterator Session::addSource(Source *s)
-{
-    // insert the source in the rendering
-    render_.scene.ws()->attach(s->group(View::RENDERING));
-    // insert the source to the beginning of the list
-    sources_.push_front(s);
-    // return the iterator to the source created at the beginning
-    return sources_.begin();
-}
-
-SourceList::iterator Session::deleteSource(Source *s)
-{
-    // find the source
-    SourceList::iterator its = find(s);
-    // ok, its in the list !
-    if (its != sources_.end()) {
-
-        // remove Node from the rendering scene
-        render_.scene.ws()->detatch( s->group(View::RENDERING) );
-
-        // erase the source from the update list & get next element
-        its = sources_.erase(its);
-
-        // delete the source : safe now
-        delete s;
-    }
-
-    // return end of next element
-    return its;
-}
-
-Source *Session::popSource()
-{
-    Source *s = nullptr;
-
-    SourceList::iterator its = sources_.begin();
-    if (its != sources_.end())
-    {
-        s = *its;
-
-        // remove Node from the rendering scene
-        render_.scene.ws()->detatch( s->group(View::RENDERING) );
-
-        // erase the source from the update list & get next element
-        sources_.erase(its);
-    }
-
-    return s;
-}
-
-void Session::setResolution(glm::vec3 resolution)
-{
-    render_.setResolution(resolution);
-    config_[View::RENDERING]->scale_ = resolution;
-}
-
-void Session::setFading(float f)
-{
-    render_.setFading(f);
-}
-
-void Session::fadeIn() {
-    float f = render_.fading();
-    if ( f > EPSILON)
-        render_.setFading( f / 2.f);
-}
-
-void Session::fadeOut() {
-    float f = render_.fading();
-    if ( f < 1.f - EPSILON)
-        render_.setFading( f * 2.f);
-}
-
-SourceList::iterator Session::begin()
-{
-    return sources_.begin();
-}
-
-SourceList::iterator Session::end()
-{
-    return sources_.end();
-}
-
-SourceList::iterator Session::find(int index)
-{
-    if (index<0)
-        return sources_.end();
-
-    int i = 0;
-    SourceList::iterator it = sources_.begin();
-    while ( i < index && it != sources_.end() ){
-        i++;
-        it++;
-    }
-    return it;
-}
-
-SourceList::iterator Session::find(Source *s)
-{
-    return std::find(sources_.begin(), sources_.end(), s);
-}
-
-SourceList::iterator Session::find(std::string namesource)
-{
-    return std::find_if(sources_.begin(), sources_.end(), Source::hasName(namesource));
-}
-
-SourceList::iterator Session::find(Node *node)
-{
-    return std::find_if(sources_.begin(), sources_.end(), Source::hasNode(node));
-}
-
-uint Session::numSource() const
-{
-    return sources_.size();
-}
-
-bool Session::empty() const
-{
-    return sources_.empty();
-}
-
-int Session::index(SourceList::iterator it) const
-{
-    int index = -1;
-    int count = 0;
-    for(auto i = sources_.begin(); i != sources_.end(); i++, count++) {
-        if ( i == it ) {
-            index = count;
-            break;
-        }
-    }
-    return index;
-}
-
-

Session.h

@@ -1,72 +0,0 @@
-#ifndef SESSION_H
-#define SESSION_H
-
-
-#include "View.h"
-#include "Source.h"
-
-class Session
-{
-public:
-    Session();
-    ~Session();
-
-    // add given source into the session
-    SourceList::iterator addSource (Source *s);
-
-    // delete the source s from the session
-    SourceList::iterator deleteSource (Source *s);
-
-    // get ptr to front most source and remove it from the session
-    // Does not delete the source
-    Source *popSource();
-
-    // management of list of sources
-    bool empty() const;
-    uint numSource() const;
-    SourceList::iterator begin ();
-    SourceList::iterator end ();
-    SourceList::iterator find (int index);
-    SourceList::iterator find (Source *s);
-    SourceList::iterator find (std::string name);
-    SourceList::iterator find (Node *node);
-    int index (SourceList::iterator it) const;
-
-    // update all sources and mark sources which failed
-    void update (float dt);
-
-    // update mode (active or not)
-    void setActive (bool on);
-    inline bool active () { return active_; }
-
-    // return the last source which failed
-    Source *failedSource() { return failedSource_; }
-
-    // get frame result of render
-    inline FrameBuffer *frame () const { return render_.frame(); }
-
-    // configure rendering resolution
-    void setResolution(glm::vec3 resolution);
-
-    // manipulate fading of output
-    void setFading(float f);
-    void fadeIn();
-    void fadeOut();
-
-    // configuration for group nodes of views
-    inline Group *config (View::Mode m) const { return config_.at(m); }
-
-    // name of file containing this session (for transfer)
-    void setFilename(const std::string &filename) { filename_ = filename; }
-    std::string filename() const { return filename_; }
-
-protected:
-    RenderView render_;
-    std::string filename_;
-    Source *failedSource_;
-    SourceList sources_;
-    std::map<View::Mode, Group*> config_;
-    bool active_;
-};
-
-#endif // SESSION_H

SessionCreator.cpp

@@ -1,295 +0,0 @@
-#include "SessionCreator.h"
-
-#include "Log.h"
-#include "defines.h"
-#include "Scene.h"
-#include "Primitives.h"
-#include "Mesh.h"
-#include "Source.h"
-#include "MediaSource.h"
-#include "SessionSource.h"
-#include "Session.h"
-#include "ImageShader.h"
-#include "ImageProcessingShader.h"
-#include "MediaPlayer.h"
-
-#include <tinyxml2.h>
-using namespace tinyxml2;
-
-
-std::string SessionCreator::info(const std::string& filename)
-{
-    std::string ret = "";
-
-    XMLDocument doc;
-    XMLError eResult = doc.LoadFile(filename.c_str());
-    if ( XMLResultError(eResult))
-        return ret;
-
-    XMLElement *header = doc.FirstChildElement(APP_NAME);
-    if (header != nullptr && header->Attribute("date") != 0) {
-        int s = header->IntAttribute("size");
-        ret = std::to_string( s ) + " source" + ( s > 1 ? "s\n" : "\n");
-        std::string date( header->Attribute("date") );
-        ret += date.substr(6,2) + "/" + date.substr(4,2) + "/" + date.substr(0,4) + " ";
-        ret += date.substr(8,2) + ":" + date.substr(10,2) + "\n";
-    }
-
-    return ret;
-}
-
-SessionCreator::SessionCreator(Session *session): Visitor(), session_(session)
-{
-    xmlDoc_ = new XMLDocument;
-
-}
-
-bool SessionCreator::load(const std::string& filename)
-{
-    XMLError eResult = xmlDoc_->LoadFile(filename.c_str());
-    if ( XMLResultError(eResult))
-        return false;
-
-    XMLElement *header = xmlDoc_->FirstChildElement(APP_NAME);
-    if (header == nullptr) {
-        Log::Warning("%s is not a %s session file.", filename.c_str(), APP_NAME);
-        return false;
-    }
-
-    int version_major = -1, version_minor = -1;
-    header->QueryIntAttribute("major", &version_major); // TODO incompatible if major is different?
-    header->QueryIntAttribute("minor", &version_minor);
-    if (version_major != XML_VERSION_MAJOR || version_minor != XML_VERSION_MINOR){
-        Log::Warning("%s is in a different versions of session file. Loading might fail.", filename.c_str());
-        return false;
-    }
-
-    // ok, ready to read sources
-    loadSession( xmlDoc_->FirstChildElement("Session") );
-    // excellent, session was created: load optionnal config
-    if (session_){
-        loadConfig( xmlDoc_->FirstChildElement("Views") );
-    }
-
-    return true;
-}
-
-void SessionCreator::loadSession(XMLElement *sessionNode)
-{
-    if (sessionNode != nullptr) {
-        // create a session if not provided
-        if (!session_)
-            session_ = new Session;
-
-        int counter = 0;
-        XMLElement* sourceNode = sessionNode->FirstChildElement("Source");
-        for( ; sourceNode ; sourceNode = sourceNode->NextSiblingElement())
-        {
-            xmlCurrent_ = sourceNode;
-            counter++;
-
-            const char *pType = xmlCurrent_->Attribute("type");
-            if (!pType)
-                continue;
-            if ( std::string(pType) == "MediaSource") {
-                MediaSource *new_media_source = new MediaSource();
-                new_media_source->accept(*this);
-                session_->addSource(new_media_source);
-            }
-            else if ( std::string(pType) == "SessionSource") {
-                SessionSource *new_session_source = new SessionSource();
-                new_session_source->accept(*this);
-                session_->addSource(new_session_source);
-            }
-            else if ( std::string(pType) == "RenderSource") {
-                RenderSource *new_render_source = new RenderSource(session_);
-                new_render_source->accept(*this);
-                session_->addSource(new_render_source);
-            }
-            // TODO : create other types of source
-
-        }
-
-        // create clones after all sources to potentially clone have been created
-        sourceNode = sessionNode->FirstChildElement("Source");
-        for( ; sourceNode ; sourceNode = sourceNode->NextSiblingElement())
-        {
-            xmlCurrent_ = sourceNode;
-            counter++;
-
-            const char *pType = xmlCurrent_->Attribute("type");
-            if (!pType)
-                continue;
-
-            if ( std::string(pType) == "CloneSource") {
-                XMLElement* originNode = xmlCurrent_->FirstChildElement("origin");
-                if (originNode) {
-                    std::string sourcename = std::string ( originNode->GetText() );
-                    SourceList::iterator origin = session_->find(sourcename);
-                    if (origin != session_->end()) {
-                        CloneSource *new_clone_source = (*origin)->clone();
-                        new_clone_source->accept(*this);
-                        session_->addSource(new_clone_source);
-                    }
-                }
-            }
-        }
-
-    }
-    else
-        Log::Warning("Session seems empty.");
-}
-
-void SessionCreator::loadConfig(XMLElement *viewsNode)
-{
-    if (viewsNode != nullptr) {
-        // ok, ready to read views
-        SessionCreator::XMLToNode( viewsNode->FirstChildElement("Mixing"), *session_->config(View::MIXING));
-        SessionCreator::XMLToNode( viewsNode->FirstChildElement("Geometry"), *session_->config(View::GEOMETRY));
-        SessionCreator::XMLToNode( viewsNode->FirstChildElement("Layer"), *session_->config(View::LAYER));
-        SessionCreator::XMLToNode( viewsNode->FirstChildElement("Rendering"), *session_->config(View::RENDERING));
-    }
-}
-
-void SessionCreator::XMLToNode(tinyxml2::XMLElement *xml, Node &n)
-{
-    if (xml != nullptr){
-        XMLElement *node = xml->FirstChildElement("Node");
-        if ( !node || std::string(node->Name()).find("Node") == std::string::npos )
-            return;
-
-        XMLElement *scaleNode = node->FirstChildElement("scale");
-        tinyxml2::XMLElementToGLM( scaleNode->FirstChildElement("vec3"), n.scale_);
-        XMLElement *translationNode = node->FirstChildElement("translation");
-        tinyxml2::XMLElementToGLM( translationNode->FirstChildElement("vec3"), n.translation_);
-        XMLElement *rotationNode = node->FirstChildElement("rotation");
-        tinyxml2::XMLElementToGLM( rotationNode->FirstChildElement("vec3"), n.rotation_);
-    }
-}
-
-void SessionCreator::visit(Node &n)
-{
-    XMLToNode(xmlCurrent_, n);
-}
-
-void SessionCreator::visit(MediaPlayer &n)
-{
-    XMLElement* mediaplayerNode = xmlCurrent_->FirstChildElement("MediaPlayer");
-    if (mediaplayerNode) {
-        double speed = 1.0;
-        mediaplayerNode->QueryDoubleAttribute("speed", &speed);
-        n.setPlaySpeed(speed);
-        int loop = 1;
-        mediaplayerNode->QueryIntAttribute("loop", &loop);
-        n.setLoop( (MediaPlayer::LoopMode) loop);
-        bool play = true;
-        mediaplayerNode->QueryBoolAttribute("play", &play);
-        n.play(play);
-    }
-}
-
-void SessionCreator::visit(Shader &n)
-{
-    XMLElement* color = xmlCurrent_->FirstChildElement("color");
-    tinyxml2::XMLElementToGLM( color->FirstChildElement("vec4"), n.color);
-
-    XMLElement* blending = xmlCurrent_->FirstChildElement("blending");
-    if (blending) {
-        int blend = 0;
-        blending->QueryIntAttribute("mode", &blend);
-        n.blending = (Shader::BlendMode) blend;
-    }
-}
-
-void SessionCreator::visit(ImageShader &n)
-{
-    const char *pType = xmlCurrent_->Attribute("type");
-    if ( std::string(pType) != "ImageShader" )
-        return;
-
-    XMLElement* uniforms = xmlCurrent_->FirstChildElement("uniforms");
-    if (uniforms) {
-        uniforms->QueryFloatAttribute("stipple", &n.stipple);
-        uniforms->QueryUnsignedAttribute("mask", &n.mask);
-    }
-}
-
-void SessionCreator::visit(ImageProcessingShader &n)
-{
-    const char *pType = xmlCurrent_->Attribute("type");
-    if ( std::string(pType) != "ImageProcessingShader" )
-        return;
-
-    XMLElement* uniforms = xmlCurrent_->FirstChildElement("uniforms");
-    if (uniforms) {
-        uniforms->QueryFloatAttribute("brightness", &n.brightness);
-        uniforms->QueryFloatAttribute("contrast", &n.contrast);
-        uniforms->QueryFloatAttribute("saturation", &n.saturation);
-        uniforms->QueryFloatAttribute("hueshift", &n.hueshift);
-        uniforms->QueryFloatAttribute("threshold", &n.threshold);
-        uniforms->QueryFloatAttribute("lumakey", &n.lumakey);
-        uniforms->QueryIntAttribute("nbColors", &n.nbColors);
-        uniforms->QueryIntAttribute("invert", &n.invert);
-        uniforms->QueryFloatAttribute("chromadelta", &n.chromadelta);
-        uniforms->QueryIntAttribute("filter", &n.filterid);
-    }
-
-    XMLElement* gamma = xmlCurrent_->FirstChildElement("gamma");
-    tinyxml2::XMLElementToGLM( gamma->FirstChildElement("vec4"), n.gamma);
-    XMLElement* levels = xmlCurrent_->FirstChildElement("levels");
-    tinyxml2::XMLElementToGLM( levels->FirstChildElement("vec4"), n.levels);
-    XMLElement* chromakey = xmlCurrent_->FirstChildElement("chromakey");
-    tinyxml2::XMLElementToGLM( chromakey->FirstChildElement("vec4"), n.chromakey);
-}
-
-void SessionCreator::visit (Source& s)
-{
-    XMLElement* sourceNode = xmlCurrent_;
-    const char *pName = sourceNode->Attribute("name");
-    s.setName(pName);
-
-    xmlCurrent_ = sourceNode->FirstChildElement("Mixing");
-    s.groupNode(View::MIXING)->accept(*this);
-
-    xmlCurrent_ = sourceNode->FirstChildElement("Geometry");
-    s.groupNode(View::GEOMETRY)->accept(*this);
-
-    xmlCurrent_ = sourceNode->FirstChildElement("Layer");
-    s.groupNode(View::LAYER)->accept(*this);
-
-    xmlCurrent_ = sourceNode->FirstChildElement("Blending");
-    s.blendingShader()->accept(*this);
-
-    xmlCurrent_ = sourceNode->FirstChildElement("ImageProcessing");
-    s.processingShader()->accept(*this);
-
-    // restore current
-    xmlCurrent_ = sourceNode;
-}
-
-void SessionCreator::visit (MediaSource& s)
-{
-    // set uri
-    XMLElement* uriNode = xmlCurrent_->FirstChildElement("uri");
-    if (uriNode) {
-        std::string uri = std::string ( uriNode->GetText() );
-        s.setPath(uri);
-    }
-
-    // set config media player
-    s.mediaplayer()->accept(*this);
-}
-
-void SessionCreator::visit (SessionSource& s)
-{
-    // set uri
-    XMLElement* pathNode = xmlCurrent_->FirstChildElement("path");
-    if (pathNode) {
-        std::string path = std::string ( pathNode->GetText() );
-        s.load(path);
-    }
-
-}
-
-
-

SessionCreator.h

@@ -1,56 +0,0 @@
-#ifndef SESSIONCREATOR_H
-#define SESSIONCREATOR_H
-
-#include "Visitor.h"
-#include "tinyxml2Toolkit.h"
-
-class Session;
-
-class SessionCreator : public Visitor {
-
-    tinyxml2::XMLDocument *xmlDoc_;
-    tinyxml2::XMLElement *xmlCurrent_;
-    Session *session_;
-
-    void loadSession(tinyxml2::XMLElement *sessionNode);
-    void loadConfig(tinyxml2::XMLElement *viewsNode);
-
-
-public:
-    SessionCreator(Session *session = nullptr);
-
-    bool load(const std::string& filename);
-    inline Session *session() const { return session_; }
-
-    // Elements of Scene
-    void visit(Node& n) override;
-
-    void visit(Scene& n) override {}
-    void visit(Group& n) override {}
-    void visit(Switch& n) override {}
-    void visit(Primitive& n) override {}
-    void visit(Surface& n) override {}
-    void visit(ImageSurface& n) override {}
-    void visit(MediaSurface& n) override {}
-    void visit(FrameBufferSurface& n) override {}
-    void visit(LineStrip& n) override {}
-    void visit(LineSquare&) override {}
-    void visit(LineCircle& n) override {}
-    void visit(Mesh& n) override {}
-
-    // Elements with attributes
-    void visit(MediaPlayer& n) override;
-    void visit(Shader& n) override;
-    void visit(ImageShader& n) override;
-    void visit(ImageProcessingShader& n) override;
-
-    void visit (Source& s) override;
-    void visit (MediaSource& s) override;
-    void visit (SessionSource& s) override;
-
-    static std::string info(const std::string& filename);
-    static void XMLToNode(tinyxml2::XMLElement *xml, Node &n);
-};
-
-
-#endif // SESSIONCREATOR_H

SessionSource.cpp

@@ -1,320 +0,0 @@
-#include <glm/gtc/matrix_transform.hpp>
-#include <thread>
-#include <chrono>
-
-#include "SessionSource.h"
-
-#include "defines.h"
-#include "Log.h"
-#include "FrameBuffer.h"
-#include "ImageShader.h"
-#include "ImageProcessingShader.h"
-#include "Resource.h"
-#include "Primitives.h"
-#include "Mesh.h"
-#include "SearchVisitor.h"
-#include "Session.h"
-#include "SessionCreator.h"
-#include "Mixer.h"
-
-
-void SessionSource::loadSession(const std::string& filename, SessionSource *source)
-{
-    source->loadFinished_ = false;
-
-    // actual loading of xml file
-    SessionCreator creator( source->session_ );
-
-    if (creator.load(filename)) {
-        // all ok, validate session filename
-        source->session_->setFilename(filename);
-    }
-    else {
-        // error loading
-        Log::Notify("Failed to load Session file %s.", filename.c_str());
-        source->loadFailed_ = true;
-    }
-
-    // end thread
-    source->loadFinished_ = true;
-}
-
-SessionSource::SessionSource() : Source(), path_("")
-{
-    // specific node for transition view
-    groups_[View::TRANSITION]->visible_ = false;
-    groups_[View::TRANSITION]->scale_ = glm::vec3(0.1f, 0.1f, 1.f);
-    groups_[View::TRANSITION]->translation_ = glm::vec3(-1.f, 0.f, 0.f);
-
-    frames_[View::TRANSITION] = new Switch;
-    Frame *frame = new Frame(Frame::ROUND, Frame::THIN, Frame::DROP);
-    frame->translation_.z = 0.1;
-    frame->color = glm::vec4( COLOR_DEFAULT_SOURCE, 0.9f);
-    frames_[View::TRANSITION]->attach(frame);
-    frame = new Frame(Frame::ROUND, Frame::LARGE, Frame::DROP);
-    frame->translation_.z = 0.01;
-    frame->color = glm::vec4( COLOR_TRANSITION_SOURCE, 1.f);
-    frames_[View::TRANSITION]->attach(frame);
-    groups_[View::TRANSITION]->attach(frames_[View::TRANSITION]);
-
-    overlays_[View::TRANSITION] = new Group;
-    overlays_[View::TRANSITION]->translation_.z = 0.1;
-    overlays_[View::TRANSITION]->visible_ = false;
-
-    Symbol *loader = new Symbol(Symbol::DOTS);
-    loader->scale_ = glm::vec3(2.f, 2.f, 1.f);
-    loader->update_callbacks_.push_back(new InfiniteGlowCallback);
-    overlays_[View::TRANSITION]->attach(loader);
-    Symbol *center = new Symbol(Symbol::POINT, glm::vec3(0.f, -1.05f, 0.1f));
-    overlays_[View::TRANSITION]->attach(center);
-    groups_[View::TRANSITION]->attach(overlays_[View::TRANSITION]);
-
-    loadFailed_ = false;
-    loadFinished_ = false;
-    wait_for_sources_ = false;
-
-    session_ = new Session;
-
-    // create surface:
-    // - textured with original texture from session
-    // - crop & repeat UV can be managed here
-    // - additional custom shader can be associated
-    sessionsurface_ = new Surface(rendershader_);
-}
-
-SessionSource::~SessionSource()
-{
-    // delete surface
-    delete sessionsurface_;
-
-    // delete session
-    if (session_)
-        delete session_;
-}
-
-
-
-void SessionSource::load(const std::string &p)
-{
-    path_ = p;
-
-    // launch a thread to load the session
-    std::thread ( SessionSource::loadSession, path_, this).detach();
-
-    Log::Notify("Opening %s", p.c_str());
-}
-
-Session *SessionSource::detach()
-{
-    // remember pointer to give away
-    Session *giveaway = session_;
-
-    // work on a new session
-    session_ = new Session;
-
-    // make disabled
-    initialized_ = false;
-    loadFailed_ = true;
-
-    return giveaway;
-}
-
-bool SessionSource::failed() const
-{
-    return loadFailed_;
-}
-
-uint SessionSource::texture() const
-{
-    if (session_ == nullptr)
-        return Resource::getTextureBlack();
-    return session_->frame()->texture();
-}
-
-void SessionSource::init()
-{
-    if (session_ == nullptr)
-        return;
-
-    if (wait_for_sources_) {
-
-        // force update of of all sources
-        active_ = true;
-        touch();
-
-        // check that every source is ready..
-        bool ready = true;
-        for (SourceList::iterator iter = session_->begin(); iter != session_->end(); iter++)
-        {
-            // interrupt if any source is NOT ready
-            if ( !(*iter)->ready() ){
-                ready = false;
-                break;
-            }
-        }
-        // if all sources are ready, done with initialization!
-        if (ready) {
-            // remove the loading icon
-            Node *loader = overlays_[View::TRANSITION]->back();
-            overlays_[View::TRANSITION]->detatch(loader);
-            delete loader;
-            // done init
-            wait_for_sources_ = false;
-            initialized_ = true;
-            Log::Info("Source Session %s loaded %d sources.", path_.c_str(), session_->numSource());
-        }
-    }
-
-    if ( loadFinished_ && !loadFailed_ && session_ != nullptr) {
-        loadFinished_ = false;
-
-        // set resolution
-        session_->setResolution( session_->config(View::RENDERING)->scale_ );
-
-        // deep update once to draw framebuffer
-        View::need_deep_update_ = true;
-        session_->update(dt_);
-
-        // get the texture index from framebuffer of session, apply it to the surface
-        sessionsurface_->setTextureIndex( session_->frame()->texture() );
-
-        // create Frame buffer matching size of session
-        FrameBuffer *renderbuffer = new FrameBuffer( session_->frame()->resolution());
-
-        // set the renderbuffer of the source and attach rendering nodes
-        attach(renderbuffer);
-
-        // icon in mixing view
-        overlays_[View::MIXING]->attach( new Symbol(Symbol::SESSION, glm::vec3(0.8f, 0.8f, 0.01f)) );
-        overlays_[View::LAYER]->attach( new Symbol(Symbol::SESSION, glm::vec3(0.8f, 0.8f, 0.01f)) );
-
-        // wait for all sources to init
-        wait_for_sources_ = true;
-
-    }
-
-}
-
-void SessionSource::setActive (bool on)
-{
-    Source::setActive(on);
-
-    // change status of session (recursive change of internal sources)
-    if (session_ != nullptr)
-        session_->setActive(active_);
-}
-
-
-void SessionSource::update(float dt)
-{
-    if (session_ == nullptr)
-        loadFailed_ = true;
-
-    // update content
-    if (active_)
-        session_->update(dt);
-
-    // delete a source which failed
-    if (session_->failedSource() != nullptr) {
-        session_->deleteSource(session_->failedSource());
-        // fail session if all sources failed
-        if ( session_->numSource() < 1)
-            loadFailed_ = true;
-    }
-
-    Source::update(dt);
-}
-
-void SessionSource::render()
-{
-    if (!initialized_)
-        init();
-    else {
-        // render the sesion into frame buffer
-        static glm::mat4 projection = glm::ortho(-1.f, 1.f, 1.f, -1.f, -1.f, 1.f);
-        renderbuffer_->begin();
-        sessionsurface_->draw(glm::identity<glm::mat4>(), projection);
-        renderbuffer_->end();
-    }
-}
-
-void SessionSource::accept(Visitor& v)
-{
-    Source::accept(v);
-    v.visit(*this);
-}
-
-
-RenderSource::RenderSource(Session *session) : Source(), session_(session)
-{
-    // create  surface:
-    sessionsurface_ = new Surface(rendershader_);
-}
-
-RenderSource::~RenderSource()
-{
-    // delete surface
-    delete sessionsurface_;
-}
-
-bool RenderSource::failed() const
-{
-    return session_ == nullptr;
-}
-
-uint RenderSource::texture() const
-{
-    if (session_ == nullptr)
-        return Resource::getTextureBlack();
-    else
-        return session_->frame()->texture();
-}
-
-void RenderSource::init()
-{
-    if (session_ == nullptr)
-        return;
-
-    if (session_ && session_->frame()->texture() != Resource::getTextureBlack()) {
-
-        FrameBuffer *fb = session_->frame();
-
-        // get the texture index from framebuffer of view, apply it to the surface
-        sessionsurface_->setTextureIndex( fb->texture() );
-
-        // create Frame buffer matching size of output session
-        FrameBuffer *renderbuffer = new FrameBuffer( fb->resolution());
-
-        // set the renderbuffer of the source and attach rendering nodes
-        attach(renderbuffer);
-
-        // icon in mixing view
-        overlays_[View::MIXING]->attach( new Symbol(Symbol::RENDER, glm::vec3(0.8f, 0.8f, 0.01f)) );
-        overlays_[View::LAYER]->attach( new Symbol(Symbol::RENDER, glm::vec3(0.8f, 0.8f, 0.01f)) );
-
-        // done init
-        initialized_ = true;
-
-        Log::Info("Source Render linked to session (%d x %d).", int(fb->resolution().x), int(fb->resolution().y) );
-    }
-}
-
-void RenderSource::render()
-{
-    if (!initialized_)
-        init();
-    else {
-        // render the view into frame buffer
-        static glm::mat4 projection = glm::ortho(-1.f, 1.f, 1.f, -1.f, -1.f, 1.f);
-        renderbuffer_->begin();
-        sessionsurface_->draw(glm::identity<glm::mat4>(), projection);
-        renderbuffer_->end();
-    }
-}
-
-
-void RenderSource::accept(Visitor& v)
-{
-    Source::accept(v);
-    v.visit(*this);
-}

SessionSource.h

@@ -1,63 +0,0 @@
-#ifndef SESSIONSOURCE_H
-#define SESSIONSOURCE_H
-
-#include <atomic>
-#include "Source.h"
-
-class SessionSource : public Source
-{
-public:
-    SessionSource();
-    ~SessionSource();
-
-    // implementation of source API
-    void update (float dt) override;
-    void setActive (bool on) override;
-    void render() override;
-    bool failed() const override;
-    uint texture() const override;
-    void accept (Visitor& v) override;
-
-    // Session Source specific interface
-    void load(const std::string &p);
-    Session *detach();
-
-    inline std::string path() const { return path_; }
-    inline Session *session() const { return session_; }
-
-protected:
-
-    void init() override;
-    static void loadSession(const std::string& filename, SessionSource *source);
-
-    Surface *sessionsurface_;
-    std::string path_;
-    Session *session_;
-
-    std::atomic<bool> loadFailed_;
-    std::atomic<bool> loadFinished_;
-    std::atomic<bool> wait_for_sources_;
-};
-
-
-class RenderSource : public Source
-{
-public:
-    RenderSource(Session *session);
-    ~RenderSource();
-
-    // implementation of source API
-    void render() override;
-    bool failed() const override;
-    uint texture() const override;
-    void accept (Visitor& v) override;
-
-protected:
-
-    void init() override;
-    Surface *sessionsurface_;
-    Session *session_;
-};
-
-
-#endif // SESSIONSOURCE_H

SessionVisitor.cpp

@@ -1,361 +0,0 @@
-#include "SessionVisitor.h"
-
-#include "Log.h"
-#include "Scene.h"
-#include "Primitives.h"
-#include "Mesh.h"
-#include "Source.h"
-#include "MediaSource.h"
-#include "SessionSource.h"
-#include "ImageShader.h"
-#include "ImageProcessingShader.h"
-#include "MediaPlayer.h"
-
-#include <iostream>
-
-#include <tinyxml2.h>
-using namespace tinyxml2;
-
-
-SessionVisitor::SessionVisitor(tinyxml2::XMLDocument *doc,
-                               tinyxml2::XMLElement *root,
-                               bool recursive) : Visitor(), xmlCurrent_(root), recursive_(recursive)
-{    
-    if (doc == nullptr)
-        xmlDoc_ = new XMLDocument;
-    else
-        xmlDoc_ = doc;
-}
-
-tinyxml2::XMLElement *SessionVisitor::NodeToXML(Node &n, tinyxml2::XMLDocument *doc)
-{
-    XMLElement *newelement = doc->NewElement("Node");
-    newelement->SetAttribute("visible", n.visible_);
-
-    XMLElement *scale = doc->NewElement("scale");
-    scale->InsertEndChild( XMLElementFromGLM(doc, n.scale_) );
-    newelement->InsertEndChild(scale);
-
-    XMLElement *translation = doc->NewElement("translation");
-    translation->InsertEndChild( XMLElementFromGLM(doc, n.translation_) );
-    newelement->InsertEndChild(translation);
-
-    XMLElement *rotation = doc->NewElement("rotation");
-    rotation->InsertEndChild( XMLElementFromGLM(doc, n.rotation_) );
-    newelement->InsertEndChild(rotation);
-
-    return newelement;
-}
-
-void SessionVisitor::visit(Node &n)
-{
-    XMLElement *newelement = NodeToXML(n, xmlDoc_);
-
-    // insert into hierarchy
-    xmlCurrent_->InsertEndChild(newelement);
-
-    // parent for next visits
-    xmlCurrent_ = newelement;
-}
-
-void SessionVisitor::visit(Group &n)
-{
-    // Node of a different type
-    xmlCurrent_->SetAttribute("type", "Group");
-
-    if (recursive_) {
-        // loop over members of a group
-        XMLElement *group = xmlCurrent_;
-        for (NodeSet::iterator node = n.begin(); node != n.end(); node++) {
-            (*node)->accept(*this);
-            // revert to group as current
-            xmlCurrent_ = group;
-        }
-    }
-}
-
-void SessionVisitor::visit(Switch &n)
-{
-    // Node of a different type
-    xmlCurrent_->SetAttribute("type", "Switch");
-    xmlCurrent_->SetAttribute("active", n.active());
-
-    if (recursive_) {
-        // loop over members of the group
-        XMLElement *group = xmlCurrent_;
-        for(uint i = 0; i < n.numChildren(); i++) {
-            n.child(i)->accept(*this);
-            // revert to group as current
-            xmlCurrent_ = group;
-        }
-    }
-}
-
-void SessionVisitor::visit(Primitive &n)
-{
-    // Node of a different type
-    xmlCurrent_->SetAttribute("type", "Primitive");
-
-    if (recursive_) {
-        // go over members of a primitive
-        XMLElement *Primitive = xmlCurrent_;
-
-        xmlCurrent_ = xmlDoc_->NewElement("Shader");
-        n.shader()->accept(*this);
-        Primitive->InsertEndChild(xmlCurrent_);
-
-        // revert to primitive as current
-        xmlCurrent_ = Primitive;
-    }
-}
-
-
-void SessionVisitor::visit(Surface &n)
-{
-
-}
-
-void SessionVisitor::visit(ImageSurface &n)
-{
-    // Node of a different type
-    xmlCurrent_->SetAttribute("type", "ImageSurface");
-
-    XMLText *filename = xmlDoc_->NewText( n.resource().c_str() );
-    XMLElement *image = xmlDoc_->NewElement("resource");
-    image->InsertEndChild(filename);
-    xmlCurrent_->InsertEndChild(image);
-}
-
-void SessionVisitor::visit(FrameBufferSurface &n)
-{
-    // Node of a different type
-    xmlCurrent_->SetAttribute("type", "FrameBufferSurface");
-}
-
-void SessionVisitor::visit(MediaSurface &n)
-{
-    // Node of a different type
-    xmlCurrent_->SetAttribute("type", "MediaSurface");
-
-    n.mediaPlayer()->accept(*this);
-}
-
-void SessionVisitor::visit(MediaPlayer &n)
-{
-    XMLElement *newelement = xmlDoc_->NewElement("MediaPlayer");
-    newelement->SetAttribute("play", n.isPlaying());
-    newelement->SetAttribute("loop", (int) n.loop());
-    newelement->SetAttribute("speed", n.playSpeed());
-
- // TODO Segments
-
-    xmlCurrent_->InsertEndChild(newelement);
-}
-
-void SessionVisitor::visit(Shader &n)
-{
-    // Shader of a simple type
-    xmlCurrent_->SetAttribute("type", "Shader");
-
-    XMLElement *color = xmlDoc_->NewElement("color");
-    color->InsertEndChild( XMLElementFromGLM(xmlDoc_, n.color) );
-    xmlCurrent_->InsertEndChild(color);
-
-    XMLElement *blend = xmlDoc_->NewElement("blending");
-    blend->SetAttribute("mode", int(n.blending) );
-    xmlCurrent_->InsertEndChild(blend);
-
-}
-
-void SessionVisitor::visit(ImageShader &n)
-{
-    // Shader of a textured type
-    xmlCurrent_->SetAttribute("type", "ImageShader");
-
-    XMLElement *uniforms = xmlDoc_->NewElement("uniforms");
-    uniforms->SetAttribute("stipple", n.stipple);
-    uniforms->SetAttribute("mask", n.mask);
-    xmlCurrent_->InsertEndChild(uniforms);
-
-}
-
-void SessionVisitor::visit(ImageProcessingShader &n)
-{
-    // Shader of a textured type
-    xmlCurrent_->SetAttribute("type", "ImageProcessingShader");
-
-    XMLElement *filter = xmlDoc_->NewElement("uniforms");
-    filter->SetAttribute("brightness", n.brightness);
-    filter->SetAttribute("contrast", n.contrast);
-    filter->SetAttribute("saturation", n.saturation);
-    filter->SetAttribute("hueshift", n.hueshift);
-    filter->SetAttribute("threshold", n.threshold);
-    filter->SetAttribute("lumakey", n.lumakey);
-    filter->SetAttribute("nbColors", n.nbColors);
-    filter->SetAttribute("invert", n.invert);
-    filter->SetAttribute("chromadelta", n.chromadelta);
-    filter->SetAttribute("filterid", n.filterid);
-    xmlCurrent_->InsertEndChild(filter);
-
-    XMLElement *gamma = xmlDoc_->NewElement("gamma");
-    gamma->InsertEndChild( XMLElementFromGLM(xmlDoc_, n.gamma) );
-    xmlCurrent_->InsertEndChild(gamma);
-
-    XMLElement *levels = xmlDoc_->NewElement("levels");
-    levels->InsertEndChild( XMLElementFromGLM(xmlDoc_, n.levels) );
-    xmlCurrent_->InsertEndChild(levels);
-
-    XMLElement *chromakey = xmlDoc_->NewElement("chromakey");
-    chromakey->InsertEndChild( XMLElementFromGLM(xmlDoc_, n.chromakey) );
-    xmlCurrent_->InsertEndChild(chromakey);
-
-}
-
-void SessionVisitor::visit(LineStrip &n)
-{
-    // Node of a different type
-    xmlCurrent_->SetAttribute("type", "LineStrip");
-
-    XMLElement *points_node = xmlDoc_->NewElement("points");
-    std::vector<glm::vec3> points = n.getPoints();
-    for(size_t i = 0; i < points.size(); ++i)
-    {
-        XMLElement *p = XMLElementFromGLM(xmlDoc_, points[i]);
-        p->SetAttribute("index", (int) i);
-        points_node->InsertEndChild(p);
-    }
-    xmlCurrent_->InsertEndChild(points_node);
-
-    XMLElement *colors_node = xmlDoc_->NewElement("colors");
-    std::vector<glm::vec4> colors = n.getColors();
-    for(size_t i = 0; i < colors.size(); ++i)
-    {
-        XMLElement *p = XMLElementFromGLM(xmlDoc_, colors[i]);
-        p->SetAttribute("index", (int) i);
-        colors_node->InsertEndChild(p);
-    }
-    xmlCurrent_->InsertEndChild(colors_node);
-}
-
-void SessionVisitor::visit(LineSquare &)
-{
-    // Node of a different type
-    xmlCurrent_->SetAttribute("type", "LineSquare");
-
-}
-
-void SessionVisitor::visit(LineCircle &n)
-{
-    // Node of a different type
-    xmlCurrent_->SetAttribute("type", "LineCircle");
-
-//    XMLElement *color = xmlDoc_->NewElement("color");
-//    color->InsertEndChild( XMLElementFromGLM(xmlDoc_, n.getColor()) );
-//    xmlCurrent_->InsertEndChild(color);
-}
-
-void SessionVisitor::visit(Mesh &n)
-{
-    // Node of a different type
-    xmlCurrent_->SetAttribute("type", "Mesh");
-
-    XMLText *filename = xmlDoc_->NewText( n.meshPath().c_str() );
-    XMLElement *obj = xmlDoc_->NewElement("resource");
-    obj->InsertEndChild(filename);
-    xmlCurrent_->InsertEndChild(obj);
-
-    filename = xmlDoc_->NewText( n.texturePath().c_str() );
-    XMLElement *tex = xmlDoc_->NewElement("texture");
-    tex->InsertEndChild(filename);
-    xmlCurrent_->InsertEndChild(tex);
-}
-
-void SessionVisitor::visit(Frame &n)
-{
-    // Node of a different type
-    xmlCurrent_->SetAttribute("type", "Frame");
-
-    XMLElement *color = xmlDoc_->NewElement("color");
-    color->InsertEndChild( XMLElementFromGLM(xmlDoc_, n.color) );
-    xmlCurrent_->InsertEndChild(color);
-
-}
-
-void SessionVisitor::visit(Scene &n)
-{
-    XMLElement *xmlRoot = xmlDoc_->NewElement("Scene");
-    xmlDoc_->InsertEndChild(xmlRoot);
-
-    // start recursive traverse from root node
-    recursive_ = true;
-    xmlCurrent_ = xmlRoot;
-    n.root()->accept(*this);
-}
-
-void SessionVisitor::visit (Source& s)
-{
-    XMLElement *sourceNode = xmlDoc_->NewElement( "Source" );
-    sourceNode->SetAttribute("name", s.name().c_str() );
-
-    // insert into hierarchy
-    xmlCurrent_->InsertFirstChild(sourceNode);
-
-    xmlCurrent_ = xmlDoc_->NewElement( "Mixing" );
-    sourceNode->InsertEndChild(xmlCurrent_);
-    s.groupNode(View::MIXING)->accept(*this);
-
-    xmlCurrent_ = xmlDoc_->NewElement( "Geometry" );
-    sourceNode->InsertEndChild(xmlCurrent_);
-    s.groupNode(View::GEOMETRY)->accept(*this);
-
-    xmlCurrent_ = xmlDoc_->NewElement( "Layer" );
-    sourceNode->InsertEndChild(xmlCurrent_);
-    s.groupNode(View::LAYER)->accept(*this);
-
-    xmlCurrent_ = xmlDoc_->NewElement( "Blending" );
-    sourceNode->InsertEndChild(xmlCurrent_);
-    s.blendingShader()->accept(*this);
-
-    xmlCurrent_ = xmlDoc_->NewElement( "ImageProcessing" );
-    sourceNode->InsertEndChild(xmlCurrent_);
-    s.processingShader()->accept(*this);
-
-    xmlCurrent_ = sourceNode;  // parent for next visits (other subtypes of Source)
-}
-
-void SessionVisitor::visit (MediaSource& s)
-{
-    xmlCurrent_->SetAttribute("type", "MediaSource");
-
-    XMLElement *uri = xmlDoc_->NewElement("uri");
-    xmlCurrent_->InsertEndChild(uri);
-    XMLText *text = xmlDoc_->NewText( s.path().c_str() );
-    uri->InsertEndChild( text );
-
-    s.mediaplayer()->accept(*this);
-}
-
-void SessionVisitor::visit (SessionSource& s)
-{
-    xmlCurrent_->SetAttribute("type", "SessionSource");
-
-    XMLElement *path = xmlDoc_->NewElement("path");
-    xmlCurrent_->InsertEndChild(path);
-    XMLText *text = xmlDoc_->NewText( s.path().c_str() );
-    path->InsertEndChild( text );
-}
-
-void SessionVisitor::visit (RenderSource& s)
-{
-    xmlCurrent_->SetAttribute("type", "RenderSource");
-}
-
-void SessionVisitor::visit (CloneSource& s)
-{
-    xmlCurrent_->SetAttribute("type", "CloneSource");
-
-    XMLElement *origin = xmlDoc_->NewElement("origin");
-    xmlCurrent_->InsertEndChild(origin);
-    XMLText *text = xmlDoc_->NewText( s.origin()->name().c_str() );
-    origin->InsertEndChild( text );
-}

SessionVisitor.h

@@ -1,51 +0,0 @@
-#ifndef XMLVISITOR_H
-#define XMLVISITOR_H
-
-#include "Visitor.h"
-#include "tinyxml2Toolkit.h"
-
-class SessionVisitor : public Visitor {
-
-    bool recursive_;
-    tinyxml2::XMLDocument *xmlDoc_;
-    tinyxml2::XMLElement *xmlCurrent_;
-
-public:
-    SessionVisitor(tinyxml2::XMLDocument *doc = nullptr,
-                   tinyxml2::XMLElement *root = nullptr,
-                   bool recursive = false);
-
-    inline tinyxml2::XMLDocument *doc() const { return xmlDoc_; }
-
-    // Elements of Scene
-    void visit(Scene& n) override;
-    void visit(Node& n) override;
-    void visit(Group& n) override;
-    void visit(Switch& n) override;
-    void visit(Primitive& n) override;
-    void visit(Surface& n) override;
-    void visit(ImageSurface& n) override;
-    void visit(MediaSurface& n) override;
-    void visit(FrameBufferSurface& n) override;
-    void visit(LineStrip& n) override;
-    void visit(LineSquare&) override;
-    void visit(LineCircle& n) override;
-    void visit(Mesh& n) override;
-    void visit(Frame& n) override;
-
-    // Elements with attributes
-    void visit(MediaPlayer& n) override;
-    void visit(Shader& n) override;
-    void visit(ImageShader& n) override;
-    void visit(ImageProcessingShader& n) override;
-
-    void visit (Source& s) override;
-    void visit (MediaSource& s) override;
-    void visit (SessionSource& s) override;
-    void visit (RenderSource& s) override;
-    void visit (CloneSource& s) override;
-
-    static tinyxml2::XMLElement *NodeToXML(Node &n, tinyxml2::XMLDocument *doc);
-};
-
-#endif // XMLVISITOR_H

Settings.cpp

@@ -1,358 +0,0 @@
-#include <algorithm>
-#include <iostream>
-using namespace std;
-
-#include <tinyxml2.h>
-#include "tinyxml2Toolkit.h"
-using namespace tinyxml2;
-
-#include "defines.h"
-#include "Settings.h"
-#include "SystemToolkit.h"
-
-
-Settings::Application Settings::application;
-static string settingsFilename = "";
-
-void Settings::Save()
-{
-    XMLDocument xmlDoc;
-    XMLDeclaration *pDec = xmlDoc.NewDeclaration();
-    xmlDoc.InsertFirstChild(pDec);
-
-    XMLElement *pRoot = xmlDoc.NewElement(application.name.c_str());
-    xmlDoc.InsertEndChild(pRoot);
-
-    string comment = "Settings for " + application.name;
-    comment += "Version " + std::to_string(APP_VERSION_MAJOR) + "." + std::to_string(APP_VERSION_MINOR);
-    XMLComment *pComment = xmlDoc.NewComment(comment.c_str());
-    pRoot->InsertEndChild(pComment);
-
-	// block: windows
-	{
-		XMLElement *windowsNode = xmlDoc.NewElement( "Windows" );  
-
-        for (int i = 0; i < application.windows.size(); i++)
-        {
-            const Settings::WindowConfig& w = application.windows[i];
-
-            XMLElement *window = xmlDoc.NewElement( "Window" );
-            window->SetAttribute("id", i);
-            window->SetAttribute("name", w.name.c_str());
-			window->SetAttribute("x", w.x);
-			window->SetAttribute("y", w.y);
-			window->SetAttribute("w", w.w);
-			window->SetAttribute("h", w.h);
-            window->SetAttribute("f", w.fullscreen);
-            window->SetAttribute("m", w.monitor.c_str());
-            windowsNode->InsertEndChild(window);
-		}
-
-        pRoot->InsertEndChild(windowsNode);
-	}
-
-    // General application preferences
-    XMLElement *applicationNode = xmlDoc.NewElement( "Application" );
-    applicationNode->SetAttribute("scale", application.scale);
-    applicationNode->SetAttribute("accent_color", application.accent_color);
-    applicationNode->SetAttribute("pannel_stick", application.pannel_stick);
-    applicationNode->SetAttribute("smooth_transition", application.smooth_transition);
-    pRoot->InsertEndChild(applicationNode);
-
-    // Widgets
-    XMLElement *widgetsNode = xmlDoc.NewElement( "Widgets" );
-    widgetsNode->SetAttribute("preview", application.widget.preview);
-    widgetsNode->SetAttribute("media_player", application.widget.media_player);
-    widgetsNode->SetAttribute("shader_editor", application.widget.shader_editor);
-    widgetsNode->SetAttribute("stats", application.widget.stats);
-    widgetsNode->SetAttribute("stats_corner", application.widget.stats_corner);
-    widgetsNode->SetAttribute("logs", application.widget.logs);
-    widgetsNode->SetAttribute("toolbox", application.widget.toolbox);
-    pRoot->InsertEndChild(widgetsNode);
-
-    // Render
-    XMLElement *RenderNode = xmlDoc.NewElement( "Render" );
-    RenderNode->SetAttribute("vsync", application.render.vsync);
-    RenderNode->SetAttribute("multisampling", application.render.multisampling);
-    RenderNode->SetAttribute("blit", application.render.blit);
-    RenderNode->SetAttribute("ratio", application.render.ratio);
-    RenderNode->SetAttribute("res", application.render.res);
-    pRoot->InsertEndChild(RenderNode);
-
-    // Transition
-    XMLElement *TransitionNode = xmlDoc.NewElement( "Transition" );
-    TransitionNode->SetAttribute("auto_open", application.transition.auto_open);
-    TransitionNode->SetAttribute("hide_windows", application.transition.hide_windows);
-    TransitionNode->SetAttribute("cross_fade", application.transition.cross_fade);
-    TransitionNode->SetAttribute("duration", application.transition.duration);
-    TransitionNode->SetAttribute("profile", application.transition.profile);
-    pRoot->InsertEndChild(TransitionNode);
-
-    // bloc views
-    {
-        XMLElement *viewsNode = xmlDoc.NewElement( "Views" );
-        // save current view only if [mixing, geometry or layers]
-        int v = application.current_view > 3 ? 1 : application.current_view;
-        viewsNode->SetAttribute("current", v);
-
-        map<int, Settings::ViewConfig>::iterator iter;
-        for (iter=application.views.begin(); iter != application.views.end(); iter++)
-        {
-            const Settings::ViewConfig& v = iter->second;
-
-            XMLElement *view = xmlDoc.NewElement( "View" );
-            view->SetAttribute("name", v.name.c_str());
-            view->SetAttribute("id", iter->first);
-
-            XMLElement *scale = xmlDoc.NewElement("default_scale");
-            scale->InsertEndChild( XMLElementFromGLM(&xmlDoc, v.default_scale) );
-            view->InsertEndChild(scale);
-            XMLElement *translation = xmlDoc.NewElement("default_translation");
-            translation->InsertEndChild( XMLElementFromGLM(&xmlDoc, v.default_translation) );
-            view->InsertEndChild(translation);
-
-            viewsNode->InsertEndChild(view);
-        }
-
-        pRoot->InsertEndChild(viewsNode);
-    }
-
-    // bloc history
-    {
-        XMLElement *recent = xmlDoc.NewElement( "Recent" );
-
-        XMLElement *recentsession = xmlDoc.NewElement( "Session" );
-        recentsession->SetAttribute("path", application.recentSessions.path.c_str());
-        recentsession->SetAttribute("autoload", application.recentSessions.load_at_start);
-        recentsession->SetAttribute("autosave", application.recentSessions.save_on_exit);
-        recentsession->SetAttribute("valid", application.recentSessions.valid_file);
-        for(auto it = application.recentSessions.filenames.begin();
-            it != application.recentSessions.filenames.end(); it++) {
-            XMLElement *fileNode = xmlDoc.NewElement("path");
-            XMLText *text = xmlDoc.NewText( (*it).c_str() );
-            fileNode->InsertEndChild( text );
-            recentsession->InsertFirstChild(fileNode);
-        };
-        recent->InsertEndChild(recentsession);
-
-        XMLElement *recentfolder = xmlDoc.NewElement( "Folder" );
-        for(auto it = application.recentFolders.filenames.begin();
-            it != application.recentFolders.filenames.end(); it++) {
-            XMLElement *fileNode = xmlDoc.NewElement("path");
-            XMLText *text = xmlDoc.NewText( (*it).c_str() );
-            fileNode->InsertEndChild( text );
-            recentfolder->InsertFirstChild(fileNode);
-        };
-        recent->InsertEndChild(recentfolder);
-
-        XMLElement *recentmedia = xmlDoc.NewElement( "Import" );
-        recentmedia->SetAttribute("path", application.recentImport.path.c_str());
-        for(auto it = application.recentImport.filenames.begin();
-            it != application.recentImport.filenames.end(); it++) {
-            XMLElement *fileNode = xmlDoc.NewElement("path");
-            XMLText *text = xmlDoc.NewText( (*it).c_str() );
-            fileNode->InsertEndChild( text );
-            recentmedia->InsertFirstChild(fileNode);
-        }
-        recent->InsertEndChild(recentmedia);
-
-        pRoot->InsertEndChild(recent);
-    }
-
-
-    // First save : create filename
-    if (settingsFilename.empty())
-        settingsFilename = SystemToolkit::full_filename(SystemToolkit::settings_path(), APP_SETTINGS);
-
-    XMLError eResult = xmlDoc.SaveFile(settingsFilename.c_str());
-    XMLResultError(eResult);
-}
-
-void Settings::Load()
-{
-    XMLDocument xmlDoc;
-    if (settingsFilename.empty())
-        settingsFilename = SystemToolkit::full_filename(SystemToolkit::settings_path(), APP_SETTINGS);
-    XMLError eResult = xmlDoc.LoadFile(settingsFilename.c_str());
-
-	// do not warn if non existing file
-    if (eResult == XML_ERROR_FILE_NOT_FOUND)
-        return;
-    // warn and return on other error
-    else if (XMLResultError(eResult))
-        return;
-
-    XMLElement *pRoot = xmlDoc.FirstChildElement(application.name.c_str());
-    if (pRoot == nullptr) return;
-
-    if (application.name.compare( string( pRoot->Value() ) ) != 0 ) 
-        // different root name
-        return;
-
-    XMLElement * applicationNode = pRoot->FirstChildElement("Application");
-    if (applicationNode != nullptr) {
-        applicationNode->QueryFloatAttribute("scale", &application.scale);
-        applicationNode->QueryIntAttribute("accent_color", &application.accent_color);
-        applicationNode->QueryBoolAttribute("pannel_stick", &application.pannel_stick);
-        applicationNode->QueryBoolAttribute("smooth_transition", &application.smooth_transition);
-    }
-
-    // Widgets
-    XMLElement * widgetsNode = pRoot->FirstChildElement("Widgets");
-    if (widgetsNode != nullptr) {
-        widgetsNode->QueryBoolAttribute("preview", &application.widget.preview);
-        widgetsNode->QueryBoolAttribute("media_player", &application.widget.media_player);
-        widgetsNode->QueryBoolAttribute("shader_editor", &application.widget.shader_editor);
-        widgetsNode->QueryBoolAttribute("stats", &application.widget.stats);
-        widgetsNode->QueryIntAttribute("stats_corner", &application.widget.stats_corner);
-        widgetsNode->QueryBoolAttribute("logs", &application.widget.logs);
-        widgetsNode->QueryBoolAttribute("toolbox", &application.widget.toolbox);
-    }
-
-    // Render
-    XMLElement * rendernode = pRoot->FirstChildElement("Render");
-    if (rendernode != nullptr) {
-        rendernode->QueryIntAttribute("vsync", &application.render.vsync);
-        rendernode->QueryIntAttribute("multisampling", &application.render.multisampling);
-        rendernode->QueryBoolAttribute("blit", &application.render.blit);
-        rendernode->QueryIntAttribute("ratio", &application.render.ratio);
-        rendernode->QueryIntAttribute("res", &application.render.res);
-    }
-
-    // Transition
-    XMLElement * transitionnode = pRoot->FirstChildElement("Transition");
-    if (transitionnode != nullptr) {
-        transitionnode->QueryBoolAttribute("hide_windows", &application.transition.hide_windows);
-        transitionnode->QueryBoolAttribute("auto_open", &application.transition.auto_open);
-        transitionnode->QueryBoolAttribute("cross_fade", &application.transition.cross_fade);
-        transitionnode->QueryFloatAttribute("duration", &application.transition.duration);
-        transitionnode->QueryIntAttribute("profile", &application.transition.profile);
-    }
-
-    // bloc windows
-    {
-        XMLElement * pElement = pRoot->FirstChildElement("Windows");
-        if (pElement)
-        {
-            XMLElement* windowNode = pElement->FirstChildElement("Window");
-            for( ; windowNode ; windowNode=windowNode->NextSiblingElement())
-            {
-                Settings::WindowConfig w;
-                w.name = std::string(windowNode->Attribute("name"));
-                windowNode->QueryIntAttribute("x", &w.x); // If this fails, original value is left as-is
-                windowNode->QueryIntAttribute("y", &w.y);
-                windowNode->QueryIntAttribute("w", &w.w);
-                windowNode->QueryIntAttribute("h", &w.h);
-                windowNode->QueryBoolAttribute("f", &w.fullscreen);
-                w.monitor = std::string(windowNode->Attribute("m"));
-
-                int i = 0;
-                windowNode->QueryIntAttribute("id", &i);
-                application.windows[i] = w;
-            }
-        }
-	}
-
-    // bloc views
-    {
-        application.views.clear(); // trash existing list
-        XMLElement * pElement = pRoot->FirstChildElement("Views");
-        if (pElement)
-        {
-            pElement->QueryIntAttribute("current", &application.current_view);
-
-            XMLElement* viewNode = pElement->FirstChildElement("View");
-            for( ; viewNode ; viewNode=viewNode->NextSiblingElement())
-            {
-                int id = 0;
-                viewNode->QueryIntAttribute("id", &id);
-                application.views[id].name = viewNode->Attribute("name");
-
-                XMLElement* scaleNode = viewNode->FirstChildElement("default_scale");
-                tinyxml2::XMLElementToGLM( scaleNode->FirstChildElement("vec3"),
-                                           application.views[id].default_scale);
-
-                XMLElement* translationNode = viewNode->FirstChildElement("default_translation");
-                tinyxml2::XMLElementToGLM( translationNode->FirstChildElement("vec3"),
-                                           application.views[id].default_translation);
-
-            }
-        }
-
-    }
-
-    // bloc history of recent
-    {
-        XMLElement * pElement = pRoot->FirstChildElement("Recent");
-        if (pElement)
-        {
-            // recent session filenames
-            XMLElement * pSession = pElement->FirstChildElement("Session");
-            if (pSession)
-            {
-                const char *path_ = pSession->Attribute("path");
-                if (path_)
-                    application.recentSessions.path = std::string(path_);
-                else
-                    application.recentSessions.path = SystemToolkit::home_path();
-                application.recentSessions.filenames.clear();
-                XMLElement* path = pSession->FirstChildElement("path");
-                for( ; path ; path = path->NextSiblingElement())
-                {
-                    const char *p = path->GetText();
-                    if (p)
-                    application.recentSessions.push( std::string (p) );
-                }
-                pSession->QueryBoolAttribute("autoload", &application.recentSessions.load_at_start);
-                pSession->QueryBoolAttribute("autosave", &application.recentSessions.save_on_exit);
-                pSession->QueryBoolAttribute("valid", &application.recentSessions.valid_file);
-            }
-            // recent session filenames
-            XMLElement * pFolder = pElement->FirstChildElement("Folder");
-            if (pFolder)
-            {
-                application.recentFolders.filenames.clear();
-                XMLElement* path = pFolder->FirstChildElement("path");
-                for( ; path ; path = path->NextSiblingElement())
-                {
-                    const char *p = path->GetText();
-                    if (p)
-                    application.recentFolders.push( std::string (p) );
-                }
-            }
-            // recent media uri
-            XMLElement * pImport = pElement->FirstChildElement("Import");
-            if (pImport)
-            {
-                const char *path_ = pImport->Attribute("path");
-                if (path_)
-                    application.recentImport.path = std::string(path_);
-                else
-                    application.recentImport.path = SystemToolkit::home_path();
-                application.recentImport.filenames.clear();
-                XMLElement* path = pImport->FirstChildElement("path");
-                for( ; path ; path = path->NextSiblingElement())
-                {
-                    const char *p = path->GetText();
-                    if (p)
-                    application.recentImport.push( std::string (p) );
-                }
-            }
-        }
-    }
-
-
-}
-
-
-void Settings::Check()
-{
-	Settings::Save();
-
-    XMLDocument xmlDoc;
-    XMLError eResult = xmlDoc.LoadFile(settingsFilename.c_str());
-    if (XMLResultError(eResult))
-        return;
-
-	xmlDoc.Print();
-}

Settings.h

@@ -1,184 +0,0 @@
-#ifndef __SETTINGS_H_
-#define __SETTINGS_H_
-
-#include "defines.h"
-
-#include <string>
-#include <map>
-#include <vector>
-#include <list>
-#include <glm/glm.hpp>
-
-namespace Settings {
-
-struct WidgetsConfig
-{
-    bool stats;
-    int  stats_corner;
-    bool logs;
-    bool preview;
-    bool media_player;
-    bool media_player_view;
-    bool shader_editor;
-    bool toolbox;
-
-    WidgetsConfig() {
-        stats = false;
-        stats_corner = 1;
-        logs = false;
-        preview = false;
-        media_player = false;
-        media_player_view = true;
-        shader_editor = false;
-        toolbox = false;
-    }
-};
-
-struct WindowConfig
-{
-    std::string name;
-    int x,y,w,h;
-    bool fullscreen;
-    std::string monitor;
-
-    WindowConfig() : name(""), x(15), y(15), w(1280), h(720), fullscreen(false), monitor("") { }
-
-};
-
-struct ViewConfig
-{
-    std::string name;
-    glm::vec3 default_scale;
-    glm::vec3 default_translation;
-
-    ViewConfig() : name("") {
-        default_scale = glm::vec3(1.f);
-        default_translation = glm::vec3(0.f);
-    }
-
-};
-
-struct History
-{
-    std::string path;
-    std::list<std::string> filenames;
-    bool valid_file;
-    bool load_at_start;
-    bool save_on_exit;
-
-    History() {
-        path = IMGUI_LABEL_RECENT_FILES;
-        valid_file = false;
-        load_at_start = false;
-        save_on_exit = false;
-    }
-    void push(std::string filename) {
-        if (filename.empty()) {
-            valid_file = false;
-            return;
-        }
-        filenames.remove(filename);
-        filenames.push_front(filename);
-        if (filenames.size() > MAX_RECENT_HISTORY)
-            filenames.pop_back();
-        valid_file = true;
-    }
-};
-
-struct TransitionConfig
-{
-    bool cross_fade;
-    bool auto_open;
-    bool hide_windows;
-    float duration;
-    int profile;
-
-    TransitionConfig() {
-        cross_fade = true;
-        auto_open = true;
-        hide_windows = true;
-        duration = 1.f;
-        profile = 0;
-    }
-};
-
-struct RenderConfig
-{
-    bool blit;
-    int vsync;
-    int multisampling;
-    int ratio;
-    int res;
-    float fading;
-
-    RenderConfig() {
-        blit = false;
-        vsync = 1; // todo GUI selection
-        multisampling = 2; // todo GUI selection
-        ratio = 3;
-        res = 1;
-        fading = 0.0;
-    }
-};
-
-struct Application
-{
-    // Verification
-    std::string name;
-    std::string executable;
-
-    // Global settings Application interface
-    float scale;
-    int  accent_color;
-    bool pannel_stick;
-    bool smooth_transition;
-
-    // Settings of widgets
-    WidgetsConfig widget;
-
-    // Settings of Views
-    int current_view;
-    std::map<int, ViewConfig> views;
-
-    // settings render
-    RenderConfig render;
-
-    // settings transition
-    TransitionConfig transition;
-
-    // multiple windows handling
-    std::vector<WindowConfig> windows;
-
-    // recent files histories
-    History recentSessions;
-    History recentFolders;
-    History recentImport;
-
-    Application() : name(APP_NAME){
-        scale = 1.f;
-        accent_color = 0;
-        pannel_stick = false;
-        smooth_transition = true;
-        current_view = 1;
-        windows = std::vector<WindowConfig>(3);
-        windows[0].name = APP_NAME APP_TITLE;
-        windows[0].w = 1600;
-        windows[0].h = 900;
-        windows[1].name = APP_NAME " -- Output";
-    }
-
-};
-
-
-// minimal implementation of settings
-// Can be accessed r&w anywhere
-extern Application application;
-
-// Save and Load store settings in XML file
-void Save();
-void Load();
-void Check();
-
-}
-
-#endif /* __SETTINGS_H_ */

Shader.cpp

@@ -1,234 +0,0 @@
-#include "Shader.h"
-#include "Resource.h"
-#include "Log.h"
-#include "Visitor.h"
-#include "RenderingManager.h"
-
-#include <fstream>
-#include <sstream>
-#include <iostream>
-#include <chrono>
-#include <ctime>
-
-#include <glad/glad.h> 
-#include <GLFW/glfw3.h>
-
-#include <glm/glm.hpp>
-#include <glm/gtc/type_ptr.hpp>
-#define GLM_ENABLE_EXPERIMENTAL
-#include <glm/gtx/string_cast.hpp>
-
-// Globals
-ShadingProgram *ShadingProgram::currentProgram_ = nullptr;
-ShadingProgram simpleShadingProgram("shaders/simple.vs", "shaders/simple.fs");
-
-// Blending presets for matching with Shader::BlendMode
-GLenum blending_equation[6] = { GL_FUNC_ADD, GL_FUNC_ADD, GL_FUNC_REVERSE_SUBTRACT, GL_FUNC_ADD, GL_FUNC_REVERSE_SUBTRACT, GL_FUNC_ADD};
-GLenum blending_source_function[6] = { GL_SRC_ALPHA,GL_SRC_ALPHA,GL_SRC_ALPHA,GL_SRC_ALPHA,GL_SRC_ALPHA,GL_SRC_ALPHA};
-GLenum blending_destination_function[6] = {GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE, GL_DST_COLOR, GL_DST_COLOR, GL_ONE_MINUS_SRC_ALPHA};
-
-
-
-ShadingProgram::ShadingProgram(const std::string& vertex_file, const std::string& fragment_file) : vertex_id_(0), fragment_id_(0), id_(0)
-{
-    vertex_file_ = vertex_file;
-    fragment_file_ = fragment_file;
-}
-
-void ShadingProgram::init()
-{
-    vertex_code_ = Resource::getText(vertex_file_);
-    fragment_code_ = Resource::getText(fragment_file_);
-	compile();
-	link();
-}
-
-bool ShadingProgram::initialized()
-{
-    return (id_ != 0);
-}
-
-void ShadingProgram::compile()
-{
-    const char* vcode = vertex_code_.c_str();
-    vertex_id_ = glCreateShader(GL_VERTEX_SHADER);
-    glShaderSource(vertex_id_, 1, &vcode, NULL);
-    glCompileShader(vertex_id_);
-
-    const char* fcode = fragment_code_.c_str();
-    fragment_id_ = glCreateShader(GL_FRAGMENT_SHADER);
-    glShaderSource(fragment_id_, 1, &fcode, NULL);
-    glCompileShader(fragment_id_);
-
-    checkCompileErr();
-}
-
-void ShadingProgram::link()
-{
-    id_ = glCreateProgram();
-    glAttachShader(id_, vertex_id_);
-    glAttachShader(id_, fragment_id_);
-    glLinkProgram(id_);
-    checkLinkingErr();
-    glUseProgram(id_);
-    glUniform1i(glGetUniformLocation(id_, "iChannel0"), 0);
-    glUniform1i(glGetUniformLocation(id_, "iChannel1"), 1);
-    glUseProgram(0);
-    glDeleteShader(vertex_id_);
-    glDeleteShader(fragment_id_);
-}
-
-void ShadingProgram::use()
-{
-    if (currentProgram_ == nullptr || currentProgram_ != this)
-    {
-        currentProgram_ = this;
-        glUseProgram(id_);
-    }
-}
-
-void ShadingProgram::enduse()
-{
-    glUseProgram(0);
-    currentProgram_ = nullptr ;
-}
-
-template<>
-void ShadingProgram::setUniform<int>(const std::string& name, int val) {
-	glUniform1i(glGetUniformLocation(id_, name.c_str()), val);
-}
-
-template<>
-void ShadingProgram::setUniform<bool>(const std::string& name, bool val) {
-	glUniform1i(glGetUniformLocation(id_, name.c_str()), val);
-}
-
-template<>
-void ShadingProgram::setUniform<float>(const std::string& name, float val) {
-	glUniform1f(glGetUniformLocation(id_, name.c_str()), val);
-}
-
-template<>
-void ShadingProgram::setUniform<float>(const std::string& name, float val1, float val2) {
-    glUniform2f(glGetUniformLocation(id_, name.c_str()), val1, val2);
-}
-
-template<>
-void ShadingProgram::setUniform<float>(const std::string& name, float val1, float val2, float val3) {
-    glUniform3f(glGetUniformLocation(id_, name.c_str()), val1, val2, val3);
-}
-
-template<>
-void ShadingProgram::setUniform<glm::vec4>(const std::string& name, glm::vec4 val) {
-    glm::vec4 v(val);
-    glUniform4fv(glGetUniformLocation(id_, name.c_str()), 1, glm::value_ptr(v));
-}
-
-template<>
-void ShadingProgram::setUniform<glm::vec3>(const std::string& name, glm::vec3 val) {
-    glm::vec3 v(val);
-    glUniform4fv(glGetUniformLocation(id_, name.c_str()), 1, glm::value_ptr(v));
-}
-
-template<>
-void ShadingProgram::setUniform<glm::mat4>(const std::string& name, glm::mat4 val) {
-    glm::mat4 m(val);
-	glUniformMatrix4fv(glGetUniformLocation(id_, name.c_str()), 1, GL_FALSE, glm::value_ptr(m));
-}
-
-
-// template<>
-// void ShadingProgram::setUniform<float*>(const std::string& name, float* val) {
-// 	glUniformMatrix4fv(glGetUniformLocation(id_, name.c_str()), 1, GL_FALSE, val);
-// }
-
-void ShadingProgram::checkCompileErr()
-{
-    int success;
-    char infoLog[1024];
-    glGetShaderiv(vertex_id_, GL_COMPILE_STATUS, &success);
-    if (!success) {
-        glGetShaderInfoLog(vertex_id_, 1024, NULL, infoLog);
-        Log::Warning("Error compiling Vertex ShadingProgram:\n%s", infoLog);
-    }
-    glGetShaderiv(fragment_id_, GL_COMPILE_STATUS, &success);
-	if (!success) {
-        glGetShaderInfoLog(fragment_id_, 1024, NULL, infoLog);
-        Log::Warning("Error compiling Fragment ShadingProgram:\n%s", infoLog);
-	}
-}
-
-void ShadingProgram::checkLinkingErr()
-{
-	int success;
-	char infoLog[1024];
-	glGetProgramiv(id_, GL_LINK_STATUS, &success);
-	if (!success) {
-		glGetProgramInfoLog(id_, 1024, NULL, infoLog);
-        Log::Warning("Error linking ShadingProgram:\n%s", infoLog);
-	}
-}
-
-
-Shader::Shader() : blending(BLEND_OPACITY)
-{
-    // create unique id
-    auto duration = std::chrono::high_resolution_clock::now().time_since_epoch();
-    id_ = std::chrono::duration_cast<std::chrono::nanoseconds>(duration).count() % 100000000;
-
-    program_ = &simpleShadingProgram;
-    reset();
-}
-
-
-void Shader::operator = (const Shader &S )
-{
-    color = S.color;
-    blending = S.blending;
-}
-
-void Shader::accept(Visitor& v) {
-    v.visit(*this);
-}
-
-void Shader::use()
-{
-    // initialization on first use
-    if (!program_->initialized())
-        program_->init();
-
-    // Use program and set uniforms
-    program_->use();
-
-    // set uniforms
-    program_->setUniform("projection", projection);
-    program_->setUniform("modelview", modelview);
-    program_->setUniform("color", color);
-
-    iResolution = glm::vec3( Rendering::manager().currentAttrib().viewport, 0.f);
-    program_->setUniform("iResolution", iResolution);
-
-    // Blending Function
-    if ( blending != BLEND_CUSTOM) {
-        glEnable(GL_BLEND);
-        glBlendEquation(blending_equation[blending]);
-        glBlendFunc(blending_source_function[blending], blending_destination_function[blending]);
-
-//        glBlendEquationSeparate(blending_equation[blending], GL_FUNC_ADD);
-//        glBlendFuncSeparate(blending_source_function[blending], blending_destination_function[blending], GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-
-    }
-    else
-        glDisable(GL_BLEND);
-}
-
-
-void Shader::reset()
-{
-    projection = glm::identity<glm::mat4>();
-    modelview  = glm::identity<glm::mat4>();
-    iResolution = glm::vec3(1280.f, 720.f, 0.f);
-    color = glm::vec4(1.f, 1.f, 1.f, 1.f);
-}
-
-

Shader.h

@@ -1,75 +0,0 @@
-#ifndef __SHADER_H_
-#define __SHADER_H_
-
-#include <string>
-#include <vector>
-#include <glm/glm.hpp>
-
-// Forward declare classes referenced
-class Visitor;
-
-class ShadingProgram
-{
-public:
-    ShadingProgram(const std::string& vertex_file, const std::string& fragment_file);
-    void init();
-    bool initialized();
-    void use();
-	template<typename T> void setUniform(const std::string& name, T val);
-	template<typename T> void setUniform(const std::string& name, T val1, T val2);
-	template<typename T> void setUniform(const std::string& name, T val1, T val2, T val3);
-
-	static void enduse();
-
-private:
-	void checkCompileErr();
-	void checkLinkingErr();
-	void compile();
-	void link();
-	unsigned int vertex_id_, fragment_id_, id_;
-	std::string vertex_code_;
-	std::string fragment_code_;
-    std::string vertex_file_;
-    std::string fragment_file_;
-
-    static ShadingProgram *currentProgram_;
-};
-
-class Shader
-{
-    int       id_;
-
-public:
-    Shader();
-
-    // unique identifyer generated at instanciation
-    inline int id () const { return id_; }
-
-    virtual void use();
-    virtual void reset();
-    virtual void accept(Visitor& v);
-
-    void operator = (const Shader &D );
-
-    glm::mat4 projection;
-    glm::mat4 modelview;
-    glm::vec4 color;
-
-    typedef enum {
-        BLEND_OPACITY = 0,
-        BLEND_ADD,
-        BLEND_SUBSTRACT,
-        BLEND_LAYER_ADD,
-        BLEND_LAYER_SUBSTRACT,
-        BLEND_CUSTOM
-    } BlendMode;
-    BlendMode blending;
-
-protected:
-    ShadingProgram *program_;
-    glm::vec3 iResolution;
-
-};
-
-
-#endif /* __SHADER_H_ */

Source.cpp

@@ -1,431 +0,0 @@
-
-#include <algorithm>
-#include <glm/gtc/matrix_transform.hpp>
-
-#include "Source.h"
-
-#include "defines.h"
-#include "FrameBuffer.h"
-#include "Primitives.h"
-#include "Decorations.h"
-#include "Mesh.h"
-#include "Resource.h"
-#include "Session.h"
-#include "SearchVisitor.h"
-#include "ImageShader.h"
-#include "ImageProcessingShader.h"
-#include "Log.h"
-#include "Mixer.h"
-
-Source::Source() : initialized_(false), active_(true), need_update_(true)
-{
-    sprintf(initials_, "__");
-    name_ = "Source";
-    mode_ = Source::UNINITIALIZED;
-
-    // create groups and overlays for each view
-
-    // default rendering node
-    groups_[View::RENDERING] = new Group;
-    groups_[View::RENDERING]->visible_ = false;
-
-    // default mixing nodes
-    groups_[View::MIXING] = new Group;
-    groups_[View::MIXING]->visible_ = false;
-    groups_[View::MIXING]->scale_ = glm::vec3(0.15f, 0.15f, 1.f);
-    groups_[View::MIXING]->translation_ = glm::vec3(-1.f, 1.f, 0.f);
-
-    frames_[View::MIXING] = new Switch;
-    Frame *frame = new Frame(Frame::ROUND, Frame::THIN, Frame::DROP);
-    frame->translation_.z = 0.1;
-    frame->color = glm::vec4( COLOR_DEFAULT_SOURCE, 0.9f);
-    frames_[View::MIXING]->attach(frame);
-    frame = new Frame(Frame::ROUND, Frame::LARGE, Frame::DROP);
-    frame->translation_.z = 0.01;
-    frame->color = glm::vec4( COLOR_HIGHLIGHT_SOURCE, 1.f);
-    frames_[View::MIXING]->attach(frame);
-    groups_[View::MIXING]->attach(frames_[View::MIXING]);
-
-    overlays_[View::MIXING] = new Group;
-    overlays_[View::MIXING]->translation_.z = 0.1;
-    overlays_[View::MIXING]->visible_ = false;
-    Symbol *center = new Symbol(Symbol::POINT, glm::vec3(0.f, 0.f, 0.1f));
-    overlays_[View::MIXING]->attach(center);
-    groups_[View::MIXING]->attach(overlays_[View::MIXING]);
-
-    // default geometry nodes
-    groups_[View::GEOMETRY] = new Group;
-    groups_[View::GEOMETRY]->visible_ = false;
-
-    frames_[View::GEOMETRY] = new Switch;
-    frame = new Frame(Frame::SHARP, Frame::THIN, Frame::NONE);
-    frame->translation_.z = 0.1;
-    frame->color = glm::vec4( COLOR_DEFAULT_SOURCE, 0.7f);
-    frames_[View::GEOMETRY]->attach(frame);
-    frame = new Frame(Frame::SHARP, Frame::LARGE, Frame::GLOW);
-    frame->translation_.z = 0.1;
-    frame->color = glm::vec4( COLOR_HIGHLIGHT_SOURCE, 1.f);
-    frames_[View::GEOMETRY]->attach(frame);
-    groups_[View::GEOMETRY]->attach(frames_[View::GEOMETRY]);
-
-    overlays_[View::GEOMETRY] = new Group;
-    overlays_[View::GEOMETRY]->translation_.z = 0.15;
-    overlays_[View::GEOMETRY]->visible_ = false;
-    handle_[Handles::RESIZE] = new Handles(Handles::RESIZE);
-    handle_[Handles::RESIZE]->color = glm::vec4( COLOR_HIGHLIGHT_SOURCE, 1.f);
-    handle_[Handles::RESIZE]->translation_.z = 0.1;
-    overlays_[View::GEOMETRY]->attach(handle_[Handles::RESIZE]);
-    handle_[Handles::RESIZE_H] = new Handles(Handles::RESIZE_H);
-    handle_[Handles::RESIZE_H]->color = glm::vec4( COLOR_HIGHLIGHT_SOURCE, 1.f);
-    handle_[Handles::RESIZE_H]->translation_.z = 0.1;
-    overlays_[View::GEOMETRY]->attach(handle_[Handles::RESIZE_H]);
-    handle_[Handles::RESIZE_V] = new Handles(Handles::RESIZE_V);
-    handle_[Handles::RESIZE_V]->color = glm::vec4( COLOR_HIGHLIGHT_SOURCE, 1.f);
-    handle_[Handles::RESIZE_V]->translation_.z = 0.1;
-    overlays_[View::GEOMETRY]->attach(handle_[Handles::RESIZE_V]);
-    handle_[Handles::ROTATE] = new Handles(Handles::ROTATE);
-    handle_[Handles::ROTATE]->color = glm::vec4( COLOR_HIGHLIGHT_SOURCE, 1.f);
-    handle_[Handles::ROTATE]->translation_.z = 0.1;
-    overlays_[View::GEOMETRY]->attach(handle_[Handles::ROTATE]);
-    frame = new Frame(Frame::SHARP, Frame::THIN, Frame::NONE);
-    frame->translation_.z = 0.1;
-    frame->color = glm::vec4( COLOR_HIGHLIGHT_SOURCE, 0.7f);
-    overlays_[View::GEOMETRY]->attach(frame);
-    groups_[View::GEOMETRY]->attach(overlays_[View::GEOMETRY]);
-
-    // default layer nodes
-    groups_[View::LAYER] = new Group;
-    groups_[View::LAYER]->visible_ = false;
-
-    frames_[View::LAYER] = new Switch;
-    frame = new Frame(Frame::ROUND, Frame::THIN, Frame::PERSPECTIVE);
-    frame->translation_.z = 0.1;
-    frame->color = glm::vec4( COLOR_DEFAULT_SOURCE, 0.8f);    
-    frames_[View::LAYER]->attach(frame);
-    frame = new Frame(Frame::ROUND, Frame::LARGE, Frame::PERSPECTIVE);
-    frame->translation_.z = 0.1;
-    frame->color = glm::vec4( COLOR_HIGHLIGHT_SOURCE, 1.f);
-    frames_[View::LAYER]->attach(frame);
-    groups_[View::LAYER]->attach(frames_[View::LAYER]);
-
-    overlays_[View::LAYER] = new Group;
-    overlays_[View::LAYER]->translation_.z = 0.15;
-    overlays_[View::LAYER]->visible_ = false;
-    groups_[View::LAYER]->attach(overlays_[View::LAYER]);
-
-    // empty transition node
-    groups_[View::TRANSITION] = new Group;
-
-    // create objects
-    stored_status_  = new Group;
-
-    // those will be associated to nodes later
-    blendingshader_ = new ImageShader;
-    rendershader_   = new ImageProcessingShader;
-    renderbuffer_   = nullptr;
-    rendersurface_  = nullptr;
-
-}
-
-Source::~Source()
-{
-    // delete objects
-    delete stored_status_;
-    if (renderbuffer_)
-        delete renderbuffer_;
-
-    // all groups and their children are deleted in the scene
-    // this includes rendersurface_, overlays, blendingshader_ and rendershader_
-    delete groups_[View::RENDERING];
-    delete groups_[View::MIXING];
-    delete groups_[View::GEOMETRY];
-    delete groups_[View::LAYER];
-    delete groups_[View::TRANSITION];
-
-    groups_.clear();
-    frames_.clear();
-    overlays_.clear();
-
-    // inform clones that they lost their origin
-    for (auto it = clones_.begin(); it != clones_.end(); it++)
-        (*it)->origin_ = nullptr;
-
-}
-
-void Source::setName (const std::string &name)
-{
-    name_ = name;
-
-    initials_[0] = std::toupper( name_.front() );
-    initials_[1] = std::toupper( name_.back() );
-}
-
-void Source::accept(Visitor& v)
-{
-    v.visit(*this);
-}
-
-
-Source::Mode Source::mode() const
-{
-    return mode_;
-}
-
-void Source::setMode(Source::Mode m)
-{
-    // make visible on first time
-    if ( mode_ == Source::UNINITIALIZED ) {
-        for (auto g = groups_.begin(); g != groups_.end(); g++)
-            (*g).second->visible_ = true;
-    }
-
-    // choose frame if selected
-    uint index_frame = m == Source::VISIBLE ? 0 : 1;
-    for (auto f = frames_.begin(); f != frames_.end(); f++)
-        (*f).second->setActive(index_frame);
-
-    // show overlay if current
-    bool current = m == Source::CURRENT;
-    for (auto o = overlays_.begin(); o != overlays_.end(); o++)
-        (*o).second->visible_ = current;
-
-    mode_ = m;
-}
-
-void Source::attach(FrameBuffer *renderbuffer)
-{
-    renderbuffer_ = renderbuffer;
-
-    // create the surfaces to draw the frame buffer in the views
-    rendersurface_ = new FrameBufferSurface(renderbuffer_, blendingshader_);
-    groups_[View::RENDERING]->attach(rendersurface_);
-    groups_[View::GEOMETRY]->attach(rendersurface_);
-    groups_[View::MIXING]->attach(rendersurface_);
-//    groups_[View::LAYER]->attach(rendersurface_);
-
-    // for mixing and layer views, add another surface to overlay
-    // (stippled view on top with transparency)
-    Surface *surfacemix = new FrameBufferSurface(renderbuffer_);
-    ImageShader *is = static_cast<ImageShader *>(surfacemix->shader());
-    if (is)  is->stipple = 1.0;
-    groups_[View::MIXING]->attach(surfacemix);
-    groups_[View::LAYER]->attach(surfacemix);
-
-    // scale all icon nodes to match aspect ratio of the media
-    NodeSet::iterator node;
-    for (node = groups_[View::MIXING]->begin();
-         node != groups_[View::MIXING]->end(); node++) {
-        (*node)->scale_.x = renderbuffer_->aspectRatio();
-    }
-    for (node = groups_[View::GEOMETRY]->begin();
-         node != groups_[View::GEOMETRY]->end(); node++) {
-        (*node)->scale_.x = renderbuffer_->aspectRatio();
-    }
-    for (node = groups_[View::LAYER]->begin();
-         node != groups_[View::LAYER]->end(); node++) {
-        (*node)->scale_.x = renderbuffer_->aspectRatio();
-    }
-
-    // Transition group node is optionnal
-    if ( groups_[View::TRANSITION]->numChildren() > 0 ) {
-        groups_[View::TRANSITION]->attach(rendersurface_);
-        groups_[View::TRANSITION]->attach(surfacemix);
-        for (NodeSet::iterator node = groups_[View::TRANSITION]->begin();
-             node != groups_[View::TRANSITION]->end(); node++) {
-            (*node)->scale_.x = renderbuffer_->aspectRatio();
-        }
-    }
-
-    // make the source visible
-    if ( mode_ == UNINITIALIZED )
-        setMode(VISIBLE);
-}
-
-void Source::setActive (bool on)
-{
-    active_ = on;
-
-    for(auto clone = clones_.begin(); clone != clones_.end(); clone++) {
-        if ( (*clone)->active() )
-            active_ = true;
-    }
-
-    groups_[View::RENDERING]->visible_ = active_;
-    groups_[View::GEOMETRY]->visible_ = active_;
-    groups_[View::LAYER]->visible_ = active_;
-
-}
-
-void Source::update(float dt)
-{
-    // keep delta-t
-    dt_ = dt;
-
-    // update nodes if needed
-    if (need_update_)
-    {
-        // ADJUST alpha based on MIXING node
-        // read position of the mixing node and interpret this as transparency of render output
-        glm::vec2 dist = glm::vec2(groups_[View::MIXING]->translation_);
-        float alpha = 1.0 - CLAMP( ( dist.x * dist.x ) + ( dist.y * dist.y ), 0.f, 1.f );
-        blendingshader_->color.a = alpha;
-
-        // CHANGE update status based on limbo
-        setActive( glm::length(dist) < 1.3f );
-
-        // MODIFY geometry based on GEOMETRY node
-        groups_[View::RENDERING]->translation_ = groups_[View::GEOMETRY]->translation_;
-        groups_[View::RENDERING]->rotation_ = groups_[View::GEOMETRY]->rotation_;
-        // avoid any null scale
-        glm::vec3 s = groups_[View::GEOMETRY]->scale_;
-        s.x = CLAMP_SCALE(s.x);
-        s.y = CLAMP_SCALE(s.y);
-        s.z = 1.f;
-        groups_[View::GEOMETRY]->scale_ = s;
-        groups_[View::RENDERING]->scale_ = s;
-
-        // MODIFY depth based on LAYER node
-        groups_[View::MIXING]->translation_.z = groups_[View::LAYER]->translation_.z;
-        groups_[View::GEOMETRY]->translation_.z = groups_[View::LAYER]->translation_.z;
-        groups_[View::RENDERING]->translation_.z = groups_[View::LAYER]->translation_.z;
-
-        need_update_ = false;
-    }
-}
-
-FrameBuffer *Source::frame() const
-{
-    if (initialized_ && renderbuffer_)
-    {
-        return renderbuffer_;
-    }
-    else {
-        static FrameBuffer *black = new FrameBuffer(640,480);
-        return black;
-    }
-}
-
-bool Source::contains(Node *node) const
-{
-    if ( node == nullptr )
-        return false;
-
-    hasNode tester(node);
-    return tester(this);
-}
-
-
-bool Source::hasNode::operator()(const Source* elem) const
-{
-    if (_n && elem)
-    {
-        // quick case (most frequent and easy to answer)
-        if (elem->rendersurface_ == _n)
-            return true;
-
-        // general case: traverse tree of all Groups recursively using a SearchVisitor
-        SearchVisitor sv(_n);
-        for (auto g = elem->groups_.begin(); g != elem->groups_.end(); g++) {
-            (*g).second->accept(sv);
-            if (sv.found())
-                return true;
-        }
-    }
-
-    return false;
-}
-
-CloneSource *Source::clone()
-{
-    CloneSource *s = new CloneSource(this);
-
-    clones_.push_back(s);
-
-    return s;
-}
-
-CloneSource::CloneSource(Source *origin) : Source(), origin_(origin)
-{
-    // create surface:
-    clonesurface_ = new Surface(rendershader_);
-}
-
-CloneSource::~CloneSource()
-{
-    // delete surface
-    delete clonesurface_;
-}
-
-CloneSource *CloneSource::clone()
-{
-    // do not clone a clone : clone the original instead
-    if (origin_)
-        return origin_->clone();
-    else
-        return nullptr;
-}
-
-void CloneSource::init()
-{
-    if (origin_ && origin_->ready()) {
-
-        // get the texture index from framebuffer of view, apply it to the surface
-        clonesurface_->setTextureIndex( origin_->texture() );
-
-        // create Frame buffer matching size of session
-        FrameBuffer *renderbuffer = new FrameBuffer( origin_->frame()->resolution(), true);
-
-        // set the renderbuffer of the source and attach rendering nodes
-        attach(renderbuffer);
-
-        // icon in mixing view
-        overlays_[View::MIXING]->attach( new Symbol(Symbol::CLONE, glm::vec3(0.8f, 0.8f, 0.01f)) );
-        overlays_[View::LAYER]->attach( new Symbol(Symbol::CLONE, glm::vec3(0.8f, 0.8f, 0.01f)) );
-
-        // done init
-        initialized_ = true;
-
-        Log::Info("Source Clone linked to source %s).", origin_->name().c_str() );
-    }
-}
-
-void CloneSource::setActive (bool on)
-{
-    active_ = on;
-
-    groups_[View::RENDERING]->visible_ = active_;
-    groups_[View::GEOMETRY]->visible_ = active_;
-    groups_[View::LAYER]->visible_ = active_;
-
-    if (origin_)
-        origin_->touch();
-}
-
-
-uint CloneSource::texture() const
-{
-    if (origin_)
-        return origin_->texture();
-    else
-        return Resource::getTextureBlack();
-}
-
-void CloneSource::render()
-{
-    if (!initialized_)
-        init();
-    else {
-        // render the view into frame buffer
-        static glm::mat4 projection = glm::ortho(-1.f, 1.f, 1.f, -1.f, -1.f, 1.f);
-        renderbuffer_->begin();
-        clonesurface_->draw(glm::identity<glm::mat4>(), projection);
-        renderbuffer_->end();
-    }
-}
-
-void CloneSource::accept(Visitor& v)
-{
-    Source::accept(v);
-    v.visit(*this);
-}
-

Source.h

@@ -1,192 +0,0 @@
-#ifndef SOURCE_H
-#define SOURCE_H
-
-#include <string>
-#include <map>
-#include <list>
-
-#include "View.h"
-#include "Decorations.h"
-
-class ImageShader;
-class ImageProcessingShader;
-class FrameBuffer;
-class FrameBufferSurface;
-class MediaPlayer;
-class Surface;
-class Session;
-class Frame;
-class Source;
-class CloneSource;
-
-typedef std::list<Source *> SourceList;
-typedef std::list<CloneSource *> CloneList;
-
-class Source
-{
-    friend class View;
-    friend class MixingView;
-    friend class GeometryView;
-    friend class LayerView;
-    friend class TransitionView;
-
-public:
-    // create a source and add it to the list
-    // only subclasses of sources can actually be instanciated
-    Source();
-    virtual ~Source();
-
-    // manipulate name of source
-    void setName (const std::string &name);
-    inline std::string name () const { return name_; }
-    inline const char *initials () const { return initials_; }
-
-    // cloning mechanism
-    virtual CloneSource *clone ();
-    inline size_t numClones() const { return clones_.size(); }
-
-    // Display mode
-    typedef enum {
-        UNINITIALIZED   = 0,
-        VISIBLE   = 1,
-        SELECTED = 2,
-        CURRENT  = 3
-    } Mode;
-    Mode mode () const;
-    void setMode (Mode m);
-
-    // get handle on the nodes used to manipulate the source in a view
-    inline Group *group (View::Mode m) const { return groups_.at(m); }
-    inline Node  *groupNode (View::Mode m) const { return static_cast<Node*>(groups_.at(m)); }
-
-    // tests if a given node is part of the source
-    bool contains (Node *node) const;
-
-    // a Source has a shader to control image processing effects
-    inline ImageProcessingShader *processingShader () const { return rendershader_; }
-
-    // a Source has a shader to control mixing effects
-    inline ImageShader *blendingShader () const { return blendingshader_; }
-
-    // every Source has a frame buffer from the renderbuffer
-    virtual FrameBuffer *frame () const;
-
-    // touch to request update
-    inline void touch () { need_update_ = true; }
-
-    // informs if its ready (i.e. initialized)
-    inline bool ready() const  { return initialized_; }
-
-    // a Source shall be updated before displayed (Mixing, Geometry and Layer)
-    virtual void update (float dt);
-
-    // update mode
-    virtual void setActive (bool on);
-    inline bool active () { return active_; }
-
-    // a Source shall informs if the source failed (i.e. shall be deleted)
-    virtual bool failed() const = 0;
-
-    // a Source shall define a way to get a texture
-    virtual uint texture() const = 0;
-
-    // a Source shall define how to render into the frame buffer
-    virtual void render() = 0;
-
-    // accept all kind of visitors
-    virtual void accept (Visitor& v);
-
-    struct hasNode: public std::unary_function<Source*, bool>
-    {
-        bool operator()(const Source* elem) const;
-        hasNode(Node *n) : _n(n) { }
-    private:
-        Node *_n;
-    };
-
-    struct hasName: public std::unary_function<Source*, bool>
-    {
-        inline bool operator()(const Source* elem) const {
-           return (elem && elem->name() == _n);
-        }
-        hasName(std::string n) : _n(n) { }
-    private:
-        std::string _n;
-    };
-
-
-protected:
-    // name
-    std::string name_;
-    char initials_[3];
-
-    // every Source shall be initialized on first draw
-    bool initialized_;
-    virtual void init() = 0;
-
-    // nodes
-    std::map<View::Mode, Group*> groups_;
-
-    // render() fills in the renderbuffer at every frame
-    // NB: rendershader_ is applied at render()
-    FrameBuffer *renderbuffer_;
-    void attach(FrameBuffer *renderbuffer);
-
-    // the rendersurface draws the renderbuffer in the scene
-    // It is associated to the rendershader for mixing effects
-    FrameBufferSurface *rendersurface_;
-
-    // rendershader performs image processing
-    ImageProcessingShader *rendershader_;
-
-    // blendingshader provides mixing controls
-    ImageShader *blendingshader_;
-
-    // mode for display
-    Mode mode_;
-
-    // overlays and frames to be displayed on top of source
-    std::map<View::Mode, Group*> overlays_;
-    std::map<View::Mode, Switch*> frames_;
-    Handles *handle_[4];
-
-    // update
-    bool  active_;
-    bool  need_update_;
-    float dt_;
-    Group *stored_status_;
-
-    // clones
-    CloneList clones_;
-};
-
-
-
-class CloneSource : public Source
-{
-    friend class Source;
-
-public:
-    ~CloneSource();
-
-    // implementation of source API
-    void setActive (bool on) override;
-    void render() override;
-    uint texture() const override;
-    bool failed() const override  { return origin_ == nullptr; }
-    void accept (Visitor& v) override;
-
-    CloneSource *clone() override;
-    inline Source *origin() const { return origin_; }
-
-protected:
-    // only Source class can create new CloneSource via clone();
-    CloneSource(Source *origin);
-
-    void init() override;
-    Surface *clonesurface_;
-    Source *origin_;
-};
-
-
-#endif // SOURCE_H

SystemToolkit.cpp

@@ -1,286 +0,0 @@
-#include <stdlib.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <sstream>
-#include <fstream>
-#include <iomanip>
-#include <ctime>
-#include <chrono>
-
-using namespace std;
-
-#ifdef WIN32
-#include <windows.h>
-#define mkdir(dir, mode) _mkdir(dir)
-#include <include/dirent.h>
-#include <sys/resource.h>
-#define PATH_SEP '\\'
-#define PATH_SETTINGS "\\\AppData\\Roaming\\"
-#elif defined(LINUX) or defined(APPLE)
-#include <sys/resource.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <pwd.h>
-#include <dirent.h>
-#define PATH_SEP '/'
-#endif
-
-#if defined(APPLE)
-#define PATH_SETTINGS "/Library/Application Support/"
-#include <mach/task.h>
-#include <mach/mach_init.h>
-#elif defined(LINUX)
-#include <sys/sysinfo.h>
-#define PATH_SETTINGS "/.config/"
-#endif
-
-#include "defines.h"
-#include "SystemToolkit.h"
-
-/// The amount of memory currently being used by this process, in bytes.
-/// it will try to report the resident set in RAM
-long SystemToolkit::memory_usage()
-{
-#if defined(LINUX)
-    // Grabbing info directly from the /proc pseudo-filesystem.  Reading from
-    // /proc/self/statm gives info on your own process, as one line of
-    // numbers that are: virtual mem program size, resident set size,
-    // shared pages, text/code, data/stack, library, dirty pages.  The
-    // mem sizes should all be multiplied by the page size.
-    size_t size = 0;
-    FILE *file = fopen("/proc/self/statm", "r");
-    if (file) {
-        unsigned long m = 0;
-        fscanf (file, "%lu", &m);  // virtual mem program size,
-        fscanf (file, "%lu", &m);  // resident set size,
-        fclose (file);
-        size = (size_t)m * getpagesize();
-    }
-    return (long)size;
-
-#elif defined(APPLE)
-    // Inspired from
-    // http://miknight.blogspot.com/2005/11/resident-set-size-in-mac-os-x.html
-    struct task_basic_info t_info;
-    mach_msg_type_number_t t_info_count = TASK_BASIC_INFO_COUNT;
-    task_info(current_task(), TASK_BASIC_INFO, (task_info_t)&t_info, &t_info_count);
-    return t_info.resident_size;
-
-#elif defined(WIN32)
-    // According to MSDN...
-    PROCESS_MEMORY_COUNTERS counters;
-    if (GetProcessMemoryInfo (GetCurrentProcess(), &counters, sizeof (counters)))
-        return counters.PagefileUsage;
-    else return 0;
-
-#else
-    return 0;
-#endif
-}
-
-long SystemToolkit::memory_max_usage() {
-
-    struct rusage r_usage;
-    getrusage(RUSAGE_SELF,&r_usage);
-    return r_usage.ru_maxrss;
-//    return r_usage.ru_isrss;
-}
-
-string SystemToolkit::byte_to_string(long b)
-{
-    double numbytes = static_cast<double>(b);
-    ostringstream oss;
-
-    std::list<std::string> list = {" Bytes", " KB", " MB", " GB", " TB"};
-    std::list<std::string>::iterator i = list.begin();
-
-    while(numbytes >= 1024.0 && i != list.end())
-    {
-        i++;
-        numbytes /= 1024.0;
-    }
-    oss << std::fixed << std::setprecision(2) << numbytes << *i;
-    return oss.str();
-}
-
-
-string SystemToolkit::date_time_string()
-{
-    chrono::system_clock::time_point now = chrono::system_clock::now();
-    time_t t = chrono::system_clock::to_time_t(now);
-    tm* datetime = localtime(&t);
-
-    auto duration = now.time_since_epoch();
-    auto millis = chrono::duration_cast<chrono::milliseconds>(duration).count() % 1000;
-
-    ostringstream oss;
-    oss << setw(4) << setfill('0') << to_string(datetime->tm_year + 1900);
-    oss << setw(2) << setfill('0') << to_string(datetime->tm_mon + 1);
-    oss << setw(2) << setfill('0') << to_string(datetime->tm_mday );
-    oss << setw(2) << setfill('0') << to_string(datetime->tm_hour );
-    oss << setw(2) << setfill('0') << to_string(datetime->tm_min );
-    oss << setw(2) << setfill('0') << to_string(datetime->tm_sec );
-    oss << setw(3) << setfill('0') << to_string(millis);
-
-    // fixed length string (17 chars) YYYYMMDDHHmmssiii
-    return oss.str();
-}
-
-string SystemToolkit::filename(const string& path)
-{
-    return path.substr(path.find_last_of(PATH_SEP) + 1);
-}
-
-string SystemToolkit::base_filename(const string& path)
-{
-    string basefilename = SystemToolkit::filename(path);
-    const size_t period_idx = basefilename.rfind('.');
-    if (string::npos != period_idx)
-    {
-        basefilename.erase(period_idx);
-    }
-    return basefilename;
-}
-
-string SystemToolkit::path_filename(const string& path)
-{
-    return path.substr(0, path.find_last_of(PATH_SEP) + 1);
-}
-
-string SystemToolkit::trunc_filename(const string& path, int lenght)
-{
-    string trunc = path;
-    int l = path.size();
-    if ( l > lenght ) {
-        trunc = string("...") + path.substr( l - lenght + 3 );
-    }
-    return trunc;
-}
-
-string SystemToolkit::extension_filename(const string& filename)
-{
-    string ext = filename.substr(filename.find_last_of(".") + 1);
-    return ext;
-}
-
-std::string SystemToolkit::home_path()
-{
-    // 1. find home
-    char *mHomePath;
-    // try the system user info
-    struct passwd* pwd = getpwuid(getuid());
-    if (pwd)
-        mHomePath = pwd->pw_dir;
-    else
-        // try the $HOME environment variable
-        mHomePath = getenv("HOME");
-
-    return string(mHomePath) + PATH_SEP;
-}
-
-std::string SystemToolkit::username()
-{
-    // 1. find home
-    char *user;
-    // try the system user info
-    struct passwd* pwd = getpwuid(getuid());
-    if (pwd)
-        user = pwd->pw_name;
-    else
-        // try the $USER environment variable
-        user = getenv("USER");
-
-    return string(user);
-}
-
-bool create_directory(const string& path)
-{
-    return !mkdir(path.c_str(), 0755) || errno == EEXIST;
-
-    // TODO : verify WIN32 implementation
-}
-
-string SystemToolkit::settings_path()
-{
-    string home(home_path());
-
-    // 2. try to access user settings folder
-    string settingspath = home + PATH_SETTINGS;
-    if (SystemToolkit::file_exists(settingspath)) {
-        // good, we have a place to put the settings file
-        // settings should be in 'vmix' subfolder
-        settingspath += APP_NAME;
-
-        // 3. create the vmix subfolder in settings folder if not existing already
-        if ( !SystemToolkit::file_exists(settingspath)) {
-            if ( !create_directory(settingspath) )
-                // fallback to home if settings path cannot be created
-                settingspath = home;
-        }
-
-        return settingspath;
-    }
-    else {
-        // fallback to home if settings path does not exists
-        return home;
-    }
-}
-
-string SystemToolkit::full_filename(const std::string& path, const string &filename)
-{
-    string fullfilename = path;
-    fullfilename += PATH_SEP;
-    fullfilename += filename;
-
-    return fullfilename;
-}
-
-bool SystemToolkit::file_exists(const string& path)
-{
-    if (path.empty())
-        return false;
-
-    return access(path.c_str(), R_OK) == 0;
-
-    // TODO : WIN32 implementation
-}
-
-list<string> SystemToolkit::list_directory(const string& path, const string& filter)
-{
-    list<string> ls;
-
-    DIR *dir;
-    struct dirent *ent;
-    if ((dir = opendir (path.c_str())) != NULL) {
-      // list all the files and directories within directory
-      while ((ent = readdir (dir)) != NULL) {
-          if ( ent->d_type == DT_REG)
-          {
-              string filename = string(ent->d_name);
-              if ( extension_filename(filename) == filter)
-                  ls.push_back( full_filename(path, filename) );
-          }
-      }
-      closedir (dir);
-    }
-
-    return ls;
-}
-
-void SystemToolkit::open(const string& url)
-{
-#ifdef WIN32
-        ShellExecuteA( nullptr, nullptr, url.c_str(), nullptr, nullptr, 0 );
-#elif defined APPLE
-        char buf[2048];
-        sprintf( buf, "open '%s'", url.c_str() );
-        system( buf );
-#else
-        char buf[2048];
-        sprintf( buf, "xdg-open '%s'", url.c_str() );
-        int r = system( buf );
-#endif
-}
-
-
-

SystemToolkit.h

@@ -1,62 +0,0 @@
-#ifndef SYSTEMTOOLKIT_H
-#define SYSTEMTOOLKIT_H
-
-#ifdef WIN32
-#define PATH_SEP '\\'
-#elif defined(LINUX) or defined(APPLE)
-#define PATH_SEP '/'
-#endif
-
-#include <string>
-#include <list>
-
-namespace SystemToolkit
-{
-    // get fixed length string (17 chars) YYYYMMDDHHmmssiii
-    std::string date_time_string();
-
-    // get the OS dependent username
-    std::string username();
-
-    // get the OS dependent home path
-    std::string home_path();
-
-    // get the OS dependent path where to store settings
-    std::string settings_path();
-
-    // builds the OS dependent complete file name
-    std::string full_filename(const std::string& path, const std::string& filename);
-
-    // extract the filename from a full path / URI (e.g. file:://home/me/toto.mpg -> toto.mpg)
-    std::string filename(const std::string& path);
-
-    // extract the base filename from a full path / URI (e.g. file:://home/me/toto.mpg -> toto)
-    std::string base_filename(const std::string& path);
-
-    // extract the path of a filename from a full URI (e.g. file:://home/me/toto.mpg -> file:://home/me/)
-    std::string path_filename(const std::string& path);
-
-    // Truncate a full filename to display the right part (e.g. file:://home/me/toto.mpg -> ...ome/me/toto.mpg)
-    std::string trunc_filename(const std::string& path, int lenght);
-
-    // extract the extension of a filename
-    std::string extension_filename(const std::string& filename);
-
-    // list all files of a directory mathing the given filter extension (if any)
-    std::list<std::string> list_directory(const std::string& path, const std::string& filter = "");
-
-    // true of file exists
-    bool file_exists(const std::string& path);
-
-    // try to open the file with system
-    void open(const std::string& path);
-
-    // return memory resident set size used (in bytes)
-    long memory_usage();
-    long memory_max_usage();
-
-    // get a string to display memory size with unit KB, MB, GB, TB
-    std::string byte_to_string(long b);
-}
-
-#endif // SYSTEMTOOLKIT_H

UpdateCallback.cpp

@@ -1,87 +0,0 @@
-#include "UpdateCallback.h"
-
-#include "defines.h"
-#include "Scene.h"
-#include "Log.h"
-
-#include <glm/gtc/type_ptr.hpp>
-
-UpdateCallback::UpdateCallback() : enabled_(true), finished_(false)
-{
-
-}
-
-MoveToCallback::MoveToCallback(glm::vec3 target, float duration) : UpdateCallback(),
-    target_(target), duration_(duration), progress_(0.f), initialized_(false)
-{
-
-}
-
-void MoveToCallback::update(Node *n, float dt)
-{
-    // set start position on first run or upon call of reset()
-    if (!initialized_){
-        startingpoint_ = n->translation_;
-        target_.z = startingpoint_.z; // ignore depth
-        initialized_ = true;
-    }
-
-    // calculate amplitude of movement
-    progress_ += dt / duration_;
-
-    // perform movement
-    n->translation_ = startingpoint_ + progress_ * (target_ - startingpoint_);
-
-    // end of movement
-    if ( progress_ > 1.f ) {
-        n->translation_ = target_;
-        finished_ = true;
-    }
-}
-
-BounceScaleCallback::BounceScaleCallback(float duration) : UpdateCallback(),
-    duration_(duration), progress_(0.f), initialized_(false)
-{
-
-}
-
-void BounceScaleCallback::update(Node *n, float dt)
-{
-    // set start scale on first run or upon call of reset()
-    if (!initialized_){
-        initial_scale_ = n->scale_;
-        initialized_ = true;
-    }
-
-    // calculate amplitude of movement
-    progress_ += dt / duration_;
-
-    n->scale_.x = initial_scale_.x + (initial_scale_.x * 0.05f) * sin(M_PI * progress_);
-    n->scale_.y = initial_scale_.y + (initial_scale_.y * 0.05f) * sin(M_PI * progress_);
-
-    // end of movement
-    if ( progress_ > 1.f) {
-        n->scale_ = initial_scale_;
-        finished_ = true;
-    }
-}
-InfiniteGlowCallback::InfiniteGlowCallback(float amplitude) : UpdateCallback(),
-    amplitude_(amplitude), time_(0.f), initialized_(false)
-{
-
-}
-
-void InfiniteGlowCallback::update(Node *n, float dt)
-{
-    // set start scale on first run
-    if (!initialized_){
-        initial_scale_ = n->scale_;
-        initialized_ = true;
-    }
-
-    time_ += dt / 600.f;
-
-    n->scale_.x = initial_scale_.x + amplitude_ * sin(M_PI * time_);
-    n->scale_.y = initial_scale_.y + amplitude_ * sin(M_PI * time_);
-
-}

UserInterfaceManager.h

@@ -1,172 +0,0 @@
-#ifndef __UI_MANAGER_H_
-#define __UI_MANAGER_H_
-
-#include <string>
-#include <list>
-using namespace std;
-
-#define NAV_COUNT 68
-#define NAV_MAX 64
-#define NAV_NEW 65
-#define NAV_MENU 66
-#define NAV_TRANS 67
-
-struct ImVec2;
-class Source;
-class MediaPlayer;
-
-class SourcePreview {
-
-    Source *source_;
-    std::string label_;
-
-public:
-    SourcePreview();
-
-    void setSource(Source *s = nullptr, std::string label = "");
-    Source *getSource();
-
-    void Render(float width, bool controlbutton = false);
-    inline bool ready() const { return source_ != nullptr; }
-};
-
-class Navigator
-{
-    // geometry left bar & pannel
-    float width_;
-    float height_;
-    float pannel_width_;
-    float sourcelist_height_;
-    float padding_width_;
-
-    // behavior pannel
-    bool pannel_visible_;
-    bool selected_button[NAV_COUNT];
-    void clearButtonSelection();
-    void applyButtonSelection(int index);
-
-    // side pannels
-    void RenderSourcePannel(Source *s);
-    void RenderMainPannel();
-    void RenderTransitionPannel();
-    void RenderNewPannel();
-    int new_source_type_;
-    char file_browser_path_[2048];
-
-    SourcePreview new_source_preview_;
-
-public:
-    Navigator();
-
-    bool pannelVisible() { return pannel_visible_; }
-    void hidePannel();
-    void showPannelSource(int index);
-    void togglePannelMenu();
-    void togglePannelNew();
-
-
-    void Render();
-};
-
-class ToolBox
-{
-    bool show_demo_window;
-    bool show_icons_window;
-
-public:
-    ToolBox();
-
-    void Render();
-};
-
-
-class MediaController
-{
-    MediaPlayer *mp_;
-    std::string current_;
-    bool follow_active_source_;
-    bool media_playing_mode_;
-    bool slider_pressed_;
-
-public:
-    MediaController();
-
-    void setMediaPlayer(MediaPlayer *mp = nullptr);
-    void followCurrentSource();
-
-    void Render();
-};
-
-class UserInterface
-{
-    friend class Navigator;
-    Navigator navigator;
-    ToolBox toolbox;
-    MediaController mediacontrol;
-
-    bool keyboard_modifier_active;
-    bool show_about;
-    bool show_imgui_about;
-    bool show_gst_about;
-    bool show_opengl_about;
-    unsigned int screenshot_step;
-
-
-//    typedef enum {
-//        FILE_DIALOG_INACTIVE = 0,
-//        FILE_DIALOG_ACTIVE,
-//        FILE_DIALOG_FINISHED
-//    } FileDialogStatus;
-//    FileDialogStatus filestatus_;
-//    std::string filename_;
-//    void startOpenFileDialog();
-
-    // Private Constructor
-    UserInterface();
-    UserInterface(UserInterface const& copy);            // Not Implemented
-    UserInterface& operator=(UserInterface const& copy); // Not Implemented
-
-public:
-
-    static UserInterface& manager()
-    {
-        // The only instance
-        static UserInterface _instance;
-        return _instance;
-    }
-
-    // pre-loop initialization
-    bool Init();
-    // loop update start new frame
-    void NewFrame();
-    // loop update rendering
-    void Render();
-    // Post-loop termination
-    void Terminate();
-
-    // status querries
-    inline bool keyboardModifier() { return keyboard_modifier_active; }
-
-    void StartScreenshot();
-    void showPannel(int id = 0);
-
-    void showMediaPlayer(MediaPlayer *mp);
-
-    // TODO implement the shader editor
-    std::string currentTextEdit;
-    void fillShaderEditor(std::string text);
-
-protected:
-
-    void showMenuFile();
-    void showMenuOptions();
-
-    void RenderPreview();
-    void RenderShaderEditor();
-    void handleKeyboard();
-    void handleMouse();
-    void handleScreenshot();
-};
-
-#endif /* #define __UI_MANAGER_H_ */
-

View.h

@@ -1,186 +0,0 @@
-#ifndef VIEW_H
-#define VIEW_H
-
-#include <glm/glm.hpp>
-
-#include "Scene.h"
-#include "FrameBuffer.h"
-class Source;
-class SessionSource;
-class Surface;
-
-class View
-{
-public:
-
-    typedef enum {RENDERING = 0, MIXING=1, GEOMETRY=2, LAYER=3,  TRANSITION=4, INVALID=5 } Mode;
-
-    View(Mode m);
-    virtual ~View() {}
-
-    inline Mode mode() const { return mode_; }
-
-    virtual void update (float dt);
-    virtual void draw ();
-
-    virtual void zoom (float) {}
-    virtual void centerSource(Source *) {}
-
-    typedef enum {
-        Cursor_Arrow = 0,
-        Cursor_TextInput,
-        Cursor_ResizeAll,
-        Cursor_ResizeNS,
-        Cursor_ResizeEW,
-        Cursor_ResizeNESW,
-        Cursor_ResizeNWSE,
-        Cursor_Hand,
-        Cursor_NotAllowed
-    } CursorType;
-
-    typedef struct Cursor {
-        CursorType type;
-        std::string info;
-        Cursor() { type = Cursor_Arrow; info = "";}
-        Cursor(CursorType t, std::string i = "") { type = t; info = i;}
-    } Cursor;
-
-    // picking of nodes in a view provided a point coordinates in screen coordinates
-    virtual std::pair<Node *, glm::vec2> pick(glm::vec2);
-
-    // select sources provided a start and end selection points in screen coordinates
-    virtual void select(glm::vec2, glm::vec2);
-    virtual void selectAll();
-
-    // drag the view provided a start and an end point in screen coordinates
-    virtual Cursor drag (glm::vec2, glm::vec2);
-
-    // grab a source provided a start and an end point in screen coordinates and the picking point
-    virtual Cursor grab (Source*, glm::vec2, glm::vec2, std::pair<Node *, glm::vec2>) {
-        return Cursor();
-    }
-
-    // test mouse over provided a point in screen coordinates and the picking point
-    virtual Cursor over (Source*, glm::vec2, std::pair<Node *, glm::vec2>) {
-        return Cursor();
-    }
-
-    virtual void initiate();
-    virtual void recenter();
-
-    // accessible scene
-    Scene scene;
-
-    // reordering scene when necessary
-    static bool need_deep_update_;
-
-protected:
-
-    virtual void restoreSettings();
-    virtual void saveSettings();
-
-    Mode mode_;
-};
-
-
-class MixingView : public View
-{
-public:
-    MixingView();
-
-    void zoom (float factor) override;
-    void centerSource(Source *) override;
-
-    void selectAll() override;
-    Cursor grab (Source *s, glm::vec2 from, glm::vec2 to, std::pair<Node *, glm::vec2>) override;
-    Cursor drag (glm::vec2, glm::vec2) override;
-
-    void setAlpha (Source *s);
-    inline float limboScale() { return limbo_scale_; }
-
-private:
-    uint textureMixingQuadratic();
-    float limbo_scale_;
-};
-
-class RenderView : public View
-{
-    FrameBuffer *frame_buffer_;
-    Surface *fading_overlay_;
-
-public:
-    RenderView ();
-    ~RenderView ();
-
-    void draw () override;
-
-    void setResolution (glm::vec3 resolution = glm::vec3(0.f));
-    glm::vec3 resolution() const { return frame_buffer_->resolution(); }
-
-    void setFading(float f = 0.f);
-    float fading() const;
-
-    inline FrameBuffer *frame () const { return frame_buffer_; }
-};
-
-class GeometryView : public View
-{
-public:
-    GeometryView();
-
-    void draw () override;
-    void update (float dt) override;
-    void zoom (float factor) override;
-    std::pair<Node *, glm::vec2> pick(glm::vec2 P) override;
-    Cursor grab (Source *s, glm::vec2 from, glm::vec2 to, std::pair<Node *, glm::vec2> pick) override;
-    Cursor over (Source *s, glm::vec2 pos, std::pair<Node *, glm::vec2> pick) override;
-    Cursor drag (glm::vec2, glm::vec2) override;
-//    void select(glm::vec2, glm::vec2) override;
-
-//    class Box *selection_box_;
-};
-
-class LayerView : public View
-{
-public:
-    LayerView();
-
-    void update (float dt) override;
-    void zoom (float factor) override;
-    Cursor grab (Source *s, glm::vec2 from, glm::vec2 to, std::pair<Node *, glm::vec2> pick) override;
-    Cursor drag (glm::vec2, glm::vec2) override;
-
-    float setDepth (Source *, float d = -1.f);
-
-private:
-    float aspect_ratio;
-};
-
-class TransitionView : public View
-{
-public:
-    TransitionView();
-
-    void attach(SessionSource *ts);
-    class Session *detach();
-
-    void play(bool open);
-
-    void draw () override;
-    void update (float dt) override;
-    void zoom (float factor) override;
-    std::pair<Node *, glm::vec2> pick(glm::vec2 P) override;
-    void selectAll() override;
-    Cursor grab (Source *s, glm::vec2 from, glm::vec2 to, std::pair<Node *, glm::vec2> pick) override;
-    Cursor drag (glm::vec2, glm::vec2) override;
-
-private:
-    class Surface *output_surface_;
-    class Mesh *mark_100ms_, *mark_1s_;
-    Switch *gradient_;
-    SessionSource *transition_source_;
-};
-
-
-
-#endif // VIEW_H

Visitor.h

@@ -1,69 +0,0 @@
-#ifndef VISITOR_H
-#define VISITOR_H
-
-#include <string>
-
-// Forward declare different kind of Node
-class Node;
-class Group;
-class Switch;
-class Primitive;
-class Scene;
-class Surface;
-class ImageSurface;
-class MediaSurface;
-class FrameBufferSurface;
-class LineStrip;
-class LineSquare;
-class LineCircle;
-class Mesh;
-class Frame;
-class Handles;
-class MediaPlayer;
-class Shader;
-class ImageShader;
-class ImageProcessingShader;
-class Source;
-class MediaSource;
-class SessionSource;
-class RenderSource;
-class CloneSource;
-
-// Declares the interface for the visitors
-class Visitor {
-
-public:
-    // Need to declare overloads for basic kind of Nodes to visit
-    virtual void visit (Scene&) = 0;
-    virtual void visit (Node&) = 0;
-    virtual void visit (Primitive&) = 0;
-    virtual void visit (Group&) = 0;
-    virtual void visit (Switch&) = 0;
-
-    // not mandatory for all others
-    virtual void visit (Surface&) {}
-    virtual void visit (ImageSurface&) {}
-    virtual void visit (MediaSurface&) {}
-    virtual void visit (FrameBufferSurface&) {}
-    virtual void visit (LineStrip&)  {}
-    virtual void visit (LineSquare&) {}
-    virtual void visit (LineCircle&) {}
-    virtual void visit (Mesh&) {}
-    virtual void visit (Frame&) {}
-    virtual void visit (Handles&) {}
-    virtual void visit (MediaPlayer&) {}
-    virtual void visit (Shader&) {}
-    virtual void visit (ImageShader&) {}
-    virtual void visit (ImageProcessingShader&) {}
-
-    // utility
-    virtual void visit (Source&) {}
-    virtual void visit (MediaSource&) {}
-    virtual void visit (SessionSource&) {}
-    virtual void visit (RenderSource&) {}
-    virtual void visit (CloneSource&) {}
-
-};
-
-
-#endif // VISITOR_H

_config.yml

@@ -0,0 +1 @@
+theme: jekyll-theme-midnight

cmake/modules/BundleInstall.cmake.in

@@ -0,0 +1,41 @@
+set(BUNDLE_NAME @BUNDLE_NAME@)
+set(BUNDLE_LIBS_DIR @BUNDLE_LIBS_DIR@)
+set(BUNDLE_DIRS @BUNDLE_DIRS@)
+set(APPLE_CODESIGN_IDENTITY @APPLE_CODESIGN_IDENTITY@)
+set(APPLE_CODESIGN_ENTITLEMENTS @APPLE_CODESIGN_ENTITLEMENTS@)
+
+set(BUNDLE_PATH "${CMAKE_INSTALL_PREFIX}/${BUNDLE_NAME}")
+
+include(BundleUtilities)
+
+#fixup_bundle tries to copy system libraries without this. Wtf?
+function(gp_resolved_file_type_override file type)
+  if(file MATCHES "^(/usr/lib)")
+    set(type "system" PARENT_SCOPE)
+  endif()
+endfunction()
+
+file(GLOB_RECURSE BUNDLE_LIBS "${CMAKE_INSTALL_PREFIX}/${BUNDLE_LIBS_DIR}/*.dylib")
+
+set(BU_CHMOD_BUNDLE_ITEMS ON)
+fixup_bundle("${BUNDLE_PATH}" "${BUNDLE_LIBS}" "${BUNDLE_DIRS}")
+
+if(DEFINED APPLE_CODESIGN_IDENTITY AND DEFINED APPLE_CODESIGN_ENTITLEMENTS)
+#  execute_process(COMMAND
+#      codesign --verbose=4 --deep --force --options runtime
+#      --entitlements "${APPLE_CODESIGN_ENTITLEMENTS}"
+#      --sign "${APPLE_CODESIGN_IDENTITY}"
+#      "${BUNDLE_NAME}"
+#  )
+  foreach(PATH_TO_SIGN IN LISTS BUNDLE_LIBS BUNDLE_PATH)
+    execute_process(COMMAND
+        codesign --verbose=4 --deep --force
+        --entitlements "${APPLE_CODESIGN_ENTITLEMENTS}"
+        --sign "${APPLE_CODESIGN_IDENTITY}"
+        "${PATH_TO_SIGN}"
+    )
+  endforeach()
+else()
+  message(STATUS "Not signing bundle. Specify -DAPPLE_CODESIGN_IDENTITY and -DAPPLE_CODESIGN_ENTITLEMENTS to cmake before running cpack to sign")
+endif()
+

cmake/modules/FindGStreamerPluginsBad.cmake

@@ -0,0 +1,76 @@
+# - Try to find gst-plugins-base
+# Once done this will define
+#
+#  GSTREAMER_PLUGINS_BASE_FOUND - system has gst-plugins-base
+#
+#  And for all the plugin libraries specified in the COMPONENTS
+#  of find_package, this module will define:
+#
+#  GSTREAMER_<plugin_lib>_LIBRARY_FOUND - system has <plugin_lib>
+#  GSTREAMER_<plugin_lib>_LIBRARY - the <plugin_lib> library
+#  GSTREAMER_<plugin_lib>_INCLUDE_DIR - the <plugin_lib> include directory
+#
+# Copyright (c) 2010, Collabora Ltd.
+#   @author George Kiagiadakis <george.kiagiadakis@collabora.co.uk>
+#
+# Redistribution and use is allowed according to the terms of the BSD license.
+# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
+
+set(GSTREAMER_ABI_VERSION "1.0")
+
+
+# Find the pkg-config file for doing the version check
+find_package(PkgConfig)
+
+if (PKG_CONFIG_FOUND)
+    pkg_check_modules(PKG_GSTREAMER_PLUGINS_BAD gstreamer-plugins-bad-${GSTREAMER_ABI_VERSION})
+endif()
+
+
+# Find the plugin libraries
+include(MacroFindGStreamerLibrary)
+
+macro(_find_gst_plugins_bad_component _name _header)
+    find_gstreamer_library(${_name} ${_header} ${GSTREAMER_ABI_VERSION})
+    set(_GSTREAMER_PLUGINS_BAD_EXTRA_VARIABLES ${_GSTREAMER_PLUGINS_BAD_EXTRA_VARIABLES}
+                                        GSTREAMER_${_name}_LIBRARY GSTREAMER_${_name}_INCLUDE_DIR)
+endmacro()
+
+foreach(_component ${GStreamerPluginsBad_FIND_COMPONENTS})
+    if (${_component} STREQUAL "player")
+        _find_gst_plugins_bad_component(PLAYER gstplayer.h)
+    elseif (${_component} STREQUAL "webrtc")
+        _find_gst_plugins_bad_component(WEBRTC webrtc.h)
+    elseif (${_component} STREQUAL "srtsrc")
+        _find_gst_plugins_bad_component(SRTSRC mpegts.h)
+    else()
+        message (AUTHOR_WARNING "FindGStreamerPluginBad.cmake: Invalid component \"${_component}\" was specified")
+    endif()
+endforeach()
+
+get_filename_component(_GSTREAMER_BAD_LIB_DIR ${GSTREAMER_PLAYER_LIBRARY} PATH)
+set(PKG_GSTREAMER_BAD_PLUGIN_DIR ${_GSTREAMER_BAD_LIB_DIR}/gstreamer-${GSTREAMER_ABI_VERSION})
+
+# Version check
+if (GStreamerPluginsBad_FIND_VERSION)
+    if (PKG_GSTREAMER_PLUGINS_BAD_FOUND)
+        if("${PKG_GSTREAMER_PLUGINS_BAD_VERSION}" VERSION_LESS "${GStreamerPluginsBad_FIND_VERSION}")
+            message(STATUS "Found gst-plugins-base version ${PKG_GSTREAMER_PLUGINS_BAD_VERSION}, but at least version ${GStreamerPluginsBad_FIND_VERSION} is required")
+            set(GSTREAMER_PLUGINS_BAD_VERSION_COMPATIBLE FALSE)
+        else()
+            set(GSTREAMER_PLUGINS_BAD_VERSION_COMPATIBLE TRUE)
+        endif()
+    else()
+        # We can't make any version checks without pkg-config, just assume version is compatible and hope...
+        set(GSTREAMER_PLUGINS_BAD_VERSION_COMPATIBLE TRUE)
+    endif()
+else()
+    # No version constrain was specified, thus we consider the version compatible
+    set(GSTREAMER_PLUGINS_BAD_VERSION_COMPATIBLE TRUE)
+endif()
+
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(GStreamerPluginsBad DEFAULT_MSG
+                                  GSTREAMER_PLUGINS_BAD_VERSION_COMPATIBLE
+                                  ${_GSTREAMER_PLUGINS_BAD_EXTRA_VARIABLES})

cmake/modules/FindGStreamerPluginsBase.cmake

@@ -64,6 +64,8 @@ foreach(_component ${GStreamerPluginsBase_FIND_COMPONENTS})
     endif()
 endforeach()
 
+get_filename_component(_GSTREAMER_BASE_LIB_DIR ${GSTREAMER_APP_LIBRARY} PATH)
+set(PKG_GSTREAMER_BASE_PLUGIN_DIR ${_GSTREAMER_BASE_LIB_DIR}/gstreamer-${GSTREAMER_ABI_VERSION})
 
 # Version check
 if (GStreamerPluginsBase_FIND_VERSION)

cmake/modules/FindGTK.cmake

@@ -0,0 +1,147 @@
+# - Try to find GTK+ 3.x or 4.x
+#
+# Copyright (C) 2012 Raphael Kubo da Costa <rakuco@webkit.org>
+# Copyright (C) 2013, 2015, 2020 Igalia S.L.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+# 1.  Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+# 2.  Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND ITS CONTRIBUTORS ``AS
+# IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR ITS
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#[=======================================================================[.rst:
+FindGTK
+-------
+
+Find GTK headers and libraries.
+
+Optional Components
+^^^^^^^^^^^^^^^^^^^
+
+The ``COMPONENTS`` (or ``OPTIONAL_COMPONENTS``) keyword can be passed to
+``find_package()``, the following GTK components can be searched for:
+
+- ``unix-print``
+
+
+Imported Targets
+^^^^^^^^^^^^^^^^
+
+``GTK::GTK``
+  The GTK library, if found.
+``GTK::UnixPrint``
+  The GTK unix-print library, if found.
+
+Result Variables
+^^^^^^^^^^^^^^^^
+
+This will define the following variables in your project:
+
+``GTK_FOUND``
+  true if (the requested version of) GTK is available.
+``GTK_UNIX_PRINT_FOUND``
+  true if the ``unix-print`` component is available.
+``GTK_4``
+  whether GTK 4 was detected
+``GTK_3``
+  whether GTK 3 was detected
+``GTK_VERSION``
+  the version of GTK.
+``GTK_SUPPORTS_BROADWAY``
+  true if the Broadway target is built into GTK.
+``GTK_SUPPORTS_QUARTZ``
+  true if the Quartz target is built into GTK.
+``GTK_SUPPORTS_WAYLAND``
+  true if the Wayland target is built into GTK.
+``GTK_SUPPORTS_WIN32``
+  true if the Windows target is built into GTK.
+``GTK_SUPPORTS_X11``
+  true if the X11 target is built into GTK.
+
+#]=======================================================================]
+
+
+if (GTK_FIND_VERSION VERSION_LESS 3.90)
+    set(GTK_PC_MODULE "gtk+-3.0")
+    set(GTK_PC_UNIX_PRINT_MODULE "gtk+-unix-print-3.0")
+    set(GTK_4 FALSE)
+    set(GTK_3 TRUE)
+else ()
+    set(GTK_PC_MODULE "gtk4")
+    set(GTK_PC_UNIX_PRINT_MODULE "gtk4-unix-print")
+    set(GTK_4 TRUE)
+    set(GTK_3 FALSE)
+endif ()
+
+find_package(PkgConfig QUIET)
+pkg_check_modules(GTK IMPORTED_TARGET ${GTK_PC_MODULE})
+
+set(GTK_VERSION_OK TRUE)
+if (GTK_VERSION)
+    if (GTK_FIND_VERSION_EXACT)
+        if (NOT("${GTK_FIND_VERSION}" VERSION_EQUAL "${GTK_VERSION}"))
+            set(GTK_VERSION_OK FALSE)
+        endif ()
+    else ()
+        if ("${GTK_VERSION}" VERSION_LESS "${GTK_FIND_VERSION}")
+            set(GTK_VERSION_OK FALSE)
+        endif ()
+    endif ()
+endif ()
+
+# Set all the GTK_SUPPORTS_<target> variables to FALSE initially.
+foreach (gtk_target broadway quartz wayland win32 x11)
+    string(TOUPPER "GTK_SUPPORTS_${gtk_target}" gtk_target)
+    set(${gtk_target} FALSE)
+endforeach ()
+
+if (GTK_VERSION AND GTK_VERSION_OK)
+    # Fetch the "targets" variable and set GTK_SUPPORTS_<target>.
+    pkg_get_variable(GTK_TARGETS ${GTK_PC_MODULE} targets)
+    separate_arguments(GTK_TARGETS)
+    foreach (gtk_target ${GTK_TARGETS})
+        string(TOUPPER "GTK_SUPPORTS_${gtk_target}" gtk_target)
+        set(${gtk_target} TRUE)
+    endforeach ()
+endif ()
+
+if (TARGET PkgConfig::GTK AND NOT TARGET GTK::GTK)
+    add_library(GTK::GTK INTERFACE IMPORTED GLOBAL)
+    set_property(TARGET GTK::GTK PROPERTY
+        INTERFACE_LINK_LIBRARIES PkgConfig::GTK
+    )
+endif ()
+
+# Try to find additional components
+foreach (gtk_component ${GTK_FIND_COMPONENTS})
+    if (NOT "${gtk_component}" STREQUAL unix-print)
+        message(FATAL_ERROR "Invalid component name: ${gtk_component}")
+    endif ()
+    pkg_check_modules(GTK_UNIX_PRINT IMPORTED_TARGET "${GTK_PC_UNIX_PRINT_MODULE}")
+    if (GTK_FIND_REQUIRED_unix-print AND NOT GTK_UNIX_PRINT_FOUND)
+        message(FATAL_ERROR "Component unix-print not found")
+    endif ()
+    if (TARGET PkgConfig::GTK_UNIX_PRINT AND NOT TARGET GTK::UnixPrint)
+        add_library(GTK::UnixPrint INTERFACE IMPORTED GLOBAL)
+        set_property(TARGET GTK::UnixPrint PROPERTY
+            INTERFACE_LINK_LIBRARIES PkgConfig::GTK_UNIX_PRINT)
+    endif ()
+endforeach ()
+
+include(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(GTK DEFAULT_MSG GTK_VERSION GTK_VERSION_OK)

defines.h

@@ -1,102 +0,0 @@
-#ifndef VMIX_DEFINES_H
-#define VMIX_DEFINES_H
-
-#define APP_NAME "vimix"
-#define APP_TITLE " -- Video Live Mixer"
-#define APP_SETTINGS "vimix.xml"
-#define APP_VERSION_MAJOR 0
-#define APP_VERSION_MINOR 1
-#define XML_VERSION_MAJOR 0
-#define XML_VERSION_MINOR 1
-#define MAX_RECENT_HISTORY 20
-
-#define MINI(a, b)  (((a) < (b)) ? (a) : (b))
-#define MAXI(a, b)  (((a) > (b)) ? (a) : (b))
-#define ABS(a)	   (((a) < 0) ? -(a) : (a))
-#define ABS_DIFF(a, b) ( (a) < (b) ? (b - a) : (a - b) )
-#define SIGN(a)	   (((a) < 0) ? -1.0 : 1.0)
-#define SQUARE(a)	   ((a) * (a))
-#define CLAMP(x, low, high)  (((x) > (high)) ? (high) : (((x) < (low)) ? (low) : (x)))
-#define EPSILON 0.00001
-#define LOG100(val) (50.0/log(10.0)*log((float)val + 1.0))
-#define EXP100(val) (exp(log(10.0)/50.0*(float)(val))-1.0)
-#define EUCLIDEAN(P1, P2) sqrt((P1.x() - P2.x()) * (P1.x() - P2.x()) + (P1.y() - P2.y()) * (P1.y() - P2.y()))
-
-#define SCENE_UNIT 5.f
-#define SCENE_DEPTH 12.f
-#define CIRCLE_SQUARE_DIST(x,y) ( (x*x + y*y) / (SCENE_UNIT * SCENE_UNIT * SCENE_UNIT * SCENE_UNIT) )
-#define MIN_SCALE 0.01f
-#define MAX_SCALE 10.f
-#define CLAMP_SCALE(x) SIGN(x) * CLAMP( ABS(x), MIN_SCALE, MAX_SCALE)
-#define MIXING_DEFAULT_SCALE 2.4f
-#define MIXING_MIN_SCALE 0.8f
-#define MIXING_MAX_SCALE 7.0f
-#define GEOMETRY_DEFAULT_SCALE 1.2f
-#define GEOMETRY_MIN_SCALE 0.2f
-#define GEOMETRY_MAX_SCALE 10.0f
-#define LAYER_DEFAULT_SCALE 0.8f
-#define LAYER_MIN_SCALE 0.4f
-#define LAYER_MAX_SCALE 1.7f
-#define TRANSITION_DEFAULT_SCALE 3.0f
-#define TRANSITION_MIN_DURATION 0.2f
-#define TRANSITION_MAX_DURATION 10.f
-
-#define IMGUI_TITLE_MAINWINDOW ICON_FA_CIRCLE_NOTCH "  vimix"
-#define IMGUI_TITLE_MEDIAPLAYER ICON_FA_FILM "  Media Player"
-#define IMGUI_TITLE_TOOLBOX ICON_FA_WRENCH "  Tools"
-#define IMGUI_TITLE_SHADEREDITOR ICON_FA_CODE "  Shader Editor"
-#define IMGUI_TITLE_PREVIEW ICON_FA_DESKTOP "  Preview"
-#define IMGUI_TITLE_DELETE ICON_FA_BROOM " Delete?"
-#define IMGUI_LABEL_RECENT_FILES " Recent files"
-#define IMGUI_RIGHT_ALIGN -3.5f * ImGui::GetTextLineHeightWithSpacing()
-#define IMGUI_NOTIFICATION_DURATION 1.5f
-#ifdef APPLE
-#define CTRL_MOD "Cmd+"
-#else
-#define CTRL_MOD "Ctrl+"
-#endif
-
-#define COLOR_BGROUND 0.2f, 0.2f, 0.2f
-#define COLOR_NAVIGATOR 0.1f, 0.1f, 0.1f
-#define COLOR_DEFAULT_SOURCE 0.8f, 0.8f, 0.8f
-#define COLOR_HIGHLIGHT_SOURCE 1.f, 1.f, 1.f
-#define COLOR_TRANSITION_SOURCE 1.f, 0.5f, 1.f
-#define COLOR_TRANSITION_LINES 0.9f, 0.9f, 0.9f
-#define COLOR_FRAME 0.8f, 0.f, 0.8f
-#define COLOR_LIMBO_CIRCLE 0.16f, 0.16f, 0.16f
-
-// from glmixer
-#define TEXTURE_REQUIRED_MAXIMUM 2048
-#define CATALOG_TEXTURE_HEIGHT 96
-#define SELECTBUFSIZE 512
-#define CIRCLE_SIZE 8.0
-#define DEFAULT_LIMBO_SIZE 1.5
-#define MIN_LIMBO_SIZE 1.1
-#define MAX_LIMBO_SIZE 3.0
-#define DEFAULT_ICON_SIZE 1.75
-#define MIN_ICON_SIZE 1.0
-#define MAX_ICON_SIZE 2.5
-#define MIN_DEPTH_LAYER 0.0
-#define MAX_DEPTH_LAYER 40.0
-#define DEPTH_EPSILON 0.1
-#define DEPTH_DEFAULT_SPACING 1.0
-#define BORDER_SIZE 0.4
-#define CENTER_SIZE 1.2
-#define PROPERTY_DECIMALS 8
-#define COLOR_SOURCE 230, 230, 0
-#define COLOR_SOURCE_STATIC 230, 40, 40
-#define COLOR_SELECTION 10, 210, 40
-#define COLOR_SELECTION_AREA 50, 210, 50
-#define COLOR_CIRCLE 210, 30, 210
-#define COLOR_CIRCLE_MOVE 230, 30, 230
-#define COLOR_DRAWINGS 180, 180, 180
-#define COLOR_LIMBO 35, 35, 35
-//#define COLOR_LIMBO_CIRCLE 210, 160, 210
-#define COLOR_FADING 25, 25, 25
-#define COLOR_FLASHING 250, 250, 250
-#define COLOR_FRAME_MOVE 230, 30, 230
-#define COLOR_CURSOR 10, 100, 255
-
-
-
-#endif // VMIX_DEFINES_H

docs/_config.yml

@@ -0,0 +1,6 @@
+theme: jekyll-theme-minimal
+title: vimix
+description: Video Live Mixer
+logo: vimix_256x256.png
+show_downloads: true
+