pixo 0.1.0

data/ext/pixo/patterns/warping_grid.glsl

@@ -0,0 +1,50 @@
+#version 330 core
+out vec4 color_out;
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+// http://glslsandbox.com/e#27440.0
+
+uniform float time;
+uniform vec2 mouse;
+uniform vec2 resolution;
+uniform sampler2D backbuffer;
+
+vec3 Hue( float hue )
+{
+  vec3 rgb = fract(hue + vec3(0.0,2.0/3.0,1.0/3.0));
+
+  rgb = abs(rgb*2.0-1.0);
+    
+  return clamp(rgb*3.0-1.0,0.0,1.0);
+}
+
+vec4 toRGB( vec4 hsv )
+{
+  return vec4( ((Hue(hsv.x)-1.0)*hsv.y+1.0) * hsv.z, hsv.a);
+}
+
+void main( void ) {
+
+  vec2 texcoord = vec2(gl_FragCoord.xy/resolution);
+  vec2 coord = ( gl_FragCoord.xy*2.0 - resolution ) / resolution.y;
+
+  vec4 prev =texture(backbuffer,texcoord *vec2(0.5));
+  vec4 prev1 =texture(backbuffer,texcoord*vec2(0.1));
+  
+  float x = fract(coord.x*2.0+sin(time+coord.y));
+  float y = fract(coord.y*2.0+sin(time+coord.x));
+  
+  y = pow(abs(y-0.5), 2.0)*2.0;
+  x = pow(abs(x-0.5), 2.0)*2.0;
+  
+  float h = texcoord.x * texcoord.y;
+  vec4 color = toRGB(vec4(h,0.5,1.0,1.0));
+  
+  vec4 s1 =vec4(y+x)*color + (prev*0.2) + (prev1*0.2);
+  
+  color_out = s1;
+
+}

data/ext/pixo/pixlib/CMakeLists.txt

@@ -0,0 +1,34 @@
+
+cmake_minimum_required(VERSION 3.0)
+project(pixlib)
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14 -fPIC")
+
+
+###################### GLM     ###############################
+include_directories( ../ext/glm/ )
+
+include_directories(include)
+
+add_library(pixlib STATIC
+ src/shader.cpp
+ src/scene.cpp
+ src/texture.cpp
+ src/cube.cpp
+ src/mesh.cpp
+ src/camera.cpp
+ src/led_mesh.cpp
+ src/led_cluster.cpp
+ src/renderer.cpp
+ src/pattern_renderer.cpp
+ src/led_renderer.cpp
+ src/timer.cpp
+ src/fade_candy.cpp
+ src/pattern.cpp
+ src/app.cpp
+ )
+
+ target_link_libraries(pixlib) # realsense)
+
+
+set(PIXLIB_INCLUDE ${CMAKE_CURRENT_SOURCE_DIR}/include PARENT_SCOPE)
+

data/ext/pixo/pixlib/include/opc_client.h

