my desired outcome(in red)
Hi, I'm trying to make my code in opengl c++ to produce this(with light coming from (1,1,1)), and it doesn't work and produces this. Can anyone teach me why?
I thought it was about matrices calculation or lighting usage at first, but not so sure anymore.
light function
void init_light(void) {
glLoadIdentity();
glGetFloatv(GL_PROJECTION_MATRIX, ProjectionMat);
ProjectionMatrix = glm::make_mat4(ProjectionMat);
glGetFloatv(GL_MODELVIEW_MATRIX, ViewMat);
ViewMatrix = glm::make_mat4(ViewMat);
glm::mat4 InverseProjectionMatrix = glm::inverse(ProjectionMatrix);
glm::mat4 InverseViewMatrix = glm::inverse(ViewMatrix);
glm::mat4 M = glm::inverse(ProjectionMatrix * ViewMatrix);
glm::mat4 Matr = ProjectionMatrix * ViewMatrix;
glClearColor(1.0, 1.0, 1.0, 0.0);
//glClearDepth(0.0);
GLfloat ambient[] = { 0.2, 0.2, 0.2, 1.0 };
GLfloat diffuse[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat specular[] = { 1.0, 1.0, 1.0, 1.0 };
//GLfloat position0[] = { 1., 1., 1., 0.0 };
//GLfloat position1[] = { 1., 1., 1., 1.0 };
GLfloat pos[] = { (GLfloat)(InverseViewMatrix * glm::make_vec4(position0))[0],
(GLfloat)(InverseViewMatrix * glm::make_vec4(position0))[1],
(GLfloat)(InverseViewMatrix * glm::make_vec4(position0))[2],
(GLfloat)(InverseViewMatrix * glm::make_vec4(position0))[3] };
GLfloat spot_direction[] = { 1.0, 1.0, 1.0 };
glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
glLightfv(GL_LIGHT0, GL_SPECULAR, specular);
glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, spot_direction);
glLightf(GL_LIGHT1, GL_SPOT_CUTOFF, 1.0);
glLightf(GL_LIGHT1, GL_SPOT_EXPONENT, 80.);
//glLightfv(GL_LIGHT0, GL_POSITION, position0);
//glLightfv(GL_LIGHT0, GL_POSITION, pos);
//glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, 2.0);
//glLightfv(GL_LIGHT1, GL_AMBIENT, ambient);
//glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuse);
//glLightfv(GL_LIGHT1, GL_POSITION, position1);
GLfloat mat_ambient[] = { 0.2, 0.2, 0.8, 0.0 };
GLfloat mat_diffuse[] = { 1.0, 1.0, 1.0, 0.0 };
GLfloat mat_specular[] = { 0.5, 0.5, 0.5, 0.0 };
//GLfloat mat_emissive[] = { 0.0, 0.0, 0.0, 0.0 };
GLfloat mat_shininess[] = { 120.0 };
glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
//glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, mat_emissive);
glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
glColorMaterial(GL_FRONT, GL_SHININESS);
glEnable(GL_COLOR_MATERIAL);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHT1);
glEnable(GL_NORMALIZE);
glEnable(GL_AUTO_NORMAL);
glShadeModel(GL_SMOOTH);
glEnable(GL_DEPTH_TEST);
}
rendering scene
void renderScene(void) {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
double ratio = window_size[0] * 1.0 / window_size[1];
if (rotationbool == 1) {
xRot = temp_xRot;
yRot = temp_yRot;
}
glPopMatrix();
gluPerspective(fovy, ratio, zNear + (zoom_factor)* ratio, zFar + (zoom_factor)* ratio);
glLightfv(GL_LIGHT0, GL_POSITION, position0);
glLightfv(GL_LIGHT1, GL_POSITION, position1);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glPopMatrix();
glRotatef(xRot, 1.0, .0, .0);
glRotatef(yRot, .0, 1.0, .0);
glTranslatef(xTrans, yTrans, zTrans);
glPushMatrix(); ...
}
main function
int main(int argc, char* argv[]) {
bool cad_draw = true;
if (cad_draw) {
glutInit(&argc, argv);
}
double L_base[3] = { 0.1, 0.1, 0.1 };
if (cad_draw) {
finemost_limit[0] = L_base[0];
finemost_limit[1] = L_base[1];
finemost_limit[2] = L_base[2];
window_params_init();
//glDepthRange(1.0, 0.);
glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
glutInitWindowPosition(100, 100);
glutInitWindowSize(window_size[0], window_size[1]);
glutCreateWindow("Interactive boundary design");
glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_CONTINUE_EXECUTION);
//init_sfc();
//init_light();
// register callbacks
glDepthFunc(GL_LEQUAL);
//glDepthFunc(GL_GEQUAL);
glDepthRange(1.0, 0.); // left handed에서 right hanaded로 변경
glutDisplayFunc(renderScene);
glutReshapeFunc(changeSize);
init_light();
///glutMouseWheelFunc(render_wheel);
glutMouseFunc(mousePress);
glutMotionFunc(mouseDrag);
glutPassiveMotionFunc(passive_mouse);
glutKeyboardFunc(simple_keyboard_binding);
// enter GLUT event processing cycle
glutMainLoop();
}
return 0;
}
I had updated after the suggestion in the comment sections. It should be better and working fine now. However, feel free to comment and discussion! I really wish to improve my programming in OpenGL!
I am new to OpenGL. I want to create a pop-up menu to change the lighting (ambient, diffuse, specular and position) of a sphere. However, there are some problems in showing the light. It works accordingly to click on the choice, e.g. ambient--> diffuse --> specular) but cannot work when (specular--> diffuse).
Here is the part of my code.
void display(void)
{
GLfloat gray[] = { 0.8, 0.8, 0.8, 1.0 };
GLfloat cyan[] = { 0.0, 1.0, 1.0, 0.0 };
GLfloat black[] = { 0.0, 0.0, 0.0, 1.0 };
GLfloat white[] = { 0.8f, 0.8f, 0.8f, 1.0f };
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushMatrix();
glTranslatef(0.0, 0.0, tdist);
glRotatef((GLfloat)spinx, 1.0, 0.0, 0.0);
glRotatef((GLfloat)spiny, 0.0, 1.0, 0.0);
glRotatef((GLfloat)spinz, 0.0, 0.0, 1.0);
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, gray);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, cyan);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, white);
glMaterialfv(GL_FRONT_AND_BACK, GL_POSITION, cyan);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 50);
glEnable(GL_LIGHTING);
glEnable(GL_POLYGON_OFFSET_FILL);
if (value == 2) {
glEnable(GL_LIGHT0);
glPolygonOffset(polyfactor, polyunits);
glCallList(list);
}
else if (value == 3) {
glEnable(GL_LIGHT1);
glPolygonOffset(polyfactor, polyunits);
glCallList(list);
}
else if (value == 4) {
glEnable(GL_LIGHT2);
glPolygonOffset(polyfactor, polyunits);
glCallList(list);
}
else if (value == 5) {
glEnable(GL_LIGHT3);
glPolygonOffset(polyfactor, polyunits);
glCallList(list);
}
glDisable(GL_POLYGON_OFFSET_FILL);
glDisable(GL_LIGHTING);
glDisable(GL_LIGHT0);
glDisable(GL_LIGHT1);
glDisable(GL_LIGHT2);
glDisable(GL_LIGHT3);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glCallList(list);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glPopMatrix();
glFlush();
}
Thank you so much if anyone can help!!!
I need help with my code in C++ using the OpenGL API. I have written a program that draws 4 3D cubes and text (using bitmap) onto the screen. Now I want to add lighting.
I have added glMaterial code to give a description of the material for the cubes. I do not want the material properties to be applied to the bitmap text. Therefore, I placed the code for the material before drawing the cube and I also placed the code for drawing the cube and the material between a pushMatrix and popMatrix pair. However, when I run the code, I find the text changes color.
Below is some of the code that I am using:
void init() {
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ligAmb);
glEnable(GL_LIGHTING);
glLightfv(GL_LIGHT0, GL_DIFFUSE, lig[0][0]);
glLightfv(GL_LIGHT0, GL_SPECULAR, lig[0][1]);
glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, ligDir);
glLightf(GL_LIGHT0, GL_SPOT_EXPONENT, exp_one);
glLightf(GL_LIGHT0, GL_SPOT_CUTOFF, cutoff);
glEnable(GL_LIGHT0);
glLightfv(GL_LIGHT1, GL_DIFFUSE, lig[1][0]);
glLightfv(GL_LIGHT1, GL_SPECULAR, lig[1][1]);
glEnable(GL_LIGHT1);
glClearColor(0.0, 0.0, 0.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
void drawCube(Point3D colors[], Point3D vertices[]) {
glBegin(GL_QUADS);
glColor3fv(colors[1]);
glVertex3fv(vertices[1]);
glColor3fv(colors[5]);
glVertex3fv(vertices[5]);
glColor3fv(colors[7]);
glVertex3fv(vertices[7]);
glColor3fv(colors[3]);
glVertex3fv(vertices[3]);
glColor3fv(colors[7]);
glVertex3fv(vertices[7]);
glColor3fv(colors[6]);
glVertex3fv(vertices[6]);
glColor3fv(colors[2]);
glVertex3fv(vertices[2]);
glColor3fv(colors[3]);
glVertex3fv(vertices[3]);
glColor3fv(colors[2]);
glVertex3fv(vertices[2]);
glColor3fv(colors[6]);
glVertex3fv(vertices[6]);
glColor3fv(colors[4]);
glVertex3fv(vertices[4]);
glColor3fv(colors[0]);
glVertex3fv(vertices[0]);
glColor3fv(colors[5]);
glVertex3fv(vertices[5]);
glColor3fv(colors[4]);
glVertex3fv(vertices[4]);
glColor3fv(colors[6]);
glVertex3fv(vertices[6]);
glColor3fv(colors[7]);
glVertex3fv(vertices[7]);
glColor3fv(colors[4]);
glVertex3fv(vertices[4]);
glColor3fv(colors[5]);
glVertex3fv(vertices[5]);
glColor3fv(colors[1]);
glVertex3fv(vertices[1]);
glColor3fv(colors[0]);
glVertex3fv(vertices[0]);
glColor3fv(colors[0]);
glVertex3fv(vertices[0]);
glColor3fv(colors[1]);
glVertex3fv(vertices[1]);
glColor3fv(colors[3]);
glVertex3fv(vertices[3]);
glColor3fv(colors[2]);
glVertex3fv(vertices[2]);
glEnd();
}
void displayObject() {
glPushMatrix();
glClearColor(0.0, 0.0, 0.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glColor3f(1.0, 0.0, 0.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glLightfv(GL_LIGHT0, GL_POSITION, ligPos[0]);
glLightfv(GL_LIGHT1, GL_POSITION, ligPos[1]);
typedef GLint vertex3[3];
Point3D vertices[8] = { {-1.0, -1.0, -1.0},
{-1.0, -1.0, 1.0},
{-1.0, 1.0, -1.0},
{-1.0, 1.0, 1.0},
{ 1.0, -1.0, -1.0},
{ 1.0, -1.0, 1.0},
{ 1.0, 1.0, -1.0},
{ 1.0, 1.0, 1.0} };
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_INT, 0, vertices);
GLubyte vertIndex[] = { 6,2,3,7,5,1,0,4,7,3,1,5,4,0,2,6,2,0,1,3,7,5,4,6
};
glDrawElements(GL_QUADS, 24, GL_UNSIGNED_BYTE, vertIndex);
glPopMatrix();
Point3D colorsb[8] = { {0.,0.,1.},
{0.,0.,1.},
{0.,0.,1.},
{0.,0.,1.},
{0.,0.,1.},
{0.,0.,1.},
{0.,0.,1.},
{0.,0.,1.} };
Point3D colorsg[8] = { {0.,1.,0.},
{0.,1.,0.},
{0.,1.,0.},
{0.,1.,0.},
{0.,1.,0.},
{0.,1.,0.},
{0.,1.,0.},
{0.,1.,0.} };
Point3D colorsr[8] = { {1.,0.,0.},
{1.,0.,0.},
{1.,0.,0.},
{1.,0.,0.},
{1.,0.,0.},
{1.,0.,0.},
{1.,0.,0.},
{1.,0.,0.} };
Point3D colorsy[8] = { {1.,1.,0.},
{1.,1.,0.},
{1.,1.,0.},
{1.,1.,0.},
{1.,1.,0.},
{1.,1.,0.},
{1.,1.,0.},
{1.,1.,0.} };
glPushMatrix();
glTranslatef(-0.5f, 4.0f, -6.0f);
glRotatef(10.0, 0.0, 1.0, 0.0);
glRotatef(loop, 0.0, 1.0, 0.0);
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, mat[0][0]);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, mat[0][1]);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat[0][2]);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, shi[0]);
drawCube(colorsb, vertices);
glPopMatrix();
glPushMatrix();
glTranslatef(6.0f, -0.5f, -6.0f);
glRotatef(10.0, 1.0, 0.0, 0.0);
glRotatef(loop, 0.0, 1.0, 0.0);
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, mat[1][0]);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, mat[1][1]);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat[1][2]);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, shi[1]);
drawCube(colorsg, vertices);
glPopMatrix();
glPushMatrix();
glTranslatef(-0.5f, -4.5f, -6.0f);
glRotatef(10.0, 0.0, 1.0, 0.0);
glRotatef(loop, 0.0, 1.0, 0.0);
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, mat[2][0]);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, mat[2][1]);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat[2][2]);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, shi[2]);
drawCube(colorsr, vertices);
glPopMatrix();
glPushMatrix();
glTranslatef(-6.0f, -0.5f, -6.0f);
glRotatef(10.0, 1.0, 0.0, 0.0);
glRotatef(loop, 0.0, 1.0, 0.0);
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, mat[3][0]);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, mat[3][1]);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat[3][2]);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, shi[3]);
drawCube(colorsy, vertices);
glPopMatrix();
}
void display() {
displayObject();
wordColor = "green";
char str[] = { "Red" };
glColor3f(0.0, 1.0, 0.0);
glRasterPos2f(-0.5, 0.0);
for (int i = 0; i < strlen(str); i++)
{
glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, str[i]);
}
glPopMatrix();
loop += 0.05;
glFlush();
glutSwapBuffers();
glutPostRedisplay();
}
OpenGL is a state machine, which means that it keeps a state around until you explicitly change it again. So when you take care to set the illumination only after drawing the text during drawing one frame, it will have happened before drawing the text of the next frame.
The solution is, that you always set every relevant state for whatever it is you're drawing, right before you draw it. In case of the text, it's as simple as disable lighting, right before drawing the text (actually before calling glRasterPos).
I want to make a simple OpenGL Program with a sun shining. Here is my code so far:
void init() {
glClearColor (0.0f, 0.0f, 0.0f, 0.0f);
glClear (GL_COLOR_BUFFER_BIT);
glLoadIdentity();
glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);
// Lighting set up
glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
// Set lighting intensity and color
GLfloat qaAmbientLight[] = {0.2, 0.2, 0.2, 1.0};
GLfloat qaDiffuseLight[] = {0.8, 0.8, 0.8, 1.0};
GLfloat qaSpecularLight[] = {1.0, 1.0, 1.0, 1.0};
glLightfv(GL_LIGHT0, GL_AMBIENT, qaAmbientLight);
glLightfv(GL_LIGHT0, GL_DIFFUSE, qaDiffuseLight);
glLightfv(GL_LIGHT0, GL_SPECULAR, qaSpecularLight);
// Set the light position
GLfloat qaLightPosition[] = {0, 0.758, 0.0, 1.0};
glLightfv(GL_LIGHT0, GL_POSITION, qaLightPosition);
}
void drawSun() {
glClear(GL_COLOR_BUFFER_BIT);
// Set material properties
GLfloat Yellow[] = {1.0, 0.647, 0.0, 1.0};
GLfloat White[] = {1.0, 1.0, 1.0, 1.0};
glMaterialfv(GL_FRONT, GL_AMBIENT, Yellow);
glMaterialfv(GL_FRONT, GL_DIFFUSE, Yellow);
glMaterialfv(GL_FRONT, GL_SPECULAR, White);
glMaterialf(GL_FRONT, GL_SHININESS, 60.0);
float x, y;
float radius = 0.095f;
float x_mid = 0;
float y_mid = 0.758;
glBegin(GL_POLYGON);
x = x_mid + (float)radius * cos(359 * PI / 180.0f);
y = y_mid + (float)radius * sin(359 * PI / 180.0f);
for (int j = 0; j < 360; j++)
{
glVertex2f(x, y);
x = x_mid + (float)radius * cos(j * PI / 180.0f);
y = y_mid + (float)radius * sin(j * PI / 180.0f);
glVertex2f(x, y);
}
glEnd();
}
But the sun doesn't shine, it looks like this :
I want to know if I make some mistakes in my code, any helps will be appreciated.
Shouldn't you call glColorMaterial to enable GL_SPECULAR that is off by default?
Also you are completely skipping all the error checking.
Why the shadows are gone from unlighted faces of my cube shape when I am using arrays of:
vertices[]
indices[]
colors[]
normals[]
texcoords[]
// and draw them by
glDrawElements();
But when I use:
glBegin(...);
glVertex3f(...);
glEnd(...);
The shadows are ok.
Here you got an image of what is happening:
My light is set as below:
glShadeModel (GL_SMOOTH);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_DEPTH_TEST);
glColorMaterial( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
glEnable(GL_COLOR_MATERIAL);
glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
GLfloat AmbientLight[] = {0.0, 0.0, 0,0, 1.0};
GLfloat DiffuseLight[] = {1.0, 1.0, 1,0, 1.0};
GLfloat SpecularLight[] = {1.0, 1.0, 1.0, 1.0};
GLfloat Shininess[] = { 90.0 };
GLfloat Emission[] = {0.0, 0.0, 0.0, 1.0};
glLightfv(GL_LIGHT0, GL_AMBIENT, AmbientLight);
glLightfv(GL_LIGHT0, GL_DIFFUSE, DiffuseLight);
glLightfv(GL_LIGHT0, GL_SPECULAR, SpecularLight);
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, AmbientLight);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, DiffuseLight);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, SpecularLight);
glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, Shininess);
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, Emission);
You are probably missing a call to
glEnableClientState( GL_NORMAL_ARRAY );