pixo 0.1.0

data/ext/pixo/pixlib/src/scene.cpp

@@ -0,0 +1,52 @@
+#include <pixlib/scene.hpp>
+
+namespace Pixlib {
+  Scene::Scene() :
+    lastTime(std::chrono::steady_clock::now()),
+    fps(0),frames(0), render_timer(120)
+  { }
+
+  void Scene::addCluster(LedCluster* leds)
+  {
+    screen.models.push_back(leds);
+  }
+
+  void Scene::render(const IsoCamera& perspective, int width, int height)
+  {
+    std::chrono::time_point<std::chrono::steady_clock> currentTime = std::chrono::steady_clock::now();
+    ++frames;
+
+    std::chrono::duration<float> time_duration = currentTime - lastUpdate;
+    float time_delta = time_duration.count();
+    if ( time_delta >= 1.0 ){
+      lastUpdate = currentTime;
+      fps = frames;
+      frames = 0;
+    }
+
+    // Set frame time
+    deltaTime = currentTime - lastTime;
+
+    lastTime = currentTime;
+
+    render_timer.start();
+    screen.render(perspective, width, height);
+    render_timer.end();
+
+  }
+
+  float Scene::getTimeDelta()
+  {
+    return deltaTime.count();
+  }
+
+
+  float Scene::getFps() {
+    return fps;
+  }
+
+  float Scene::get_render_time()
+  {
+    return render_timer.duration();
+  }
+}

data/ext/pixo/pixlib/src/shader.cpp

@@ -0,0 +1,59 @@
+#include <pixlib/shader.hpp>
+
+// Shader::Shader(const Shader& copy) : Program(copy.Program) { }
+
+namespace Pixlib {
+  Shader::Shader(const GLchar* vShaderCode, const GLchar* fShaderCode) {
+   
+    GLuint vertex, fragment;
+    GLint success;
+    GLchar infoLog[512];
+    // Vertex Shader
+    vertex = glCreateShader(GL_VERTEX_SHADER);
+    glShaderSource(vertex, 1, &vShaderCode, NULL);
+    glCompileShader(vertex);
+    // Print compile errors if any
+    glGetShaderiv(vertex, GL_COMPILE_STATUS, &success);
+    if (!success)
+    {
+      glGetShaderInfoLog(vertex, 512, NULL, infoLog);
+      ALOGV("ERROR::SHADER::VERTEX::COMPILATION_FAILED\n%s\n", infoLog);
+    }
+    // Fragment Shader
+    fragment = glCreateShader(GL_FRAGMENT_SHADER);
+    glShaderSource(fragment, 1, &fShaderCode, NULL);
+    glCompileShader(fragment);
+    // Print compile errors if any
+    glGetShaderiv(fragment, GL_COMPILE_STATUS, &success);
+    if (!success)
+    {
+      glGetShaderInfoLog(fragment, 512, NULL, infoLog);
+      ALOGV("ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n%s\n", infoLog);
+    }
+    // Shader Program
+    this->Program = glCreateProgram();
+    glAttachShader(this->Program, vertex);
+    glAttachShader(this->Program, fragment);
+    glLinkProgram(this->Program);
+    // Print linking errors if any
+    glGetProgramiv(this->Program, GL_LINK_STATUS, &success);
+    if (!success)
+    {
+      glGetProgramInfoLog(this->Program, 512, NULL, infoLog);
+
+      ALOGV("ERROR::SHADER::PROGRAM::LINKING_FAILED\n%s\n", infoLog);
+    }
+    // Delete the shaders as they're linked into our program now and no longer necessery
+    glDeleteShader(vertex);
+    glDeleteShader(fragment);
+  }
+
+  Shader::~Shader() {
+    glDeleteProgram(this->Program);
+  }
+
+  // Uses the current shader
+  void Shader::Use() const { 
+      glUseProgram(this->Program); 
+  }
+}

data/ext/pixo/pixlib/src/texture.cpp

