API & Framework changes

CMakeLists.txt

@@ -53,7 +53,8 @@ INCLUDE(${CMAKE_MODULE_PATH}/Version.cmake)
 
 FIND_PACKAGE(OpenGL REQUIRED)
 FIND_PACKAGE(GLEWmx REQUIRED)
-IF(GLEWmx_FOUND AND OPENGL_FOUND)
+FIND_PACKAGE(FreeImage REQUIRED)
+IF(GLEWmx_FOUND AND OPENGL_FOUND AND FREEIMAGE_FOUND)
     ADD_DEFINITIONS(-DGLEW_MX)
 ELSE()
     IF(NOT GLEWmx_FOUND)
@@ -62,12 +63,16 @@ ELSE()
     IF(NOT OPENGL_FOUND)
         MESSAGE(FATAL_ERROR "OpenGL not found")
     ENDIF()
+    IF(NOT FREEIMAGE_FOUND)
+        MESSAGE(FATAL_ERROR "FreeImage not found")
+    ENDIF()
 ENDIF()
 
 INCLUDE_DIRECTORIES(
     "${PROJECT_SOURCE_DIR}/include"
     ${OPENGL_INCLUDE_DIR}
     ${GLEW_INCLUDE_DIR}
+    ${FREEIMAGE_INCLUDE_PATH}
     )
 
 SET(X11_LIBS "")
@@ -77,7 +82,9 @@ IF(APPLE)
     SET(X11_LIBS ${X11_LIBRARIES})
 ENDIF(APPLE)
 
-ADD_SUBDIRECTORY(src)
+ADD_EXECUTABLE(glsl2cpp "${CMAKE_MODULE_PATH}/glsl2cpp.cpp")
+
+ADD_SUBDIRECTORY(src/backend/opengl)
 
 IF(BUILD_EXAMPLES)
     ADD_SUBDIRECTORY(examples)

CMakeModules/FindFreeImage.cmake

@@ -0,0 +1,69 @@
+#
+# Try to find the FreeImage library and include path.
+# Once done this will define
+#
+# FREEIMAGE_FOUND
+# FREEIMAGE_INCLUDE_PATH
+# FREEIMAGE_LIBRARY
+# FREEIMAGE_STATIC_LIBRARY
+# FREEIMAGE_DYNAMIC_LIBRARY
+#
+
+OPTION(USE_FREEIMAGE_STATIC "Use Static FreeImage Lib" OFF)
+
+FIND_PATH( FREEIMAGE_INCLUDE_PATH
+    NAMES FreeImage.h
+    HINTS ${PROJECT_SOURCE_DIR}/extern/FreeImage
+    PATHS
+    /usr/include
+    /usr/local/include
+    /sw/include
+    /opt/local/include
+    DOC "The directory where FreeImage.h resides")
+
+FIND_LIBRARY( FREEIMAGE_DYNAMIC_LIBRARY
+    NAMES FreeImage freeimage
+    HINTS ${PROJECT_SOURCE_DIR}/FreeImage
+    PATHS
+    /usr/lib64
+    /usr/lib
+    /usr/local/lib64
+    /usr/local/lib
+    /sw/lib
+    /opt/local/lib
+    DOC "The FreeImage library")
+
+SET(PX ${CMAKE_STATIC_LIBRARY_PREFIX})
+SET(SX ${CMAKE_STATIC_LIBRARY_SUFFIX})
+FIND_LIBRARY( FREEIMAGE_STATIC_LIBRARY
+    NAMES ${PX}FreeImageLIB${SX} ${PX}FreeImage${SX} ${PX}freeimage${SX}
+    HINTS ${PROJECT_SOURCE_DIR}/FreeImage
+    PATHS
+    /usr/lib64
+    /usr/lib
+    /usr/local/lib64
+    /usr/local/lib
+    /sw/lib
+    /opt/local/lib
+    DOC "The FreeImage library")
+UNSET(PX)
+UNSET(SX)
+
+IF(USE_FREEIMAGE_STATIC)
+  MESSAGE(STATUS "Using Static FreeImage Lib")
+  ADD_DEFINITIONS(-DFREEIMAGE_LIB)
+  SET(FREEIMAGE_LIBRARY ${FREEIMAGE_STATIC_LIBRARY})
+ELSE(USE_FREEIMAGE_STATIC)
+  MESSAGE(STATUS "Using Dynamic FreeImage Lib")
+  REMOVE_DEFINITIONS(-DFREEIMAGE_LIB)
+  SET(FREEIMAGE_LIBRARY ${FREEIMAGE_DYNAMIC_LIBRARY})
+ENDIF(USE_FREEIMAGE_STATIC)
+
+MARK_AS_ADVANCED(
+    FREEIMAGE_DYNAMIC_LIBRARY
+    FREEIMAGE_STATIC_LIBRARY
+    )
+
+INCLUDE(FindPackageHandleStandardArgs)
+
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(FREEIMAGE DEFAULT_MSG FREEIMAGE_INCLUDE_PATH FREEIMAGE_LIBRARY)

CMakeModules/GLSLtoH.cmake

