//------------------------------------------------------------------------------
int main(int argc, char **argv ){
// init GLUT and create Window
glutInit( &argc, argv );
glutInitDisplayMode( GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA );
glutInitWindowSize( 320, 320 );
glutCreateWindow( "Onion World" );
initializeProgram();
initializeVertexBuffer();
initializeVertexArrayObjects();
glEnable( GL_CULL_FACE );
glCullFace( GL_BACK );
glFrontFace( GL_CW );
glEnable( GL_DEPTH_TEST );
glDepthMask( GL_TRUE );
glDepthFunc( GL_LEQUAL );
glDepthRange( 0.0, 1.0f );
// register callbacks
glutDisplayFunc( renderScene );
glutReshapeFunc( reshape );
glutKeyboardFunc( keyPressed );
glutMainLoop();
return EXIT_SUCCESS;
}
void init()
{
initializeProgram();
initializeVertexBuffer();
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
}
void QGLView::setupCube()
{
static const ModelVertex vertices[] = {
// Front face
{{0.0f, 1.0f, 1.0f}, {0.0f, 0.0f, 1.0f}},
{{0.0f, 0.0f, 1.0f}, {0.0f, 0.0f, 1.0f}},
{{1.0f, 1.0f, 1.0f}, {0.0f, 0.0f, 1.0f}},
{{0.0f, 0.0f, 1.0f}, {0.0f, 0.0f, 1.0f}},
{{1.0f, 0.0f, 1.0f}, {0.0f, 0.0f, 1.0f}},
{{1.0f, 1.0f, 1.0f}, {0.0f, 0.0f, 1.0f}},
// Right face
{{1.0f, 1.0f, 1.0f}, {1.0f, 0.0f, 0.0f}},
{{1.0f, 0.0f, 1.0f}, {1.0f, 0.0f, 0.0f}},
{{1.0f, 1.0f, 0.0f}, {1.0f, 0.0f, 0.0f}},
{{1.0f, 0.0f, 1.0f}, {1.0f, 0.0f, 0.0f}},
{{1.0f, 0.0f, 0.0f}, {1.0f, 0.0f, 0.0f}},
{{1.0f, 1.0f, 0.0f}, {1.0f, 0.0f, 0.0f}},
// Back face
{{1.0f, 1.0f, 0.0f}, {0.0f, 0.0f, -1.0f}},
{{1.0f, 0.0f, 0.0f}, {0.0f, 0.0f, -1.0f}},
{{0.0f, 1.0f, 0.0f}, {0.0f, 0.0f, -1.0f}},
{{1.0f, 0.0f, 0.0f}, {0.0f, 0.0f, -1.0f}},
{{0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, -1.0f}},
{{0.0f, 1.0f, 0.0f}, {0.0f, 0.0f, -1.0f}},
// Left face
{{0.0f, 1.0f, 0.0f}, {-1.0f, 0.0f, 0.0f}},
{{0.0f, 0.0f, 0.0f}, {-1.0f, 0.0f, 0.0f}},
{{0.0f, 1.0f, 1.0f}, {-1.0f, 0.0f, 0.0f}},
{{0.0f, 0.0f, 0.0f}, {-1.0f, 0.0f, 0.0f}},
{{0.0f, 0.0f, 1.0f}, {-1.0f, 0.0f, 0.0f}},
{{0.0f, 1.0f, 1.0f}, {-1.0f, 0.0f, 0.0f}},
// Top face
{{0.0f, 1.0f, 0.0f}, {0.0f, 1.0f, 0.0f}},
{{0.0f, 1.0f, 1.0f}, {0.0f, 1.0f, 0.0f}},
{{1.0f, 1.0f, 0.0f}, {0.0f, 1.0f, 0.0f}},
{{0.0f, 1.0f, 1.0f}, {0.0f, 1.0f, 0.0f}},
{{1.0f, 1.0f, 1.0f}, {0.0f, 1.0f, 0.0f}},
{{1.0f, 1.0f, 0.0f}, {0.0f, 1.0f, 0.0f}},
// Bottom face
{{1.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}},
{{1.0f, 0.0f, 1.0f}, {0.0f, 0.0f, 0.0f}},
{{0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}},
{{1.0f, 0.0f, 1.0f}, {0.0f, 0.0f, 0.0f}},
{{0.0f, 0.0f, 1.0f}, {0.0f, 0.0f, 0.0f}},
{{0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}}
};
initializeVertexBuffer(Cube, vertices, sizeof(vertices));
addDrawableList(Cube);
}
void QGLView::setupSphere(int detail)
{
QVector<ModelVertex> rawVertices;
QVector<ModelVertex> vertices;
int latitudeBands = detail;
int longitudeBands = detail;
GLfloat radius = 1.0;
for (int latNumber = 0; latNumber <= latitudeBands; ++latNumber)
{
GLfloat theta = (GLfloat)latNumber * M_PI / (GLfloat)latitudeBands;
GLfloat sinTheta = qSin(theta);
GLfloat cosTheta = qCos(theta);
for (int longNumber = 0; longNumber <= longitudeBands; ++longNumber)
{
GLfloat phi = (GLfloat)longNumber * 2.0 * M_PI / (GLfloat)longitudeBands;
GLfloat sinPhi = qSin(phi);
GLfloat cosPhi = qCos(phi);
GLfloat x = cosPhi * sinTheta;
GLfloat y = cosTheta;
GLfloat z = sinPhi * sinTheta;
ModelVertex modelVertex;
modelVertex.normal.x = x;
modelVertex.normal.y = y;
modelVertex.normal.z = z;
modelVertex.position.x = radius * x;
modelVertex.position.y = radius * y;
modelVertex.position.z = radius * z;
rawVertices.append(modelVertex);
}
}
for (int latNumber = 0; latNumber < latitudeBands; latNumber++) {
for (int longNumber = 0; longNumber < longitudeBands; longNumber++) {
int first = (latNumber * (longitudeBands + 1)) + longNumber;
int second = first + longitudeBands + 1;
vertices.append(rawVertices.at(first));
vertices.append(rawVertices.at(first + 1));
vertices.append(rawVertices.at(second));
vertices.append(rawVertices.at(second));
vertices.append(rawVertices.at(first + 1));
vertices.append(rawVertices.at(second + 1));
}
}
initializeVertexBuffer(Sphere, vertices);
addDrawableList(Sphere);
}
Ball() {
LOGI("init for ball");
fXOffset = 0.0f;
fYOffset = 0.0f;
initializeVertexShader();
initializeFragmentShader();
initializeProgram();
initializeVertexPositions();
initializeVertexBuffer();
positionBufferPointer = glGetAttribLocation(theProgram, "vPosition");
}
//------------------------------------------------------------------------------
int main(int argc, char **argv ){
// init GLUT and create Window
glutInit( &argc, argv );
glutInitDisplayMode( GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA );
glutInitWindowSize( 320, 320 );
glutCreateWindow( "Onion World" );
initializeProgram();
initializeVertexBuffer();
// register callbacks
glutDisplayFunc( renderScene );
glutReshapeFunc( reshape );
glutMainLoop();
return EXIT_SUCCESS;
}
RacketBar(bool userBar) {
if(userBar)
LOGI("Racketbar for user init");
else
LOGI("Racketbar for CPU init");
if(userBar){
fYOffset = -0.8f;
} else {
fYOffset = 0.8f;
}
isUserBar = userBar;
initializeVertexShader();
initializeFragmentShader();
initializeProgram();
initializeVertexPositions();
initializeVertexBuffer();
positionBufferPointer = glGetAttribLocation(theProgram, "vPosition");
}
//------------------------------------------------------------------------------
int main(int argc, char **argv ){
// init GLUT and create Window
glutInit( &argc, argv );
glutInitDisplayMode( GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA );
glutInitWindowSize( 320, 320 );
glutCreateWindow( "Example03" );
initializeProgram();
initializeVertexBuffer();
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glFrontFace(GL_CW);
// register callbacks
glutDisplayFunc( renderScene );
glutReshapeFunc( reshape );
glutMainLoop();
return EXIT_SUCCESS;
}
bool Robot::initialize()
{
#ifdef _WIN32
glGenBuffers = (PFNGLGENBUFFERSARBPROC)wglGetProcAddress("glGenBuffers");
glBindBuffer = (PFNGLBINDBUFFERPROC)wglGetProcAddress("glBindBuffer");
glBufferData = (PFNGLBUFFERDATAPROC)wglGetProcAddress("glBufferData");
#else
glGenBuffers = (PFNGLGENBUFFERSARBPROC)glXGetProcAddress((const GLubyte*)"glGenBuffers");
glBindBuffer = (PFNGLBINDBUFFERPROC)glXGetProcAddress((const GLubyte*)"glBindBuffer");
glBufferData = (PFNGLBUFFERDATAPROC)glXGetProcAddress((const GLubyte*)"glBufferData");
#endif
if (!glGenBuffers || !glBindBuffer || !glBufferData)
{
std::cerr << "VBOs are not supported by your graphics card" << std::endl;
return false;
}
glGenBuffers(LAST_BUFFER, m_vbos); //Generate a buffer for the vertices, indices and colors
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
initializeVertexBuffer(); //Build up the array of vertices for the cube
initializeVertexColors(); //Build up an array of colors for the robot
//Set the vertex pointer for the cube
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_vbos[INDEX_BUFFER]); //Bind the vertex buffer
glBindBuffer(GL_ARRAY_BUFFER, m_vbos[VERTEX_BUFFER]);
glVertexPointer(3, GL_FLOAT, 0, 0);
//Bind the default color as white, this changes depending on the part of the robot we are drawing
glBindBuffer(GL_ARRAY_BUFFER, m_vbos[COLOR_BUFFER]);
glColorPointer(3, GL_FLOAT, 0, BUFFER_OFFSET(WHITE_OFFSET)); //Default color white
return true;
}
void QGLView::setupCylinder(GLfloat r2, QVector3D P2, GLfloat r1, QVector3D P1, int detail, ModelType type)
{
QVector<ModelVertex> vertices;
QVector3D normal;
// normal pointing from origin point to end point
normal = P2 - P1;
// create two perpendicular vectors - perp and q
QVector3D perp = normal;
if ((normal.x() == 0) && (normal.z() == 0)) {
perp.setX(perp.x() + 1);
} else {
perp.setY(perp.y() + 1);
}
// cross product
QVector3D q = QVector3D::crossProduct(perp, normal);
perp = QVector3D::crossProduct(normal, q);
// normalize vectors
perp.normalize();
q.normalize();
// calculate vertices
GLfloat twoPi = 2 * M_PI;
for (int i = 0; i < detail; ++i)
{
GLfloat theta1 = (GLfloat)i / (GLfloat)detail * twoPi; // go around circle and get points
GLfloat theta2 = (GLfloat)(i+1) / (GLfloat)detail * twoPi;
ModelVertex vertex[6];
QVector3D upVector(0,0,1);
QVector3D downVector(0,0,-1);
QVector3D resultVector;
// normals
normal.setX(qCos(theta1) * perp.x() + qSin(theta1) * q.x());
normal.setY(qCos(theta1) * perp.y() + qSin(theta1) * q.y());
normal.setZ(qCos(theta1) * perp.z() + qSin(theta1) * q.z());
// top vertex
vertex[0].position.x = P1.x() + r1 * normal.x();
vertex[0].position.y = P1.y() + r1 * normal.y();
vertex[0].position.z = P1.z() + r1 * normal.z();
resultVector = (upVector + normal).normalized();
vertex[0].normal.x = resultVector.x();
vertex[0].normal.y = resultVector.y();
vertex[0].normal.z = resultVector.z();
// bottom vertex
vertex[1].position.x = P2.x() + r2 * normal.x();
vertex[1].position.y = P2.y() + r2 * normal.y();
vertex[1].position.z = P2.z() + r2 * normal.z();
resultVector = (downVector + normal).normalized();
vertex[1].normal.x = resultVector.x();
vertex[1].normal.y = resultVector.y();
vertex[1].normal.z = resultVector.z();
// normals
normal.setX(qCos(theta2) * perp.x() + qSin(theta2) * q.x());
normal.setY(qCos(theta2) * perp.y() + qSin(theta2) * q.y());
normal.setZ(qCos(theta2) * perp.z() + qSin(theta2) * q.z());
vertex[2].position.x = P2.x() + r2 * normal.x();
vertex[2].position.y = P2.y() + r2 * normal.y();
vertex[2].position.z = P2.z() + r2 * normal.z();
resultVector = (downVector + normal).normalized();
vertex[2].normal.x = resultVector.x();
vertex[2].normal.y = resultVector.y();
vertex[2].normal.z = resultVector.z();
vertex[3].position.x = P1.x() + r1 * normal.x();
vertex[3].position.y = P1.y() + r1 * normal.y();
vertex[3].position.z = P1.z() + r1 * normal.z();
resultVector = (upVector + normal).normalized();
vertex[3].normal.x = resultVector.x();
vertex[3].normal.y = resultVector.y();
vertex[3].normal.z = resultVector.z();
if (r2 != 0.0)
{
vertex[5].position.x = P2.x();
vertex[5].position.y = P2.y();
vertex[5].position.z = P2.z();
vertex[5].normal.x = downVector.x();
vertex[5].normal.y = downVector.y();
vertex[5].normal.z = downVector.z();
vertices.append(vertex[5]);
vertices.append(vertex[2]);
vertices.append(vertex[1]);
}
if (r1 != 0.0)
{
vertex[4].position.x = P1.x();
vertex[4].position.y = P1.y();
vertex[4].position.z = P1.z();
vertex[4].normal.x = upVector.x();
vertex[4].normal.y = upVector.y();
vertex[4].normal.z = upVector.z();
vertices.append(vertex[4]);
vertices.append(vertex[0]);
vertices.append(vertex[3]);
}
// append vertex
vertices.append(vertex[0]);
vertices.append(vertex[1]);
vertices.append(vertex[2]);
vertices.append(vertex[0]);
vertices.append(vertex[2]);
vertices.append(vertex[3]);
}
initializeVertexBuffer(type, vertices);
addDrawableList(type);
}
void QGLView::initializeVertexBuffer(ModelType type, const QVector<ModelVertex> &vertices)
{
initializeVertexBuffer(type, vertices.data(), vertices.length() * sizeof(ModelVertex));
}