@@ -0,0 +1,62 @@
+#include <pixlib/texture.hpp>
+
+namespace Pixlib {
+  Texture::Texture(const Texture& copy) : width(copy.width), height(copy.height), id(copy.id), isCopy(true)
+  { }
+
+  Texture::Texture(int width, int height) : width(width), height(height), isCopy(false)
+  {
+    // The texture we're going to render to
+    glGenTextures(1, &id);
+    glBindTexture(GL_TEXTURE_2D, id);
+    glTexImage2D(GL_TEXTURE_2D, 0,GL_RGB, width, height, 0,GL_RGB, GL_UNSIGNED_BYTE, 0);
+  }
+
+
+  Texture::~Texture()
+  {
+  	if(isCopy)
+  		return;
+  	glDeleteTextures(1, &id);
+  }
+
+
+
+  Texture3d::Texture3d(const Texture3d& copy) :
+   width(copy.width),
+   height(copy.height),
+   depth(copy.depth),
+   id(copy.id),
+   isCopy(true)
+  { }
+
+  Texture3d::Texture3d(int width, int height, int depth) :
+   width(width),
+   height(height),
+   depth(depth),
+   isCopy(false)
+  {
+    // The texture we're going to render to
+    glGenTextures(1, &id);
+    glBindTexture(GL_TEXTURE_3D, id);
+    glTexImage3D(GL_TEXTURE_3D,
+      0,
+      GL_DEPTH_COMPONENT,
+
+     width,
+     height,
+     depth,
+    0,
+    GL_DEPTH_COMPONENT,
+    GL_UNSIGNED_SHORT,
+    nullptr);
+  }
+
+
+  Texture3d::~Texture3d()
+  {
+  	if(isCopy)
+  		return;
+  	glDeleteTextures(1, &id);
+  }
+}

data/ext/pixo/pixlib/src/timer.cpp

@@ -0,0 +1,39 @@
+#include <pixlib/timer.hpp>
+
+namespace Pixlib {
+  Timer::Timer(unsigned int smoothing) :
+   start_time(std::chrono::high_resolution_clock::now()),
+   smoothing(smoothing),
+   previous_duration(0.0f)
+  { }
+
+
+  void Timer::start()
+  {
+    start_time = std::chrono::high_resolution_clock::now();
+  }
+
+  void Timer::end()
+  {
+
+    std::chrono::time_point<std::chrono::high_resolution_clock> now = std::chrono::high_resolution_clock::now();
+    std::chrono::duration<float> time_duration = now - start_time;
+    start_time = now;
+
+    if (previous_duration == 0.0f)
+    {
+      previous_duration = time_duration.count();
+    }
+
+    float duration = (previous_duration*(smoothing - 1) + time_duration.count()) / smoothing;
+
+    previous_duration = duration;
+
+    return;
+  }
+
+  float Timer::duration()
+  {
+    return previous_duration;
+  }
+}

data/ext/pixo/src/CMakeLists.txt

@@ -0,0 +1,14 @@
+
+cmake_minimum_required(VERSION 3.0)
+project(pixo_app)
+
+add_executable(pixo main.cpp )
+target_link_libraries(pixo glfw libglew_static pthread pixlib )
+
+add_custom_target(patterns ALL)
+add_custom_command(TARGET patterns
+                   POST_BUILD
+                   COMMAND cp -a ${CMAKE_CURRENT_SOURCE_DIR}/../patterns .
+                   WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+                   VERBATIM
+                   )

data/ext/pixo/src/main.cpp

