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

Merging and tweaking issues 1 and 11

Browse Source
This commit is contained in:
Dmitri K 2016-11-09 14:34:54 -05:00
commit c5fbaac3fd
7 changed files with 93 additions and 176 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -48,3 +48,4 @@ release
*_LOCAL_*
*_BASE_*
*_REMOTE_*
*.orig

33
src/glnodes/shapes.cpp
View File

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

22
src/glnodes/shapes.h
View File

@ -11,28 +11,10 @@ public:
virtual QColor getColor() = 0;
};
class Circle : public Shape
class Cube : public Shape
{
public:
Circle(){}
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(){}
Cube(){}
QColor color;
void accept(Visitor& v) override;
void setColor(QColor& c);

8
src/interfaces/visitor.h
View File

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

3
src/main.cpp
View File

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

185
src/viewer/simpleViewer.cpp
View File

@ -41,12 +41,10 @@ using namespace std;
namespace
{
const int numVerticesSquare = 5;
const int numVerticesTriangle = 3;
const int numVerticesCircle = 26;
const double frame_limit = 5;
const double inc_mult = 5;
const double inc_offset = 1.05;
const int numVerticesCube = 12*3;
const double frame_limit = 5;
const double inc_mult = 5;
const double inc_offset = 1.05;
}
Viewer::Viewer()
@ -90,10 +88,16 @@ void Viewer::draw()
// Prepare a transformation stack
// stack<QMatrix4x4> modelStack;
modelViewMatrix.translate(-4.5, -4.5);
modelViewMatrix.scale(0.95);
//modelViewMatrix.rotate(45, 0, 1, 0);
// uncomment this and the cube translation in init()
// to see the cube spin
/*rot = QQuaternion::fromAxisAndAngle(1, 0, 1, 90/60 * frame);
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);
@ -101,6 +105,7 @@ void Viewer::draw()
modelStack.push(modelViewMatrix);
root.accept(*this);
frame++;
update();
}
@ -112,6 +117,8 @@ void Viewer::mouseMoveEvent(QMouseEvent* e) {
void Viewer::mousePressEvent(QMouseEvent* e) {
// Auto Return, but old code left in as reference
// TODO: figure out how to get this weird offset ↓↓ frame position maybe?
int x = this->x() + e->x() + 10;
int y = this->parentWidget()->height() - e->y() + 21;
std::cout << "--------------------------------------------------\nPicking shape at " << x << " (" << this->x() << " + " << e->x() << "), " << y << endl;
@ -162,15 +169,19 @@ void Viewer::init()
// Init shaders & geometry
initShaders();
initGeometries();
//initGrid();
/*QColor* color = new QColor(255, 128, 0, 255);
Circle* c = new Circle;
c->setColor(*color);
SceneGroup* cell = new SceneGroup;
cell->addChild(c);
root.addChild(cell);//*/
//update();
{
Shape* cube = new Cube();
cube->setColor(*activeColor);
// uncomment this and the quaternion transformation in draw()
// to see the cube rotate. This is how we can easily make the sun.
// cube->transform.translate(3, 0, 0);
SceneGroup *c = new SceneGroup();
c->addChild(cube);
root.addChild(c);
}
}
void Viewer::initShaders()
@ -237,8 +248,12 @@ void Viewer::initShaders()
// Creates the basic shapes in memory. We only have 3, so we just prep them all in advance.
void Viewer::initGeometries()
{
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable( GL_BLEND ); glClearColor(0.0,0.0,0.0,0.0);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable( GL_BLEND );
glEnable( GL_CULL_FACE );
glFrontFace( GL_CCW );
glCullFace( GL_BACK );
glClearColor(0.0,0.0,0.0,0.0);
// Create our VertexArrays Objects and VertexBuffer Objects
glGenVertexArrays(NumVAOs, m_VAOs);
@ -246,92 +261,47 @@ void Viewer::initGeometries()
// Create our pentagone object, store its vertices on the graphic card, and
// bind the data to the vPosition attribute of the shader
GLfloat verticesSquare[numVerticesSquare][3] = {
{ -0.5, 0.5, 0 },
{ -0.5, -0.5, 0 },
{ 0.5, -0.5, 0 },
{ 0.5, 0.5, 0 },
{ -0.5, 0.5, 0 }
GLfloat verticesCube[numVerticesCube][3] = { // 12 triangles == 6 squares
//Front, if Z is towards us
{ -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 },
//Back
{ -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]);
glBindBuffer(GL_ARRAY_BUFFER, m_Buffers[VBO_Square]);
glBufferData(GL_ARRAY_BUFFER, sizeof(verticesSquare), verticesSquare, GL_STATIC_DRAW);
glBindVertexArray(m_VAOs[VAO_Cube]);
glBindBuffer(GL_ARRAY_BUFFER, m_Buffers[VBO_Cube]);
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 }
};
void Viewer::visit(Cube &s)
{
QMatrix4x4 modelViewMatrix = modelStack.top() * QMatrix4x4(s.transform);
glBindVertexArray(m_VAOs[VAO_Triangle]);
glBindBuffer(GL_ARRAY_BUFFER, m_Buffers[VBO_Triangle]);
glBufferData(GL_ARRAY_BUFFER, sizeof(verticesTriangle), verticesTriangle, GL_STATIC_DRAW);
int faces = floor(numVerticesCube/6);
for(int i = 0; i < faces; i++){ // 6 vertexes par face
glBindVertexArray(m_VAOs[VAO_Cube]);
m_program->setUniformValue(m_mvMatrixLocation, modelViewMatrix);
m_program->setUniformValue(m_colorLocation, s.getColor());
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;
glDrawArrays(GL_TRIANGLES, i*6, 6);
}
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));
glEnableVertexAttribArray(m_vPositionLocation);
}
void Viewer::visit(Square &s)
{
QMatrix4x4 modelViewMatrix = modelStack.top() * QMatrix4x4(s.transform);
glBindVertexArray(m_VAOs[VAO_Square]);
m_program->setUniformValue(m_mvMatrixLocation, modelViewMatrix);
m_program->setUniformValue(m_colorLocation, s.color);
glDrawArrays(GL_TRIANGLE_FAN, 0, numVerticesSquare);
}
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)
@ -364,7 +334,7 @@ void Viewer::changeColor(QColor c){
Shape* Viewer::pickGeom(int x, int y){
QMap<QRgb, Shape*> mapColorToShape;
QColor c;
QRgb startColor = 0xFFFF00ee; // alpha must be 100%, glReadPixels doesn't resturn alpha
QRgb startColor = 0xFF0001; // alpha must be 100%, glReadPixels doesn't resturn alpha
unsigned char pixelData[3];
// Traverse tree
/* TODO: Make this recurse through SceneGroups, with like "populateMap(map, root, color)"
@ -390,35 +360,34 @@ Shape* Viewer::pickGeom(int x, int y){
if(currentCube)
{
c.setRgba(startColor);
mapColorToShape.insert(c.rgba(), currentCube);
c.setRgb(startColor);
mapColorToShape.insert(c.rgb(), currentCube);
std::cout << "Setting " << currentCube << " to " << c.red() << " " << c.green() << " " << c.blue() << " " << c.alpha() << endl;
currentCube->setColor(c);
startColor++;
startColor+=6;
}
}
root.accept(*this);
update();
draw();
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
// for debugging purposes
/*QImage *im = new QImage(64, 64, QImage::Format_RGB32);
for(int i = 0; i< 64; i++){
for(int j = 0; j< 64; j++){
glReadPixels(x-31+i, y+31-j, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, pixelData);
/*QImage *im = new QImage(128,128, QImage::Format_RGB32);
for(int i = 0; i< 128; i++){
for(int j = 0; j< 128; j++){
glReadPixels(x-64+i, y+64-j, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, pixelData);
QColor* pickedColor = new QColor(pixelData[0], pixelData[1], pixelData[2]);
if(i==32&&j==32) pickedColor->setRgba(0xFFFFFFFF);
if(i==64&&j==64) pickedColor->setRgba(0xFFFFFFFF);
im->setPixelColor(i, j, pickedColor->rgb());
}
}
im->save("./screenshot.bmp");//*/
// TODO: figure out how to get this weird offset ↓↓ frame position maybe?
glReadPixels(x, y, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, pixelData);
QColor* pickedColor = new QColor(pixelData[0], pixelData[1], pixelData[2]);
Shape* pickedShape = mapColorToShape.value(pickedColor->rgba());
unsigned int pickedInt = pickedColor->rgb();
Shape* pickedShape = mapColorToShape.value(pickedInt - (pickedInt % 6) + 1);
std::cout << "Picked Color: " << pickedColor->red() << " " << pickedColor->green() << " " << pickedColor->blue() << " " << pickedColor->alpha() << endl;
std::cout << "Picked Shape: " << pickedShape << endl;

11
src/viewer/simpleViewer.h
View File

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