first

Author: zzwong

.gitignore

@@ -0,0 +1,3 @@
+*.xcuserstate
+/xcuserdata/*
+.DS_*

Cube.cpp

@@ -0,0 +1,71 @@
+
+#include "Cube.h"
+#include "Window.h"
+
+
+Cube::Cube(GLuint shader){
+    //Shader program
+    this->shaderProgram = shader;
+    
+    //VAO objects
+    //Create array object and buffers, remember to delete!
+    glGenVertexArrays(1, &VAO);
+    glGenBuffers(1, &VBO);
+    glGenBuffers(1, &EBO);
+    glGenBuffers(1, &NBO);
+    
+    // Bind VAO
+    glBindVertexArray(VAO);
+    
+    // Bind VBO
+    glBindBuffer(GL_ARRAY_BUFFER, VBO);
+    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices_), vertices_, GL_STATIC_DRAW);
+    
+    glEnableVertexAttribArray(0);
+    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), (GLvoid*)0);
+    
+    // Bind EBO
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
+    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices_), indices_, GL_STATIC_DRAW);
+    
+    // Bind the normals
+    glBindBuffer(GL_ARRAY_BUFFER, NBO);
+    glBufferData(GL_ARRAY_BUFFER, sizeof(normals_), normals_, GL_STATIC_DRAW);
+    
+    glEnableVertexAttribArray(1);
+    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 3*sizeof(GLfloat), (GLvoid*)0);
+    
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+    glBindVertexArray(0);
+}
+
+Cube::~Cube(){
+    glDeleteVertexArrays(1, &VAO);
+    glDeleteBuffers(1, &VBO);
+    glDeleteBuffers(1, &NBO);
+    glDeleteBuffers(1, &EBO);
+}
+
+void Cube::draw(glm::mat4 C){
+    
+    this->toWorld = C;
+    
+    //Draw
+    glm::mat4 modelview = Window::V * toWorld;
+    
+    uProjection = glGetUniformLocation(shaderProgram, "projection");
+    uModelview = glGetUniformLocation(shaderProgram, "modelview");
+    // Now send these values to the shader program
+    glUniformMatrix4fv(uProjection, 1, GL_FALSE, &Window::P[0][0]);
+    glUniformMatrix4fv(uModelview, 1, GL_FALSE, &modelview[0][0]);
+    glUniformMatrix4fv(glGetUniformLocation(shaderProgram, "model"), 1, GL_FALSE, &this->toWorld[0][0]);
+    
+    glBindVertexArray(VAO);
+    glDrawElements(GL_TRIANGLES, 36, GL_UNSIGNED_INT, 0);
+    //glDrawArrays(GL_POINTS, 0, 24);
+    glBindVertexArray(0);
+}
+
+void Cube::update(){
+    
+}

Cube.h

@@ -0,0 +1,59 @@
+
+#ifndef CUBE
+#define CUBE
+#include "Geode.h"
+
+class Cube : public Geode{
+public:
+    Cube(GLuint shader);
+    ~Cube();
+    
+    void draw(glm::mat4 C);
+    void update();
+    
+protected:
+    GLfloat vertices_[8][3] = {
+        // "Front" vertices
+        {-1.0, -1.0,  1.0},
+        {1.0, -1.0,  1.0},
+        {1.0,  1.0,  1.0},
+        {-1.0,  1.0,  1.0},
+        // "Back" vertices
+        {-1.0, -1.0, -1.0},
+        {1.0, -1.0, -1.0},
+        {1.0,  1.0, -1.0},
+        {-1.0,  1.0, -1.0}
+    };
+    
+    GLfloat normals_[8][3] = {
+        // "Front"
+        {-1.0f/3, -1.0f/3, 1.0f/3},
+        {1.0f/3, -1.0f/3, 1.0f/3},
+        {1.0f/3, 1.0f/3, 1.0f/3},
+        {0.0, 1.0, 0.0},
+        // "Back"
+        {-1.0f/3, -1.0f/3, -1.0f/3},
+        {1.0f/3, -1.0f/3, -1.0f/3},
+        {1.0f/3, 1.0f/3, -1.0f/3},
+        {-1.0f/3,  1.0f/3, -1.0f/3}
+    };
+    
+    GLuint indices_[6][6] = {
+        // Front face
+        {0, 1, 2, 2, 3, 0},
+        // Top face
+        {1, 5, 6, 6, 2, 1},
+        // Back face
+        {7, 6, 5, 5, 4, 7},
+        // Bottom face
+        {4, 0, 3, 3, 7, 4},
+        // Left face
+        {4, 5, 1, 1, 0, 4},
+        // Right face
+        {3, 2, 6, 6, 7, 3}
+    };
+    
+    glm::mat4 toWorld;
+};
+
+#endif

Geode.cpp

@@ -0,0 +1 @@
+#include "Geode.h"

Geode.h

@@ -0,0 +1,18 @@
+#ifndef GEODE
+#define GEODE
+#include "Node.h"
+
+class Geode : public Node{
+public:
+    virtual void draw(glm::mat4 C) = 0;
+    virtual void update() = 0;
+    
+protected:
+    GLuint VBO, VAO, EBO, NBO;
+    GLuint uProjection, uModelview;
+    GLuint shaderProgram;
+    
+    glm::mat4 toWorld;
+};
+
+#endif

Group.cpp

@@ -0,0 +1,61 @@
+#include "Group.h"
+#include "MatrixTransform.h"
+#include "Node.h"
+#include "Geode.h"
+#include <iostream>
+
+Group::Group(){
+    children = std::vector<Node*>();
+}
+
+Group::~Group(){
+    //Dlete all it's children
+    for(auto child : children){
+        delete child;
+    }
+}
+
+//Add a child
+void Group::addChild(Node *n){
+    children.push_back(n);
+}
+//Remove a child
+void Group::removeChild(Node *n){
+    //children.remove(n);
+}
+//Draw all the children
+void Group::draw(glm::mat4 C){
+    glm::vec4 translation = C * glm::vec4(0,0,0,1);
+    center = translation;
+    for(auto child : children){
+        child->draw(C);
+    }
+}
+//Update because piazza said so
+void Group::update() {
+
+}
+
+void Group::setBoundsForRobot(){
+//    boundingSphere = new Sphere();
+}
+
+void Group::drawBoundingSphere(GLuint shader){
+    
+}
+
+std::vector<Node*> Group::getChildrenVector(){
+    return children;
+}
+
+glm::vec3 Group::getPoint(){
+    return glm::vec3(center.x, center.y, center.z);
+}
+
+
+
+
+
+
+
+

Group.h

@@ -0,0 +1,36 @@
+#ifndef GROUP
+#define GROUP
+#include "Node.h"
+#include <glm/gtc/matrix_transform.hpp>
+#include <list>
+#include <vector>
+//#include "Sphere.h"
+
+class Group : public Node{
+public:
+    Group();
+    ~Group();
+    //Add a child
+    void addChild(Node *n);
+    //Remove a child
+    void removeChild(Node *n);
+    //Draw all the children
+    virtual void draw(glm::mat4 C);
+    //Update because piazza said so
+    void update();
+    
+    void setBoundsForRobot();
+    void drawBoundingSphere(GLuint);
+    glm::vec3 getPoint();
+    
+    std::vector<Node*> getChildrenVector();
+    
+protected:
+    std::vector<Node*> children;
+    
+//    Sphere* boundingSphere;
+    glm::vec4 center;
+    float radius = 1.75f;
+};
+
+#endif

MatrixTransform.cpp

@@ -0,0 +1,32 @@
+#include "MatrixTransform.h"
+
+//Constructor
+MatrixTransform::MatrixTransform(glm::mat4 C){
+    this->M = C * M;
+}
+//Destructor
+MatrixTransform::~MatrixTransform(){
+    for(auto child : children){
+        delete child;
+    }
+    Group::~Group();
+}
+
+//Update the MT
+void MatrixTransform::update(glm::mat4 update){
+    this->M = update * M;
+}
+
+//Pass down this transformation to all children
+void MatrixTransform::draw(glm::mat4 C){
+    glm::mat4 M_new = C * M;
+        
+    for(auto child : children){
+        child->draw(M_new);
+    }
+}
+
+//Get the child beneath this MT
+Node* MatrixTransform::getChild(){
+    return this->children[0];
+}

MatrixTransform.h

@@ -0,0 +1,19 @@
+#ifndef MTFORM
+#define MTFORM
+#include <stdio.h>
+#include "Group.h"
+
+class MatrixTransform : public Group{
+public:
+    MatrixTransform(glm::mat4);
+    ~MatrixTransform();
+    //Pass down this transformation to all children
+    void draw(glm::mat4 C);
+    void update(glm::mat4);
+    Node* getChild();
+protected:
+    //Model matrix
+    glm::mat4 M = glm::mat4(1.0f);
+};
+
+#endif

Node.cpp

@@ -0,0 +1,2 @@
+#include "Node.h"
+

Node.h

@@ -0,0 +1,19 @@
+#ifndef NODE
+#define NODE
+#include "glm/glm.hpp"
+#define GLFW_INCLUDE_GLEXT
+#ifdef __APPLE__
+#define GLFW_INCLUDE_GLCOREARB
+#else
+#include <GL/glew.h>
+#endif
+#include <GLFW/glfw3.h>
+
+class Node {
+public:
+    virtual void draw(glm::mat4 C) = 0; //Used to draw the geodes
+    virtual void update() = 0; //Used to update the bounding sphere
+   
+};
+
+#endif