@@ -0,0 +1,244 @@
+// Include standard headers
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <vector>
+
+#include <iostream>
+
+// Include GLEW
+#include <GL/glew.h>
+
+// Include GLFW
+#include <GLFW/glfw3.h>
+GLFWwindow* window;
+
+// Include GLM
+#include <glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+#include <glm/gtc/type_ptr.hpp>
+
+#include <pixlib.hpp>
+
+
+using namespace glm;
+using namespace std;
+using namespace Pixlib;
+
+Timer global_timer = Timer(120);
+
+static GLfloat lastX = 400, lastY = 300;
+static bool firstMouse = true;
+
+bool keys[1024];
+
+void sig_int_handler(int s){
+  static unsigned int hits = 1;
+  if (hits++ >= 3) {
+    exit(1);
+  }
+  glfwSetWindowShouldClose(window, GL_TRUE);
+}
+
+int main( int argc, char** argv )
+{  
+  std::vector<Pattern*> patterns;
+  Pattern* pattern = nullptr;
+GLenum glErr;
+  if(argc < 3) {
+    fprintf(stderr, "Usage: %s LEDS_PER_SIDE hostname [pattern file]*\n", argv[0]);
+    exit(1);
+  }
+    // Initialise GLFW
+    if( !glfwInit() )
+    {
+        fprintf( stderr, "Failed to initialize GLFW\n" );
+        getchar();
+        return -1;
+    }  
+
+  
+  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
+  glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // To make MacOS happy; should not be needed
+  glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+  glfwWindowHint(GLFW_DEPTH_BITS, 24 );
+
+    // Open a window and create its OpenGL context
+    window = glfwCreateWindow( 800, 800, "Pixo", NULL, NULL);
+    if( window == NULL ){
+        fprintf( stderr, "Failed to open GLFW window. If you have an Intel GPU, they are not 3.3 compatible. Try the 2.1 version of the tutorials.\n" );
+        getchar();
+        glfwTerminate();
+        return -1;
+    }
+    glfwMakeContextCurrent(window);
+
+
+  // Ensure we can capture the escape key being pressed below
+  glfwSetInputMode(window, GLFW_STICKY_KEYS, GL_TRUE);
+
+  // Initialize GLEW
+  glewExperimental = GL_TRUE; // Needed for core profile
+  if (glewInit() != GLEW_OK) {
+    fprintf(stderr, "Failed to initialize GLEW\n");
+    getchar();
+    glfwTerminate();
+    return -1;
+  }
+  // Setup some OpenGL options
+  // Enable depth test
+  glEnable(GL_DEPTH_TEST);
+  
+  const int leds_per_side = atoi(argv[1]);
+  FadeCandy fc = FadeCandy(argv[2], leds_per_side);
+
+  App application(&fc);
+  glfwSetWindowUserPointer(window, &application);
+
+  for(int i = 3;i < argc;i++) {
+    std::string fragmentCode;
+    std::ifstream fShaderFile;
+    // ensures ifstream objects can throw exceptions:
+    fShaderFile.exceptions (std::ifstream::badbit);
+
+    std::string fulLFragmentath = std::string(argv[i]);
+    ALOGV("Loading: %s\n", fulLFragmentath.c_str());
+
+    fShaderFile.open(fulLFragmentath.c_str());
+    std::stringstream fShaderStream;
+    fShaderStream << fShaderFile.rdbuf();
+    fShaderFile.close();
+    
+    // Convert stream into string
+    fragmentCode = fShaderStream.str();
+
+    std::string name;
+    for(unsigned int i = fulLFragmentath.size();i >= 0;i--) {
+      if (fulLFragmentath[i] == '/') {
+        break;
+      }
+      name = fulLFragmentath[i] + name;
+    }
+    patterns.push_back(new Pattern(name, fragmentCode.c_str()));
+    pattern = patterns[0];
+  }
+
+  glfwSetCursorPosCallback(window,
+          [] (GLFWwindow *window, double x, double y) {
+            App* app = (App*)glfwGetWindowUserPointer(window);
+            int state = glfwGetMouseButton(window, GLFW_MOUSE_BUTTON_RIGHT);
+
+            if (state != GLFW_PRESS) {
+              firstMouse = true;
+            }
+            if(firstMouse)
+            {
+              lastX = x;
+              lastY = y;
+              firstMouse = false;
+            }
+
+            GLfloat xoffset = x - lastX;
+            GLfloat yoffset = y - lastY; 
+
+            lastX = x;
+            lastY = y;
+
+            app->ProcessMouseMovement(xoffset, yoffset);
+          }
+      
+  );
+
+  glfwSetMouseButtonCallback(window,
+      [](GLFWwindow *window, int button, int action, int modifiers) {
+            if (button == GLFW_MOUSE_BUTTON_RIGHT && action == GLFW_PRESS) {
+              glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
+            } else if (button == GLFW_MOUSE_BUTTON_RIGHT && action == GLFW_RELEASE) {
+              glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
+            }
+          }
+  );
+
+  glfwSetKeyCallback(window,
+      [](GLFWwindow *window, int key, int scancode, int action, int mods) {
+            if (action == GLFW_REPEAT) {
+              return;
+            }
+            if(key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)
+              glfwSetWindowShouldClose(window, GL_TRUE);
+ 
+            if(key == GLFW_KEY_ENTER) {
+              keys[NEXT_PATTERN] = (action == GLFW_PRESS); 
+            }
+
+          }
+  );
+
+
+  glfwSetScrollCallback(window,
+      [](GLFWwindow *window, double x, double y) {
+            App* app = (App*)glfwGetWindowUserPointer(window);
+
+            app->ProcessMouseScroll(y);
+
+          }
+  );
+
+  glErr = glGetError();
+  while (glErr != GL_NO_ERROR)
+  {
+      ALOGV("Preloop %04x\n", glErr);
+      glErr = glGetError();
+  }
+
+  struct sigaction sigIntHandler;
+  sigIntHandler.sa_handler = sig_int_handler;
+  sigemptyset(&sigIntHandler.sa_mask);
+  sigIntHandler.sa_flags = 0;
+  sigaction(SIGINT, &sigIntHandler, NULL);
+
+  while(!glfwWindowShouldClose(window)) {
+    global_timer.start();
+
+    glfwPollEvents();
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    int width, height;
+    glfwGetFramebufferSize(window, &width, &height);
+
+    application.tick(pattern, width, height);
+    application.move_perspective_to_camera();
+
+    if(keys[NEXT_PATTERN]) {
+      keys[NEXT_PATTERN] = false;
+
+      pattern = patterns[rand() % patterns.size()];
+    }
+
+
+
+    global_timer.end();
+    
+    glfwSwapBuffers(window);
+
+    GLenum glErr = glGetError();
+    while (glErr != GL_NO_ERROR)
+    {
+        ALOGV("glError %04x\n", glErr);
+        glErr = glGetError();
+    }
+
+  }
+
+  fc.clear();
+  
+
+  // Close OpenGL window and terminate GLFW
+  glfwTerminate();
+
+  ALOGV("Exiting\n");
+
+  return 0;
+}
+
+