@@ -0,0 +1,205 @@
+/*
+ * Tiny and fast C++ client for Open Pixel Control
+ *
+ * Copyright (c) 2014 Micah Elizabeth Scott <micah@scanlime.org>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <vector>
+#include <stdint.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <netdb.h>
+#include <signal.h>
+
+
+class OPCClient {
+public:
+    OPCClient();
+    ~OPCClient();
+
+    bool resolve(const char *hostport, int defaultPort = 7890);
+    bool write(const uint8_t *data, ssize_t length);
+    bool write(const std::vector<uint8_t> &data);
+
+    bool tryConnect();
+    bool isConnected();
+
+    struct Header {
+        uint8_t channel;
+        uint8_t command;
+        uint8_t length[2];
+
+        void init(uint8_t channel, uint8_t command, uint16_t length) {
+            this->channel = channel;
+            this->command = command;
+            this->length[0] = length >> 8;
+            this->length[1] = (uint8_t)length;
+        }
+
+        uint8_t *data() {
+            return (uint8_t*) &this[1];
+        }
+        const uint8_t *data() const {
+            return (uint8_t*) &this[1];
+        }
+
+        // Use a Header() to manipulate packet data in a std::vector
+        static Header& view(std::vector<uint8_t> &data) {
+            return *(Header*) &data[0];
+        }
+        static const Header& view(const std::vector<uint8_t> &data) {
+            return *(Header*) &data[0];
+        }
+    };
+
+    // Commands
+    static const uint8_t SET_PIXEL_COLORS = 0;
+
+private:
+    int fd;
+    struct sockaddr_in address;
+    bool connectSocket();
+    void closeSocket();
+};
+
+
+/*****************************************************************************************
+ *                                   Implementation
+ *****************************************************************************************/
+
+
+inline OPCClient::OPCClient()
+{
+    fd = -1;
+    memset(&address, 0, sizeof address);
+}
+
+inline OPCClient::~OPCClient()
+{
+    closeSocket();
+}
+
+inline void OPCClient::closeSocket()
+{
+    if (isConnected()) {
+        close(fd);
+        fd = -1;
+    }
+}
+
+inline bool OPCClient::resolve(const char *hostport, int defaultPort)
+{
+    fd = -1;
+
+    char *host = strdup(hostport);
+    char *colon = strchr(host, ':');
+    int port = defaultPort;
+    bool success = false;
+
+    if (colon) {
+        *colon = '\0';
+        port = strtol(colon + 1, 0, 10);
+    }
+
+    if (port) {
+        struct addrinfo *addr;
+        getaddrinfo(*host ? host : "localhost", 0, 0, &addr);
+
+        for (struct addrinfo *i = addr; i; i = i->ai_next) {
+            if (i->ai_family == PF_INET) {
+                memcpy(&address, i->ai_addr, sizeof address);
+                address.sin_port = htons(port);
+                success = true;
+                break;
+            }
+        }
+        freeaddrinfo(addr);
+    }
+
+    free(host);
+    return success;
+}
+
+inline bool OPCClient::isConnected()
+{
+    return fd > 0;
+}
+
+inline bool OPCClient::tryConnect()
+{
+    return isConnected() || connectSocket();
+}
+
+inline bool OPCClient::write(const uint8_t *data, ssize_t length)
+{
+    if (!tryConnect()) {
+        return false;
+    }
+
+    while (length > 0) {
+        int result = send(fd, data, length, 0);
+        if (result <= 0) {
+            closeSocket();
+            return false;
+        }
+        length -= result;
+        data += result;
+    }
+
+    return true;
+}
+
+inline bool OPCClient::write(const std::vector<uint8_t> &data)
+{
+    return write(&data[0], data.size());
+}
+
+inline bool OPCClient::connectSocket()
+{
+    fd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
+
+    if (connect(fd, (struct sockaddr*) &address, sizeof address) < 0) {
+        closeSocket();
+        return false;
+    }
+
+    int flag = 1;
+    setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char*) &flag, sizeof flag);
+
+    #ifdef SO_NOSIGPIPE
+        flag = 1;
+        setsockopt(fd, SOL_SOCKET, SO_NOSIGPIPE, (char*) &flag, sizeof flag);
+    #else
+        signal(SIGPIPE, SIG_IGN);
+    #endif
+
+    return true;
+}

data/ext/pixo/pixlib/include/pixlib/app.hpp

@@ -0,0 +1,41 @@
+#pragma once
+#include <vector>
+
+#include <pixlib/pattern.hpp>
+#include <pixlib/camera.hpp>
+#include <pixlib/led_cluster.hpp>
+#include <pixlib/scene.hpp>
+#include <pixlib/timer.hpp>
+#include <pixlib/fade_candy.hpp>
+
+namespace Pixlib {
+  class App {
+  public:
+
+    App();
+    ~App();
+
+    void addFadeCandy(FadeCandy* fc);
+    
+    float scene_fps();
+    float scene_render_time();
+    float led_render_time();
+
+    const Texture& getPatternTexture();
+
+    void ProcessMouseMovement(int xoffset, int yoffset);
+    void ProcessMouseScroll(float x);
+
+    void move_perspective_to_camera();
+
+    void tick(Pattern* pattern, int width, int height);
+  private:
+    Scene scene;
+    std::vector<LedCluster*> led_clusters;
+
+    IsoCamera viewed_from;
+    IsoCamera camera;
+
+    FadeCandy *fc;
+  };
+}

data/ext/pixo/pixlib/include/pixlib/camera.hpp