@@ -0,0 +1,61 @@
+# Function to turn an GLSL shader source file into a C string within a source file.
+# xxd uses its input's filename to name the string and its length, so we
+# need to move them to a name that depends only on the path output, not its
+# input.  Otherwise, builds in different relative locations would put the
+# source into different variable names, and everything would fall over.
+# The actual name will be filename (.s replaced with underscores), and length
+# name_len.
+#
+# Usage example:
+#
+# set(KERNELS a.cl b/c.cl)
+# resource_to_cxx_source(
+#   SOURCES ${KERNELS}
+#   VARNAME OUTPUTS
+# )
+# add_executable(foo ${OUTPUTS})
+#
+# The namespace they are placed in is taken from filename.namespace.
+#
+# For example, if the input file is kernel.cl, the two variables will be
+#  unsigned char ns::kernel_cl[];
+#  unsigned int ns::kernel_cl_len;
+#
+# where ns is the contents of kernel.cl.namespace.
+
+INCLUDE(CMakeParseArguments)
+
+SET(GLSL2CPP_PROGRAM "glsl2cpp")
+
+FUNCTION(GLSL_TO_H)
+    CMAKE_PARSE_ARGUMENTS(RTCS "" "VARNAME;EXTENSION;OUTPUT_DIR;TARGETS;NAMESPACE;EOF" "SOURCES" ${ARGN})
+
+    SET(_output_files "")
+    FOREACH(_input_file ${RTCS_SOURCES})
+        GET_FILENAME_COMPONENT(_path "${_input_file}" PATH)
+        GET_FILENAME_COMPONENT(_name "${_input_file}" NAME)
+        GET_FILENAME_COMPONENT(var_name "${_input_file}" NAME_WE)
+
+        SET(_namespace "${RTCS_NAMESPACE}")
+        STRING(REPLACE "." "_" var_name ${var_name})
+
+        SET(_output_path "${CMAKE_CURRENT_BINARY_DIR}/${RTCS_OUTPUT_DIR}")
+        SET(_output_file "${_output_path}/${var_name}.${RTCS_EXTENSION}")
+
+        ADD_CUSTOM_COMMAND(
+            OUTPUT ${_output_file}
+            DEPENDS ${_input_file} ${GLSL2CPP_PROGRAM}
+            COMMAND ${CMAKE_COMMAND} -E make_directory "${_output_path}"
+            COMMAND ${CMAKE_COMMAND} -E echo "\\#include \\<${_path}/${var_name}.hpp\\>"  >>"${_output_file}"
+            COMMAND ${GLSL2CPP_PROGRAM} --file ${_name} --namespace ${_namespace} --output ${_output_file} --name ${var_name} --eof ${RTCS_EOF}
+            WORKING_DIRECTORY "${_path}"
+            COMMENT "Converting ${_input_file} to GLSL source string"
+        )
+
+        LIST(APPEND _output_files ${_output_file})
+    ENDFOREACH()
+    ADD_CUSTOM_TARGET(${RTCS_NAMESPACE}_bin_target DEPENDS ${_output_files})
+
+    SET("${RTCS_VARNAME}" ${_output_files} PARENT_SCOPE)
+    SET("${RTCS_TARGETS}" ${RTCS_NAMESPACE}_bin_target PARENT_SCOPE)
+ENDFUNCTION(GLSL_TO_H)

CMakeModules/glsl2cpp.cpp