data/ext/pixo/src/opengl.h

@@ -0,0 +1,4 @@
+#include <GL/glew.h>
+#include <stdio.h>
+
+#define ALOGV(...) fprintf(stderr, __VA_ARGS__)

data/lib/pixo/version.rb

@@ -0,0 +1,3 @@
+module Pixo
+  VERSION = "0.1.0"
+end

data/lib/pixo.rb

@@ -0,0 +1,7 @@
+require "pixo/version"
+
+require File.expand_path('../libpixgem', __FILE__)
+
+module Pixo
+
+end

data/pixo.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "pixo/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "pixo"
+  spec.version       = Pixo::VERSION
+  spec.authors       = ["Chris Constantine"]
+  spec.email         = ["cconstan@gmail.com"]
+
+  spec.summary       = %q{Write a short summary, because Rubygems requires one.}
+  spec.description   = %q{Write a longer description or delete this line.}
+  spec.homepage      = "https://github.com/cconstantine"
+  spec.license       = "MIT"
+
+  spec.extensions << "ext/libpixgem/extconf.rb"
+
+
+  spec.files = Dir['**/*'].keep_if do |file|
+    File.file?(file) && !file.end_with?(".so")
+  end
+  #spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+  #  f.match(%r{^(test|spec|features)/})
+  #end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake-compiler", "~> 1.0"
+
+end