I am trying to draw a Sphere using OpenGL and C++, but I can't use the glut Sphere function. I am passing the coordinates (x, y, z), the color white (1.0f, 1.0f, 1.0f) and saving sequentially in the vertex array (vertices).
/** Vertex shader. */
const char *vertex_code = "\n"
"#version 330 core\n"
"layout (location = 0) in vec3 position;\n"
"layout (location = 1) in vec3 color;\n"
"\n"
"out vec3 vColor;\n"
"\n"
"uniform mat4 model;\n"
"uniform mat4 view;\n"
"uniform mat4 projection;\n"
"\n"
"void main()\n"
"{\n"
" gl_Position = projection * view * model * vec4(position, 1.0);\n"
" vColor = color;\n"
"}\0";
/** Fragment shader. */
const char *fragment_code = "\n"
"#version 330 core\n"
"\n"
"in vec3 vColor;\n"
"out vec4 FragColor;\n"
"\n"
"void main()\n"
"{\n"
" FragColor = vec4(vColor, 1.0f);\n"
"}\0";
void display(){
glClearColor(0.2, 0.3, 0.3, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glUseProgram(program);
// Define view matrix.
glm::mat4 view = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -3.0f));
// Retrieve location of tranform variable in shader.
unsigned int loc = glGetUniformLocation(program, "view");
// Send matrix to shader.
glUniformMatrix4fv(loc, 1, GL_FALSE, glm::value_ptr(view));
// Define projection matrix.
glm::mat4 projection = glm::perspective(glm::radians(60.0f), (win_width/(float)win_height), 0.1f, 100.0f);
// Retrieve location of tranform variable in shader.
loc = glGetUniformLocation(program, "projection");
// Send matrix to shader.
glUniformMatrix4fv(loc, 1, GL_FALSE, glm::value_ptr(projection));
// Pyramid
glBindVertexArray(VAO2);
// Define model matrix.
glm::mat4 S = glm::scale(glm::mat4(1.0f), glm::vec3(1.0f, 1.0f, 1.0f));
glm::mat4 Rx = glm::rotate(glm::mat4(1.0f), glm::radians(px_angle), glm::vec3(1.0f,0.0f,0.0f));
glm::mat4 Ry = glm::rotate(glm::mat4(1.0f), glm::radians(py_angle), glm::vec3(0.0f,1.0f,0.0f));
glm::mat4 T = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -1.0f));
glm::mat4 model = T*Ry*Rx*S;
// Retrieve location of tranform variable in shader.
loc = glGetUniformLocation(program, "model");
// Send matrix to shader.
glUniformMatrix4fv(loc, 1, GL_FALSE, glm::value_ptr(model));
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glDrawArrays(GL_POINTS, 0, 10 * 20 * 20);
glutSwapBuffers();
}
void initData(float radius, float stacks, float sectors){
float *vertices;
int quantidade = 0;
vertices = (float *) malloc(radius * stacks * sectors * 6 * sizeof(float));
if(!vertices){
printf("Erro ao alocar memória!\n");
exit(-1);
}
const float pi = 3.14159265359;
const float deltaPhi = pi/stacks;
const float deltaTheta = (2 * pi)/sectors;
for(int i=0; i<=stacks; i++){
float phi = (-pi / 2.0) + (i * deltaPhi);
float temp = radius * cos(phi);
float z = radius * sin(phi);
for(int j=0; j<=sectors; j++){
float theta = j * deltaTheta;
float y = temp * sin(theta);
float x = temp * cos(theta);
// normalize
x = x / radius;
y = y / radius;
z = z / radius;
vertices[quantidade++] = x;
vertices[quantidade++] = y;
vertices[quantidade++] = z;
vertices[quantidade++] = 1.0f;
vertices[quantidade++] = 1.0f;
vertices[quantidade++] = 1.0f;
}
}
// Vertex array.
glGenVertexArrays(1, &VAO2);
glBindVertexArray(VAO2);
// Vertex buffer
glGenBuffers(1, &VBO2);
glBindBuffer(GL_ARRAY_BUFFER, VBO2);
glBufferData(GL_ARRAY_BUFFER, sizeof(float) * radius * stacks * sectors * 6, vertices, GL_STATIC_DRAW);
// Set attributes.
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6*sizeof(float), (void*)0);
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6*sizeof(float), (void*)(3*sizeof(float)));
glEnableVertexAttribArray(1);
// Unbind Vertex Array Object.
glBindVertexArray(0);
glEnable(GL_DEPTH_TEST);
int main(int argc, char** argv){
glutInit(&argc, argv);
glutInitContextVersion(3, 3);
glutInitContextProfile(GLUT_CORE_PROFILE);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
glutInitWindowSize(win_width,win_height);
glutCreateWindow(argv[0]);
glewExperimental = GL_TRUE;
glewInit();
// Init vertex data for the sphere
initData(10.0, 20.0, 20.0);
// Create shaders.
initShaders();
glutReshapeFunc(reshape);
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
//glutIdleFunc(idle);
glutMainLoop();
}
And the final result is this:
https://i.imgur.com/b7EwhVG.png
https://i.imgur.com/Piopsgw.png
What am I doing wrong? I am using this link ( http://www.songho.ca/opengl/gl_sphere.html ) as a reference.
void desenhaEsfera(int nx, int ny) {
float alfa, beta;
float x1, y1, z1, x2, y2, z2;
alfa = (2*pi)/nx;
beta = pi/ny;
glPolygonMode(GL_FRONT, GL_LINE);
for(int j=0; j<=ny; j++){
glBegin(GL_TRIANGLE_STRIP);
for(int i=0; i<=nx; i++){
x1 = cos(alfa*i)*sin(beta*j);
y1 = cos(beta*j);
z1 = sin(alfa*i)*sin(beta*j);
x2 = cos(alfa*i)*sin(beta*(j+1));
y2 = cos(beta*(j+1));
z2 = sin(alfa*i)*sin(beta*(j+1));
glNormal3f(x1, y1, z1);
glVertex3f(x1, y1, z1);
glNormal3f(x2, y2, z2);
glVertex3f(x2, y2, z2);
}
glEnd();
}
}
The technical post webpages of this site follow the CC BY-SA 4.0 protocol. If you need to reprint, please indicate the site URL or the original address.Any question please contact:yoyou2525@163.com.