Conjure/LOG750-LAB2
6
0
Fork 0
mirror of https://github.com/ConjureETS/LOG750-LAB2.git synced 2026-03-24 03:21:19 +00:00
Code Issues Packages Projects Releases Wiki Activity

Added basic cube and removed unnecessary shapes.

Browse Source 
to add more cubes, create a GlNode and add a Cube child to it. Then add
that GlNode to  the SceneGroup.
This commit is contained in:
Dmitri K 2016-10-30 23:39:53 -04:00
parent f72cdda386
commit b94626fb5d
6 changed files with 91 additions and 174 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
src/glnodes/shapes.cpp
View File

@ -2,43 +2,16 @@
#include <QColor> #include <QColor>
#include <QVector4D> #include <QVector4D>
void Square::accept(Visitor &v) { void Cube::accept(Visitor &v) {
v.visit(*this);
}
void Circle::accept(Visitor &v) {
v.visit(*this);
}
void Triangle::accept(Visitor &v) {
v.visit(*this); v.visit(*this);
} }
// *** // ***
void Square::setColor(QColor& c) { void Cube::setColor(QColor& c) {
color = QColor(c); color = QColor(c);
} }
void Circle::setColor(QColor& c) { QColor Cube::getColor(){
color = QColor(c);
}
void Triangle::setColor(QColor& c) {
color = QColor(c);
}
QColor Triangle::getColor(){
return color;
};
QColor Circle::getColor(){
return color;
};
QColor Square::getColor(){
return color; return color;
}; };

22
src/glnodes/shapes.h
View File