@@ -0,0 +1,78 @@
+#pragma once
+
+// Std. Includes
+#include <vector>
+
+// GL Includes
+#include <opengl.h>
+#include <glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+
+
+namespace Pixlib {
+  // Defines several possible options for camera movement. Used as abstraction to stay away from window-system specific input methods
+  enum Camera_Movement {
+    FORWARD,
+    BACKWARD,
+    LEFT,
+    RIGHT,
+    TOWARDS_VIEW,
+    MATCH_VIEW,
+    NEXT_PATTERN,
+    ORB_UP,
+    ORB_DOWN,
+    ORB_LEFT,
+    ORB_RIGHT
+  };
+
+  // Default camera values
+  const GLfloat YAW        = 108.0f;
+  const GLfloat PITCH      =  12.0f;
+  const GLfloat SENSITIVTY =  0.25f;
+  const GLfloat ZOOM       =  11.4f;
+
+  class OrthoCamera {
+  public:
+    glm::mat4 GetViewMatrix();
+    glm::mat4 GetProjectionMatrix(int width, int height);
+  };
+
+  // An abstract camera class that processes input and calculates the corresponding Eular Angles, Vectors and Matrices for use in OpenGL
+  class IsoCamera 
+  {
+  public:
+    // Camera Attributes
+    glm::vec3 Position;
+    glm::vec3 Front;
+    glm::vec3 Up;
+    glm::vec3 Right;
+    glm::vec3 WorldUp;
+    // Eular Angles
+    GLfloat Yaw;
+    GLfloat Pitch;
+    // Camera options
+    GLfloat MouseSensitivity;
+    GLfloat Zoom;
+
+    // Constructor with vectors
+    IsoCamera( GLfloat yaw = YAW, GLfloat pitch = PITCH);
+
+
+    // Returns the view matrix calculated using Eular Angles and the LookAt Matrix
+    glm::mat4 GetViewMatrix() const;
+    glm::mat4 GetProjectionMatrix(int width, int height) const;
+
+    // Processes input received from a mouse input system. Expects the offset value in both the x and y direction.
+    void ProcessMouseMovement(GLfloat xoffset, GLfloat yoffset);
+
+    // Processes input received from a mouse scroll-wheel event. Only requires input on the vertical wheel-axis
+    void ProcessMouseScroll(GLfloat yoffset);
+
+    void moveTowards(const IsoCamera& camera, float timeScale);
+
+    void rotate(const float rads);
+  private:
+    // Calculates the front vector from the Camera's (updated) Eular Angles
+    void updateCameraVectors();
+  };
+}

data/ext/pixo/pixlib/include/pixlib/cube.hpp

@@ -0,0 +1,46 @@
+#pragma once
+// Std. Includes
+#include <string>
+#include <map>
+#include <vector>
+
+// GL Includes
+#include <opengl.h>
+#include <pixlib/mesh.hpp>
+#include <pixlib/shader.hpp>
+#include <pixlib/drawable.hpp>
+
+// Include GLM
+#include <glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+#include <glm/gtc/type_ptr.hpp>
+
+namespace Pixlib {
+  class Cube : public Drawable
+  {
+  public:
+    /*  Functions   */
+    // Constructor, expects a filepath to a 3D model.
+    Cube();
+    Cube(const Texture& defaultTexture);
+
+    // Draws the model, and thus all its meshes
+    virtual void Draw(const Shader& shader);
+    
+    int  addInstance(glm::vec3 posDelta, glm::vec2 texDelta, glm::vec3 projDelta);
+    void moveInstance(int instance, const glm::vec3& position);
+
+    int numInstances();
+
+    Texture getDefaultTexture();
+  private:
+    /*  Model Data  */
+    std::vector<Mesh> meshes;
+    Texture defaultTexture;
+
+    /*  Functions   */
+    // Loads a model with supported ASSIMP extensions from file and stores the resulting meshes in the meshes vector.
+    void loadModel();
+  };
+}
+

data/ext/pixo/pixlib/include/pixlib/drawable.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <opengl.h>
+#include <pixlib/shader.hpp>
+
+namespace Pixlib {
+  class Drawable {
+  public:
+    virtual void Draw(const Shader& shader) = 0;
+  };
+}

data/ext/pixo/pixlib/include/pixlib/fade_candy.hpp

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <opengl.h>
+#include <string>
+#include <vector>
+
+#include <glm/glm.hpp>
+#include <opc_client.h>
+
+
+namespace Pixlib {
+  struct LedInfo {
+    // Position
+    glm::vec3 position;
+    // TexCoords
+    glm::vec3 texture_coordinates;
+  };
+
+  class FadeCandy {
+  public:
+  	FadeCandy(const std::string& hostname, unsigned int per_size);
+
+  	const std::vector<LedInfo>& getLeds();
+  	glm::vec2 textureSize();
+  	void update();
+    void clear();
+
+  	uint8_t* getData();
+  private:
+
+    	void finalize();
+
+  	std::vector<LedInfo> leds;
+  	std::vector<uint8_t> framebuffer;
+  	OPCClient opc_client;
+
+  };
+}