@@ -0,0 +1,184 @@
+// Umar Arshad
+// Copyright 2015-2019
+//
+// Modified by Pradeep Garigipati on Dec 30, 2015 for Forge
+// Purpose of modification: To use the program to convert
+// GLSL shader files into compile time constant string literals
+
+#include <fstream>
+#include <sstream>
+#include <iostream>
+#include <string>
+#include <vector>
+#include <map>
+#include <memory>
+
+using namespace std;
+typedef map<string, string> opt_t;
+
+static
+void print_usage() {
+    cout << R"delimiter(GLSL2CPP
+Converts OpenGL shader files to C++ headers. It is similar to bin2c and xxd but adds
+support for namespaces.
+
+| --name        | name of the variable (default: var)                               |
+| --file        | input file                                                        |
+| --output      | output file (If no output is specified then it prints to stdout)  |
+| --type        | Type of variable (default: char)                                  |
+| --namespace   | A space seperated list of namespaces                              |
+| --formatted   | Tabs for formatting                                               |
+| --version     | Prints my name                                                    |
+| --help        | Prints usage info                                                 |
+
+Example
+-------
+Command:
+./glsl2cpp --file blah.txt --namespace shaders --formatted --name image_vs
+
+Will produce the following:
+#pragma once
+#include <cstddef>
+namespace shaders {
+    static const char image_vs[] = R"shader(
+#version 330
+
+layout(location = 0) in vec3 pos;
+layout(location = 1) in vec2 tex;
+
+uniform mat4 matrix;
+
+out vec2 texcoord;
+
+void main() {
+    texcoord = tex;
+    gl_Position = matrix * vec4(pos,1.0);
+}
+    )shader";
+}
+)delimiter";
+        exit(0);
+}
+
+static bool formatted;
+
+static
+void add_tabs(const int level)
+{
+    if(formatted) {
+        for(int i =0; i < level; i++) {
+            cout << "\t";
+        }
+    }
+}
+
+static
+opt_t parse_options(const vector<string>& args)
+{
+    opt_t options;
+
+    options["--name"]       = "";
+    options["--type"]       = "";
+    options["--file"]       = "";
+    options["--output"]     = "";
+    options["--namespace"]  = "";
+    options["--eof"]        = "";
+
+    //Parse Arguments
+    string curr_opt;
+    bool verbose = false;
+    for(auto arg : args) {
+        if(arg == "--verbose") {
+            verbose = true;
+        } else if(arg == "--formatted") {
+            formatted = true;
+        } else if(arg == "--version") {
+            cout << args[0] << " Original Author: Umar Arshad;\n Modified later by: Pradeep Garigipati." << endl;
+        } else if(arg == "--help") {
+            print_usage();
+        } else if(options.find(arg) != options.end()) {
+            curr_opt = arg;
+        } else if(curr_opt.empty()) {
+            //cerr << "Invalid Argument: " << arg << endl;
+        } else {
+            if(options[curr_opt] != "") {
+                options[curr_opt] += " " + arg;
+            }
+            else {
+                options[curr_opt] += arg;
+            }
+        }
+    }
+
+    if(verbose) {
+        for(auto opts : options) {
+            cout << get<0>(opts) << " " << get<1>(opts) << endl;
+        }
+    }
+    return options;
+}
+
+int main(int argc, const char * const * const argv)
+{
+
+    vector<string> args(argv, argv+argc);
+
+    opt_t&& options = parse_options(args);
+
+    //Save default cout buffer. Need this to prevent crash.
+    auto bak = cout.rdbuf();
+    unique_ptr<ofstream> outfile;
+
+    // Set defaults
+    if(options["--name"] == "")     { options["--name"]     = "var"; }
+    if(options["--output"] != "")   {
+        //redirect stream if output file is specified
+        outfile.reset(new ofstream(options["--output"]));
+        cout.rdbuf(outfile->rdbuf());
+    }
+
+    cout << "#pragma once\n";
+    cout << "#include <string>\n"; // defines std::string
+
+    int ns_cnt = 0;
+    int level = 0;
+    if(options["--namespace"] != "") {
+        std::stringstream namespaces(options["--namespace"]);
+        string name;
+        namespaces >> name;
+        do {
+            add_tabs(level++);
+            cout << "namespace " << name << "\n{\n";
+            ns_cnt++;
+            namespaces >> name;
+        } while(!namespaces.fail());
+    }
+
+    if(options["--type"] == "") {
+        options["--type"]     = "std::string";
+    }
+    add_tabs(level);
+    cout << "static const " << options["--type"] << " " << options["--name"] << " = R\"shader(\n";
+    level++;
+
+    ifstream input(options["--file"]);
+
+    for(std::string line; std::getline(input, line);) {
+        add_tabs(level);
+        cout << line << endl;
+    }
+
+    if (options["--eof"].c_str()[0] == '1') {
+        // Add end of file character
+        cout << "0x0";
+    }
+
+    add_tabs(--level);
+    cout << ")shader\";\n";
+
+    while(ns_cnt--) {
+        add_tabs(--level);
+        cout << "}\n";
+    }
+    cout.rdbuf(bak);
+}

README.md

@@ -17,3 +17,10 @@ A prototype of the OpenGL interop library that can be used with ArrayFire. The g
 * On `Linux` and `OS X`, [fontconfig](http://www.freedesktop.org/wiki/Software/fontconfig/) is required.
 
 Above dependencies are available through package managers on most of the Unix/Linux based distributions. We have provided an option in `CMake` for `Forge` to build it's own internal `freetype` version if you choose to not install it on your machine.
+
+### Sample Images
+|     |     |
+|-----|-----|
+| <img src="./docs/images/image.png" width=150 height=100>Image</img> | <img src="./docs/images/plot.png" width=150 height=100>2D Plot</img>  |
+| <img src="./docs/images/plot31.png" width=150 height=100>3d Plot</img> | <img src="./docs/images/plot32.png" width=150 height=100>Rotated 3d Plot</img> |
+| <img src="./docs/images/hist.png" width=150 height=100>histogram</img> | <img src="./docs/images/surface.png" width=150 height=100>Surface</img> |

docs/pages/README.md

@@ -22,10 +22,12 @@ install it on your machine.
 
 We plan to provide support for alternatives to GLFW as windowing toolkit,
 however GLFW is the default option. Should you chose to use an alternative, you
-have to chose it explicity.
+have to chose it explicity while building forge.
 
-Alternatives to GLFW which are currently under consideration are given below:
+Currently supported alternatives:
 * [SDL2](https://www.libsdl.org/download-2.0.php)
+
+Alternatives to GLFW which are currently under consideration are given below:
 * [Qt5](https://wiki.qt.io/Qt_5)
 
 #### Email