@ -11,28 +11,10 @@ public:
virtual QColor getColor() = 0; virtual QColor getColor() = 0;
}; };
class Circle : public Shape class Cube : public Shape
{ {
public: public:
Circle(){} Cube(){}
QColor color;
void accept(Visitor& v) override;
void setColor(QColor& c);
QColor getColor();
};
class Triangle : public Shape
{
public:
Triangle(){}
QColor color;
void accept(Visitor& v) override;
void setColor(QColor& c);
QColor getColor();
};
class Square : public Shape
{
public:
Square(){}
QColor color; QColor color;
void accept(Visitor& v) override; void accept(Visitor& v) override;
void setColor(QColor& c); void setColor(QColor& c);

8
src/interfaces/visitor.h
View File

@ -1,15 +1,11 @@
#ifndef VISITOR_H #ifndef VISITOR_H
#define VISITOR_H #define VISITOR_H
class SceneGroup; class SceneGroup;
class Square; class Cube;
class Circle;
class Triangle;
class Visitor { class Visitor {
public: public:
virtual void visit(SceneGroup &n) = 0; virtual void visit(SceneGroup &n) = 0;
virtual void visit(Square &s) = 0; virtual void visit(Cube &s) = 0;
virtual void visit(Circle &s) = 0;
virtual void visit(Triangle &s) = 0;
}; };
#endif // VISITOR_H #endif // VISITOR_H

5
src/main.cpp
View File

@ -19,10 +19,7 @@ int main(int argc, char *argv[])
// Instantiate and layout the viewer. // Instantiate and layout the viewer.
Viewer *v = new Viewer(); Viewer *v = new Viewer();
w.addViewer(v); w.addViewer(v);
//w.setFixedSize(dw.width() * 0.7, dw.height() * 0.7);
w.show(); w.show();
return a.exec(); return a.exec();

186
src/viewer/simpleViewer.cpp
View File

@ -41,9 +41,7 @@ using namespace std;
namespace namespace
{ {
const int numVerticesSquare = 5; const int numVerticesCube = 12*3;
const int numVerticesTriangle = 3;
const int numVerticesCircle = 26;
const double frame_limit = 5; const double frame_limit = 5;
const double inc_mult = 5; const double inc_mult = 5;
const double inc_offset = 1.05; const double inc_offset = 1.05;
@ -53,7 +51,7 @@ Viewer::Viewer()
{ {
activeColor = new QColor(255, 255, 255, 255); activeColor = new QColor(255, 255, 255, 255);
activeCell = nullptr; activeCell = nullptr;
activeShape = 0; activeShape = 0;
} }
Viewer::~Viewer() Viewer::~Viewer()
@ -78,42 +76,48 @@ void Viewer::cleanup()
void Viewer::draw() void Viewer::draw()
{ {
// Bind our vertex/fragment shaders m_program->bind();
m_program->bind();
// Get projection and camera transformations // Get projection and camera transformations
QMatrix4x4 projectionMatrix; QMatrix4x4 projectionMatrix;
QMatrix4x4 modelViewMatrix; QMatrix4x4 modelViewMatrix;
camera()->getProjectionMatrix(projectionMatrix); camera()->getProjectionMatrix(projectionMatrix);
camera()->getModelViewMatrix(modelViewMatrix); camera()->getModelViewMatrix(modelViewMatrix);
// Prepare a transformation stack // Prepare a transformation stack
// stack<QMatrix4x4> modelStack; // stack<QMatrix4x4> modelStack;
modelViewMatrix.translate(-4.5, -4.5);
modelViewMatrix.scale(0.95); modelViewMatrix.scale(0.95);
modelViewMatrix.rotate(45, 0, 1, 0);
m_program->setUniformValue(m_projMatrixLocation, projectionMatrix); rot = QQuaternion::fromAxisAndAngle(1, 0, 1, 90/60 * frame);
m_program->setUniformValue(m_mvMatrixLocation, modelViewMatrix); // uncomment this and the cube translation in init()
// to see the cube spin
modelViewMatrix.rotate(rot);
projectionMatrix.translate(0, -5, 0);
projectionMatrix.rotate(15, 1, 0, 0);
m_program->setUniformValue(m_projMatrixLocation, projectionMatrix);
m_program->setUniformValue(m_mvMatrixLocation, modelViewMatrix);
// Traverse the Scene in order to draw its components // Traverse the Scene in order to draw its components
modelStack.push(modelViewMatrix); modelStack.push(modelViewMatrix);
//root.accept(*this); root.accept(*this);
frame++;
update();
} }
void Viewer::mouseMoveEvent(QMouseEvent* e) { void Viewer::mouseMoveEvent(QMouseEvent* e) {
cout << "Viewer::mouseMoveEvent(QMouseEvent* e)" << endl; cout << "Viewer::mouseMoveEvent(QMouseEvent* e)" << endl;
// Normal QGLViewer behavior. // Normal QGLViewer behavior.
//QGLViewer::mouseMoveEvent(e); //QGLViewer::mouseMoveEvent(e);
} }
void Viewer::mousePressEvent(QMouseEvent* e) { void Viewer::mousePressEvent(QMouseEvent* e) {
// Auto Return, but old code left in as reference // Auto Return, but old code left in as reference
return; return;
cout << "Viewer::mouseMoveEvent(QMouseEvent* e) : " << e->button() << endl; /*cout << "Viewer::mouseMoveEvent(QMouseEvent* e) : " << e->button() << endl;
if(e->button() == 1){ // LMB if(e->button() == 1){ // LMB
@ -135,23 +139,23 @@ void Viewer::mousePressEvent(QMouseEvent* e) {
Shape* s = nullptr; Shape* s = nullptr;
if(activeShape == 1){ if(activeShape == 1){
s = new Triangle(); s = new Triangle();
}else if(activeShape == 2){ }else if(activeShape == 2){
s = new Square(); s = new Square();
}else if(activeShape == 3){ }else if(activeShape == 3){
s = new Circle(); s = new Circle();
} }
// WARNING: END OF CODE DEGEULASSE // WARNING: END OF CODE DEGEULASSE
//activeCell->getChildren()->at(0) = s; //activeCell->getChildren()->at(0) = s;
if(s != nullptr){ if(s != nullptr){
s->setColor(*activeColor); s->setColor(*activeColor);
cell->addChild(s); cell->addChild(s);
this->update(); this->update();
deselect(); deselect();
activeCell = cell; activeCell = cell;
} }
} }
} }
@ -170,7 +174,7 @@ void Viewer::mousePressEvent(QMouseEvent* e) {
int shapeId = 0; int shapeId = 0;
if(typeid(*(activeCell->getChildren()->at(0))) == typeid(Triangle)) if(typeid(*(activeCell->getChildren()->at(0))) == typeid(Triangle))
shapeId = 1; shapeId = 1;
if(typeid(*(activeCell->getChildren()->at(0))) == typeid(Square)) if(typeid(*(activeCell->getChildren()->at(0))) == typeid(Square))
shapeId = 2; shapeId = 2;
if(typeid(*(activeCell->getChildren()->at(0))) == typeid(Circle)) if(typeid(*(activeCell->getChildren()->at(0))) == typeid(Circle))
shapeId = 3; shapeId = 3;
@ -179,7 +183,7 @@ void Viewer::mousePressEvent(QMouseEvent* e) {
emit shapeSelected(0); emit shapeSelected(0);
} }
} }
} }//*/
} }
void Viewer::deselect(){ void Viewer::deselect(){
@ -204,13 +208,13 @@ void Viewer::mouseReleaseEvent(QMouseEvent* e) {
void Viewer::init() void Viewer::init()
{ {
// We want to restrict ourselves to a 2D viewer. // We want to restrict ourselves to a 2D viewer.
//camera()->setType(qglviewer::Camera::ORTHOGRAPHIC); //camera()->setType(qglviewer::Camera::ORTHOGRAPHIC);
/*setMouseBinding(Qt::NoModifier, Qt::LeftButton, CAMERA, SCREEN_ROTATE); setMouseBinding(Qt::NoModifier, Qt::LeftButton, CAMERA, SCREEN_ROTATE);
setMouseBinding(Qt::AltModifier, Qt::LeftButton, CAMERA, NO_MOUSE_ACTION);*/ //setMouseBinding(Qt::AltModifier, Qt::LeftButton, CAMERA, NO_MOUSE_ACTION);//*/
// setMouseBinding(Qt::NoModifier, Qt::MouseButton(Qt::LeftButton + Qt::MidButton), CAMERA, NO_MOUSE_ACTION); //setMouseBinding(Qt::NoModifier, Qt::MouseButton(Qt::LeftButton + Qt::MidButton), CAMERA, NO_MOUSE_ACTION);
// setMouseBinding(Qt::ControlModifier, Qt::MouseButton(Qt::LeftButton + Qt::MidButton), CAMERA, NO_MOUSE_ACTION); //setMouseBinding(Qt::ControlModifier, Qt::MouseButton(Qt::LeftButton + Qt::MidButton), CAMERA, NO_MOUSE_ACTION);
// setMouseBinding(Qt::ShiftModifier, Qt::MouseButton(Qt::LeftButton + Qt::MidButton), CAMERA, NO_MOUSE_ACTION); //setMouseBinding(Qt::ShiftModifier, Qt::MouseButton(Qt::LeftButton + Qt::MidButton), CAMERA, NO_MOUSE_ACTION);
// Our scene will be from -5 to 5 in X and Y (the grid will be 10x10). // Our scene will be from -5 to 5 in X and Y (the grid will be 10x10).
setSceneRadius(5); setSceneRadius(5);
@ -223,7 +227,15 @@ void Viewer::init()
// Init shaders & geometry // Init shaders & geometry
initShaders(); initShaders();
initGeometries(); initGeometries();
//initGrid();
Shape* cube = new Cube();
cube->setColor(*activeColor);
// uncomment this and the quaternion transformation in draw()
// to see the cube rotate.
// cube->transform.translate(3, 0, 0);
SceneGroup *c = new SceneGroup();
c->addChild(cube);
root.addChild(c);
} }
void Viewer::initShaders() void Viewer::initShaders()
@ -261,8 +273,9 @@ void Viewer::initShaders()
// Creates the basic shapes in memory. We only have 3, so we just prep them all in advance. // Creates the basic shapes in memory. We only have 3, so we just prep them all in advance.
void Viewer::initGeometries() void Viewer::initGeometries()
{ {
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable( GL_BLEND ); glClearColor(0.0,0.0,0.0,0.0); glEnable( GL_BLEND );
glClearColor(0.0,0.0,0.0,0.0);
// Create our VertexArrays Objects and VertexBuffer Objects // Create our VertexArrays Objects and VertexBuffer Objects
glGenVertexArrays(NumVAOs, m_VAOs); glGenVertexArrays(NumVAOs, m_VAOs);
@ -270,92 +283,47 @@ void Viewer::initGeometries()
// Create our pentagone object, store its vertices on the graphic card, and // Create our pentagone object, store its vertices on the graphic card, and
// bind the data to the vPosition attribute of the shader // bind the data to the vPosition attribute of the shader
GLfloat verticesSquare[numVerticesSquare][3] = { GLfloat verticesCube[numVerticesCube][3] = { // 12 triangles == 6 squares
{ -0.5, 0.5, 0 }, //Front, if Z is towards us
{ -0.5, -0.5, 0 }, { -0.5, 0.5, 0.5 }, { -0.5, -0.5, 0.5 }, { 0.5, -0.5, 0.5 },
{ 0.5, -0.5, 0 }, { 0.5, -0.5, 0.5 }, { 0.5, 0.5, 0.5 }, { -0.5, 0.5, 0.5 },
{ 0.5, 0.5, 0 }, //Back
{ -0.5, 0.5, 0 } { -0.5, 0.5, -0.5 }, { 0.5, 0.5, -0.5 }, { 0.5, -0.5, -0.5 },
{ 0.5, -0.5, -0.5 }, { -0.5, -0.5, -0.5 }, { -0.5, 0.5, -0.5 },
//Right
{ -0.5, 0.5, 0.5 }, { -0.5, 0.5, -0.5 }, { -0.5, -0.5, -0.5 },
{ -0.5, -0.5, -0.5 }, { -0.5, -0.5, 0.5 }, { -0.5, 0.5, 0.5 },
//Left
{ 0.5, 0.5, 0.5 }, { 0.5, -0.5, -0.5 }, { 0.5, 0.5, -0.5 },
{ 0.5, -0.5, -0.5 }, { 0.5, 0.5, 0.5 }, { 0.5, -0.5, 0.5 },
//Top
{ -0.5, 0.5, 0.5 }, { 0.5, 0.5, 0.5 }, { 0.5, 0.5, -0.5 },
{ 0.5, 0.5, -0.5 }, { -0.5, 0.5, -0.5 }, { -0.5, 0.5, 0.5 },
//Bottom
{ -0.5, -0.5, 0.5 }, { 0.5, -0.5, 0.5 }, { 0.5, -0.5, -0.5 },
{ 0.5, -0.5, -0.5 }, { -0.5, -0.5, -0.5 }, { -0.5, -0.5, 0.5 }
}; };
glBindVertexArray(m_VAOs[VAO_Square]); glBindVertexArray(m_VAOs[VAO_Cube]);
glBindBuffer(GL_ARRAY_BUFFER, m_Buffers[VBO_Square]); glBindBuffer(GL_ARRAY_BUFFER, m_Buffers[VBO_Cube]);
glBufferData(GL_ARRAY_BUFFER, sizeof(verticesSquare), verticesSquare, GL_STATIC_DRAW); glBufferData(GL_ARRAY_BUFFER, sizeof(verticesCube), verticesCube, GL_STATIC_DRAW);
glVertexAttribPointer(m_vPositionLocation, 3, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0));
glEnableVertexAttribArray(m_vPositionLocation);
// Create our triangle object, store its vertices on the graphic card, and
// bind the data to the vPosition attribute of the shader
GLfloat verticesTriangle[numVerticesTriangle][3] = {
{ -0.5, -0.5, 0.0 },
{ 0.5, -0.5, 0.0 },
{ 0.0, 0.5, 0.0 }
};
glBindVertexArray(m_VAOs[VAO_Triangle]);
glBindBuffer(GL_ARRAY_BUFFER, m_Buffers[VBO_Triangle]);
glBufferData(GL_ARRAY_BUFFER, sizeof(verticesTriangle), verticesTriangle, GL_STATIC_DRAW);
glVertexAttribPointer(m_vPositionLocation, 3, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0));
glEnableVertexAttribArray(m_vPositionLocation);
// Create our Circle Object, and store its vertices with its bindings
GLfloat verticesCircle[numVerticesCircle][3];
const float PI = 3.1415926f;
double increment = 2.0f * PI / (numVerticesCircle - 2);
verticesCircle[0][0] = 0;
verticesCircle[0][1] = 0;
verticesCircle[0][2] = 0;
for(int i = 1; i < numVerticesCircle; i++) {
double angle = increment * (i);
verticesCircle[i][0] = 0.5 * cos(angle);
verticesCircle[i][1] = 0.5 * sin(angle);
verticesCircle[i][2] = 0;
}
glBindVertexArray(m_VAOs[VAO_Circle]);
glBindBuffer(GL_ARRAY_BUFFER, m_Buffers[VBO_Circle]);
glBufferData(GL_ARRAY_BUFFER, sizeof(verticesCircle), verticesCircle, GL_STATIC_DRAW);
glVertexAttribPointer(m_vPositionLocation, 3, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0)); glVertexAttribPointer(m_vPositionLocation, 3, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0));
glEnableVertexAttribArray(m_vPositionLocation); glEnableVertexAttribArray(m_vPositionLocation);
} }
void Viewer::visit(Square &s) void Viewer::visit(Cube &s)
{ {
QMatrix4x4 modelViewMatrix = modelStack.top() * QMatrix4x4(s.transform); QMatrix4x4 modelViewMatrix = modelStack.top() * QMatrix4x4(s.transform);
glBindVertexArray(m_VAOs[VAO_Square]); int faces = floor(numVerticesCube/6);
m_program->setUniformValue(m_mvMatrixLocation, modelViewMatrix); for(int i = 0; i < faces; i++){ // 6 vertexes par face
m_program->setUniformValue(m_colorLocation, s.color); glBindVertexArray(m_VAOs[VAO_Cube]);
m_program->setUniformValue(m_mvMatrixLocation, modelViewMatrix);
m_program->setUniformValue(m_colorLocation, QColor::fromHsv(360/6*i, 255, 255, 200));
glDrawArrays(GL_TRIANGLE_FAN, 0, numVerticesSquare); glDrawArrays(GL_TRIANGLES, i*6, 6);
} }
void Viewer::visit(Circle &s)
{
QMatrix4x4 modelViewMatrix = modelStack.top() * QMatrix4x4(s.transform);
glBindVertexArray(m_VAOs[VAO_Circle]);
m_program->setUniformValue(m_mvMatrixLocation, modelViewMatrix);
m_program->setUniformValue(m_colorLocation, s.color);
glDrawArrays(GL_TRIANGLE_FAN, 0, numVerticesCircle);
}
void Viewer::visit(Triangle &s)
{
QMatrix4x4 modelViewMatrix = modelStack.top() * QMatrix4x4(s.transform);
glBindVertexArray(m_VAOs[VAO_Triangle]);
m_program->setUniformValue(m_mvMatrixLocation, modelViewMatrix);
m_program->setUniformValue(m_colorLocation, s.color);
glDrawArrays(GL_TRIANGLES, 0, numVerticesTriangle);
} }
void Viewer::visit(SceneGroup &s) void Viewer::visit(SceneGroup &s)

11
src/viewer/simpleViewer.h
View File

@ -44,9 +44,7 @@ public:
~Viewer(); ~Viewer();
virtual void visit(SceneGroup &s); virtual void visit(SceneGroup &s);
virtual void visit(Square &s); virtual void visit(Cube &s);
virtual void visit(Circle &s);
virtual void visit(Triangle &s);
public slots: public slots:
void cleanup(); void cleanup();
@ -81,13 +79,16 @@ private:
QColor* activeColor; QColor* activeColor;
int activeShape; int activeShape;
enum VAO_IDs { VAO_Square, VAO_Triangle, VAO_Circle, NumVAOs }; enum VAO_IDs { VAO_Cube, NumVAOs };
enum Buffer_IDs { VBO_Square, VBO_Triangle, VBO_Circle, NumBuffers }; enum Buffer_IDs { VBO_Cube, NumBuffers };
GLuint m_VAOs[NumVAOs]; GLuint m_VAOs[NumVAOs];
GLuint m_Buffers[NumBuffers]; GLuint m_Buffers[NumBuffers];
Shape* generateShapeFromIndex(int); Shape* generateShapeFromIndex(int);
QQuaternion rot;
unsigned int frame;
}; };
#endif // SIMPLEVIEWER_H #endif // SIMPLEVIEWER_H