data/ext/pixo/pixlib/include/pixlib/led_cluster.hpp

@@ -0,0 +1,58 @@
+#pragma once
+
+#include <opengl.h>
+
+#include <string>
+#include <fstream>
+#include <sstream>
+#include <iostream>
+#include <map>
+#include <vector>
+
+#include <pixlib/cube.hpp>
+#include <pixlib/fade_candy.hpp>
+#include <pixlib/mesh.hpp>
+#include <pixlib/led_mesh.hpp>
+#include <pixlib/led_renderer.hpp>
+#include <pixlib/pattern_renderer.hpp>
+#include <pixlib/pattern.hpp>
+#include <pixlib/renderer.hpp>
+#include <pixlib/timer.hpp>
+
+
+
+namespace Pixlib {
+  class LedCluster: public Drawable {
+  public:
+    // Draws the model, and thus all its meshes
+    LedCluster(FadeCandy *fadecandy);
+
+
+    // Render the mesh
+    virtual void Draw(const Shader& shader);
+
+    void render(const IsoCamera& viewed_from, const Pattern& pattern);
+
+    const Texture& getPatternTexture();
+
+    GLuint numLeds();
+
+    float render_time();
+
+  private:
+
+    Texture led_texture;
+    LedRender fb_render;
+    PatternRender pattern_render;
+    FadeCandy *fadecandy;
+
+    /*  Model Data  */
+    LedMesh leds_for_calc;;
+
+    Cube leds_for_display;
+    Timer render_timer;
+
+    static size_t led_canvas_size(size_t leds);
+
+  };
+}

data/ext/pixo/pixlib/include/pixlib/led_mesh.hpp

@@ -0,0 +1,60 @@
+#pragma once
+// Std. Includes
+#include <opengl.h>
+#include <string>
+#include <vector>
+
+// GL Includes
+#include <glm/glm.hpp>
+
+#include <pixlib/shader.hpp>
+#include <pixlib/drawable.hpp>
+#include <pixlib/mesh.hpp>
+
+
+namespace Pixlib {
+  struct LedVertex {
+    // Position
+    glm::vec3 Position;
+    // Normal
+    glm::vec3 Normal;
+    // TexCoords
+    glm::vec3 TexCoords;
+    // Projection for led rendering
+    glm::vec3 framebuffer_proj;
+  };
+
+  class LedMesh : public Drawable {
+  public:
+    LedMesh(const Texture& textures);
+
+    
+    // Render the mesh
+    virtual void Draw(const Shader& shader);
+
+    size_t numVertices();
+    float getZoom(glm::vec3 position);
+
+    LedVertex getVertex(int idx);
+    void addVertex(const LedVertex& vert);
+    void addTexture(const Texture& texture);
+
+    void setupMesh();
+  protected:
+    /*  Render data  */
+    GLuint VAO, VBO, EBO;
+
+    /*  Mesh Data  */
+    std::vector<LedVertex> vertices;
+    std::vector<Texture> textures;
+
+    float min_x;
+    float max_x;
+    
+    float min_y;
+    float max_y;
+    
+    float min_z;
+    float max_z;
+  };
+}

data/ext/pixo/pixlib/include/pixlib/led_renderer.hpp

@@ -0,0 +1,36 @@
+#pragma once
+#include <vector>
+
+#include <opengl.h>
+#include <glm/glm.hpp>
+
+#include <pixlib/led_mesh.hpp>
+#include <pixlib/shader.hpp>
+#include <pixlib/camera.hpp>
+#include <pixlib/texture.hpp>
+
+namespace Pixlib {
+  class LedRender {
+  public:
+    LedRender(const Texture& renderTo);
+
+    void render(const IsoCamera& perspective, uint8_t* data, size_t size);
+
+    Texture getTexture();
+
+    LedMesh* leds;
+
+  private:
+    GLuint FramebufferName;
+    Texture renderedTexture;
+    int width, height;
+
+    GLuint pbos[2];
+    GLuint active_pbo;
+    OrthoCamera camera;
+
+
+    Shader shader;
+    void setupLights(const IsoCamera& perspective);
+  };
+}