int main(int argc, char *argv[])
{
glutInit(&argc, argv); // initialize GLUT
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH); // open an OpenGL context with double buffering, RGB colors, and depth buffering
glutInitWindowSize(Window::width, Window::height); // set initial window size
glutCreateWindow("Procedural Terrain"); // open window and set window title
glutFullScreen();
glEnable(GL_DEPTH_TEST); // enable depth buffering
glClear(GL_DEPTH_BUFFER_BIT); // clear depth buffer
glClearColor(0.0, 0.0, 0.0, 0.0); // set clear color to black
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); // set polygon drawing mode to fill front and back of each polygon
glDisable(GL_CULL_FACE); // disable backface culling to render both sides of polygons
glShadeModel(GL_SMOOTH); // set shading to smooth
glMatrixMode(GL_PROJECTION);
GLfloat light_ambient[] = { 0.0, 0.0, 0.0, 1.0 };
GLfloat light_diffuse_p[] = { 1.0, 0.0, 0.0, 1.0 };
GLfloat light_specular_p[] = { 1.0, 0.0, 0.0, 1.0 };
GLfloat light_diffuse_s[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat light_specular_s[] = { 1.0, 1.0, 1.0, 1.0 };
float position[] = { 0.0, 10.0, 0.0, 0.0 };
// Generate light source:
glLightfv(GL_LIGHT0, GL_POSITION, position);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
// Generate light source
glEnable(GL_LIGHTING);
glLightModelf(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
// Install callback functions:
glutDisplayFunc(Window::displayCallback);
glutReshapeFunc(Window::reshapeCallback);
glutIdleFunc(Window::idleCallback);
// To Prevent the cube from turning white when scaled down
glEnable(GL_NORMALIZE);
engine.loadTexture();
glEnable(GL_TEXTURE_2D); // Enable Texture Mapping ( NEW )
engine.initTerrain();
// Process keyboard input
glutKeyboardFunc(Window::processNormalKeys);
glutSpecialFunc(Window::processSpecialKeys);
// Initialize cube matrix:
engine.getMatrix().identity();
//glutTimerFunc(50, CGEngine::rotate, 0);
glutMainLoop();
return 0;
}
void GLViewer::setLights()
{
glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
float lightColour[] = {1.0f, 0.8f, 1.0f, 1.0f};
float lightDir[] = {0.0f, 0.0f, 1.0f, 0.0f};
glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColour);
glLightfv(GL_LIGHT0, GL_SPECULAR, lightColour);
glLightfv(GL_LIGHT0, GL_POSITION, lightDir);
glLightModelf(GL_LIGHT_MODEL_LOCAL_VIEWER, 1.0f);
glEnable(GL_LIGHT0);
}
void CGFscene::init() {
glEnable(GL_LIGHTING);
glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, CGFlight::background_ambient); // define ambient light
// Light
float light0_pos[4] = {4.0, 6.0, 3.0, 1.0};
CGFlight* light0 = new CGFlight(GL_LIGHT0, light0_pos);
light0->enable();
}
void CBaseOglControl::BaseInitialize()
{
parser.Start();
PIXELFORMATDESCRIPTOR pfd;
int pf = 0;
HDC hDC = GetDC(hMy);
pfd.nSize = sizeof(pfd);
pfd.nVersion = 1;
pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
pfd.iPixelType = PFD_TYPE_RGBA;
pfd.cColorBits = 32;
pf = ChoosePixelFormat(hDC, &pfd);
if(pf==0)
{
pf = 1;
if(DescribePixelFormat(hDC,pf,sizeof(PIXELFORMATDESCRIPTOR),&pfd)==0)
return;
}
if (SetPixelFormat(hDC, pf, &pfd) == FALSE) return;
hOGL = wglCreateContext(hDC);
wglMakeCurrent(hDC, hOGL);
quadObj = gluNewQuadric();//Для отрисовки цилиндра, сфер и т.д.
//все перенести в скрипт
glEnable(GL_TEXTURE_2D);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_COLOR_MATERIAL);
//glDisable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
glEnable(GL_ALPHA_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_ALPHA_TEST);
glAlphaFunc(GL_GREATER, 0.5f);
glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
Initialize();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
SwapBuffers(wglGetCurrentDC());
glFlush();
wglMakeCurrent(hDC, 0);
}
int main(int argc, char *argv[])
{
//Math Test Bench
MathTestBench::runTests();
glutInit(&argc, argv); //Initialize GLUT
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH); //Open an OpenGL context with double buffering, RGB colors, and depth buffering
glutInitWindowSize(Window::width, Window::height); //Set initial window size
glutCreateWindow("UCSD CSE 167 - Project 6 - Global Warming"); //Open window and set window title
glEnable(GL_DEPTH_TEST); //Enable depth buffering
glClear(GL_DEPTH_BUFFER_BIT); //Clear depth buffer
glClearColor(0.0, 0.0, 0.0, 0.0); //Set clear color to black
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); //Set polygon drawing mode to fill front and back of each polygon
glDisable(GL_CULL_FACE); //Disable backface culling to render both sides of polygons
glShadeModel(GL_SMOOTH); //Set shading to smooth
glEnable(GL_COLOR_MATERIAL); //Enable color materials
glEnable(GL_LIGHTING); //Enable lighting
glEnable(GL_NORMALIZE); //Auto normalize surface normals
glLightModelf(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
glEnable(GL_TEXTURE_2D);
//Register callback functions:
glutDisplayFunc(Window::displayCallback);
glutReshapeFunc(Window::reshapeCallback);
glutIdleFunc(Window::idleCallback);
//Register the callback for the keyboard
glutKeyboardFunc(Window::keyCallback);
//Register the callback for the keyboard function keys
//glutSpecialFunc(Window::specialFunc);
//Register the callback for the mouse
glutMouseFunc(Window::mouseFunc);
//Register the callback for the mouse motion
glutMotionFunc(Window::mouseMotion);
//Initialize lights
//Initialize the Window:
//The body of this function is a great place to load textures, shaders, etc.
//and do any operations/calculations/configurations that only need to happen once.
Window::initialize();
//Start up the render loop!
glutMainLoop();
return 0;
}
void GameScene::setLights()
{
glColorMaterial(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE);
float lightDir[]={0.8,1.0,0.5,0.0};
float lightAmbient[]={0.2,0.2,0.2,1.0}; //环境光
// float lightDiffuse[]={1.0,1.0,1.0,0.7}; //漫射光
glLightfv(GL_LIGHT0,GL_POSITION,lightDir);
glLightfv(GL_LIGHT0,GL_AMBIENT,lightAmbient);
// glLightfv(GL_LIGHT0,GL_DIFFUSE,lightDiffuse);
glLightModelf(GL_LIGHT_MODEL_LOCAL_VIEWER,1.0f);
glEnable(GL_LIGHT0);
}
void init_lighting() {
//light position
GLfloat light_pos[4] = {0.0, 0.0, 0.0, 1.0};
//light color (ambiant, diffuse and specular)
GLfloat light_amb[4] = {0.3, 0.3, 0.3, 1.0};
GLfloat light_diff[4] = {0.3, 0.3, 0.3, 1.0};
GLfloat light_spec[4] = {0.0, 0.0, 0.0, 1.0};
//turn on light0
glEnable(GL_LIGHT0);
glLightfv(GL_LIGHT0, GL_POSITION, light_pos);
//set up the diffuse, ambient and specular components for the light
glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diff);
glLightfv(GL_LIGHT0, GL_AMBIENT, light_amb);
glLightfv(GL_LIGHT0, GL_SPECULAR, light_spec);
const GLfloat light_atten = 0.3f;
//light position
GLfloat light_pos2[4] = {0.25, 2.0, 0.25, 1.0};
//light color (ambiant, diffuse and specular)
GLfloat light_amb2[4] = {0.0, 0.0, 0.0, 1.0};
GLfloat light_diff2[4] = {0.0, 0.0, 0.4, 1.0};
GLfloat light_spec2[4] = {0.0, 0.0, 0.8, 1.0};
//turn on light0
glEnable(GL_LIGHT1);
glLightfv(GL_LIGHT1, GL_POSITION, light_pos2);
//set up the diffuse, ambient and specular components for the light
glLightfv(GL_LIGHT1, GL_DIFFUSE, light_diff2);
glLightfv(GL_LIGHT1, GL_AMBIENT, light_amb2);
glLightfv(GL_LIGHT1, GL_SPECULAR, light_spec2);
glLightf(GL_LIGHT1, GL_LINEAR_ATTENUATION, light_atten);
//light position
GLfloat light_pos3[4] = {12.25, 2.0, 0.25, 1.0};
//light color (ambiant, diffuse and specular)
GLfloat light_amb3[4] = {0.0, 0.0, 0.0, 1.0};
GLfloat light_diff3[4] = {0.4, 0.0, 0.0, 1.0};
GLfloat light_spec3[4] = {0.8, 0.0, 0.0, 1.0};
//turn on light0
glEnable(GL_LIGHT2);
glLightfv(GL_LIGHT2, GL_POSITION, light_pos3);
//set up the diffuse, ambient and specular components for the light
glLightfv(GL_LIGHT2, GL_DIFFUSE, light_diff3);
glLightfv(GL_LIGHT2, GL_AMBIENT, light_amb3);
glLightfv(GL_LIGHT2, GL_SPECULAR, light_spec3);
glLightf(GL_LIGHT2, GL_LINEAR_ATTENUATION, light_atten);
//specify our lighting model as 1 normal per face
glShadeModel(SHADING_MODE);
glLightModelf(GL_LIGHT_MODEL_LOCAL_VIEWER, 1.0f);
glEnable(GL_NORMALIZE);
}
void gra_init()
{
GLfloat pos[4] = { 0.0,0.0,1.0,0.0 };
GLfloat amb[4] = { 0.2,0.2,0.2,1.0 };
GLfloat spc[4] = { 1.0,1.0,1.0,1.0 };
GLfloat dif[4] = { 0.8,0.8,0.8,1.0 };
glPixelStorei( GL_PACK_ALIGNMENT, 1 );
glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective( 30.0,1.0,1.0,20.0 );
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
glColorMaterial( GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE );
glEnable( GL_COLOR_MATERIAL );
glLightModeli( GL_LIGHT_MODEL_TWO_SIDE,1 );
glLightModelf( GL_LIGHT_MODEL_LOCAL_VIEWER,1.0 );
glEnable( GL_LIGHTING );
glLightfv( GL_LIGHT0, GL_POSITION, pos );
glLightfv( GL_LIGHT0, GL_DIFFUSE, dif );
glLightfv( GL_LIGHT0, GL_SPECULAR, spc );
glLightfv( GL_LIGHT0, GL_AMBIENT, amb );
glEnable( GL_LIGHT0 );
gluLookAt( 0.0,0.0,5.0,0.0,0.0,0.0,0.0,1.0,0.0 );
glEnable( GL_NORMALIZE );
glEnable( GL_DEPTH_TEST );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
glDisable( GL_BLEND );
glCullFace( GL_BACK );
glDisable( GL_CULL_FACE );
glDepthRange( 0.0,1.0 );
glDepthMask( GL_TRUE );
glDepthFunc( GL_LEQUAL );
// Enable anti-aliasing:
#if 0
glEnable( GL_BLEND );
glEnable( GL_LINE_SMOOTH );
glEnable( GL_POLYGON_SMOOTH );
#endif
}
int main(int argc, char *argv[])
{
//Math Test Bench
//MathTestBench::runTests();
//GLUT and OpenGL Configuration
glutInit(&argc, argv); //Initialize GLUT
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH); //Open an OpenGL context with double buffering, RGB colors, and depth buffering
glutInitWindowSize(Window::width, Window::height); //Set initial window size
glutCreateWindow("UCSD CSE 167 - Project 1 - OpenGL Cube"); //Open window and set window title
glEnable(GL_DEPTH_TEST); //Enable depth buffering
glClear(GL_DEPTH_BUFFER_BIT); //Clear depth buffer
glClearColor(0.0, 0.0, 0.0, 0.0); //Set clear color to black
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); //Set polygon drawing mode to fill front and back of each polygon
glDisable(GL_CULL_FACE); //Disable backface culling to render both sides of polygons
glShadeModel(GL_SMOOTH); //Set shading to smooth
glEnable(GL_COLOR_MATERIAL); //Enable color materials
glEnable(GL_LIGHTING); //Enable lighting
glEnable(GL_NORMALIZE); //Auto normalize surface normals
glEnable(GL_TEXTURE_2D); //Enable 2D textures
glLightModelf(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE); //Enable Local Viewer Light Model
//Register callback functions:
glutDisplayFunc(Window::displayCallback);
glutReshapeFunc(Window::reshapeCallback);
glutIdleFunc(Window::idleCallback);
//Register the callback for the keyboard
glutKeyboardFunc(Window::keyboardCallback);
//Register the callback for the keyboard function keys
//glutSpecialFunc(Window::specialKeys);
//Register the callback for the mouse
//Register the callback for the mouse motion
//Register the callback for the mouse passive motion
//Print Shader Debug Information:
printf("%s\n%s\n",
glGetString(GL_RENDERER), // e.g. Intel HD Graphics 3000 OpenGL Engine
glGetString(GL_VERSION) // e.g. 3.2 INTEL-8.0.61
);
std::printf("Supported GLSL version is %s.\n", (char *)glGetString(GL_SHADING_LANGUAGE_VERSION));
//Initialize the Window:
//The body of this function is a great place to load textures, shaders, etc.
//and do any operations/calculations/configurations that only need to happen once.
Window::initialize();
//Start up the render loop!
glutMainLoop();
return 0;
}
bool Application::InitOpenGL()
{
#ifdef WIN32
wglSwapIntervalEXT_Func wglSwapIntervalEXT = (wglSwapIntervalEXT_Func)wglGetProcAddress("wglSwapIntervalEXT");
if(wglSwapIntervalEXT) wglSwapIntervalEXT(Globals.VP.Vsync);//1 - чтобы включить
else FASSERT (wglSwapIntervalEXT);
#else
#error Linux is not supported yet
#endif
LF.Logf("InitOpenGL","Vsync status : %d",Globals.VP.Vsync);
//===[ Инициализация всякой фигни ]===================================================||
Cam.Init();
//===[ Наинициализировались ]=========================================================||
glClearColor(0.0f, 0.0f, 0.25f, 0.0f);
// Очистка экрана в черный цвет
glClearDepth(1.0); // Разрешить очистку буфера глубины
glDepthFunc(GL_LESS); // Тип теста глубины (рисуется всё что ближе)
glEnable(GL_DEPTH_TEST);// разрешить тест глубины
glShadeModel(GL_SMOOTH);// разрешить плавное цветовое сглаживание
ReshapeWindow(Globals.VP.Width,Globals.VP.Height);
glEnable(GL_TEXTURE_2D); // Разрешение наложения текстур
glClearDepth(1.0f); // Установка буфера глубины
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Улучшенные вычисления перспективы
glDisable(GL_POLYGON_SMOOTH);
glHint(GL_POLYGON_SMOOTH_HINT,GL_NICEST);
glHint(GL_POINT_SMOOTH_HINT,GL_NICEST);
glEnable(GL_DITHER);
//glEnable(GL_CULL_FACE);
//==== Свет ==========================================================================//
glEnable(GL_LIGHT1); // Разрешение источника света номер один
glLightfv(GL_LIGHT1, GL_AMBIENT, LightAmbient); // Установка Фонового Света
glLightfv(GL_LIGHT1, GL_DIFFUSE, LightDiffuse); // Установка Диффузного Света
glLightfv(GL_LIGHT1, GL_POSITION, LightPosition); // Позиция света
glEnable(GL_LIGHTING);
glLightModelf(GL_LIGHT_MODEL_TWO_SIDE,0.0);
glLightModelf(GL_LIGHT_MODEL_LOCAL_VIEWER,GL_TRUE);
//=== /Свет ==========================================================================//
return NO_ERROR;
}
void display(void)
{
GLdouble eqn[4] = {1.0, 0.0, -1.0, 1.0};
GLfloat two_side_on[] = { GL_TRUE };
GLfloat two_side_off[] = { GL_FALSE };
GLfloat mat_diffuse[] = { 0.8, 0.8, 0.8, 1.0 };
GLfloat back_diffuse[] = { 0.8, 0.2, 0.8, 1.0 };
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushMatrix ();
glClipPlane (GL_CLIP_PLANE0, eqn); /* slice objects */
glEnable (GL_CLIP_PLANE0);
glPushMatrix ();
glTranslatef (0.0, 2.0, 0.0);
auxSolidTeapot(1.0); /* one-sided lighting */
glPopMatrix ();
/* two-sided lighting, but same material */
glLightModelf (GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
glMaterialfv (GL_FRONT_AND_BACK, GL_DIFFUSE, mat_diffuse);
glPushMatrix ();
glTranslatef (0.0, 0.0, 0.0);
auxSolidTeapot(1.0);
glPopMatrix ();
/* two-sided lighting, two different materials */
glMaterialfv (GL_FRONT, GL_DIFFUSE, mat_diffuse);
glMaterialfv (GL_BACK, GL_DIFFUSE, back_diffuse);
glPushMatrix ();
glTranslatef (0.0, -2.0, 0.0);
auxSolidTeapot(1.0);
glPopMatrix ();
glLightModelf (GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE);
glDisable (GL_CLIP_PLANE0);
glPopMatrix ();
glFlush();
}
//***************************************
// Init
//***************************************
int CStaticView::Init()
{
HWND hWnd = GetSafeHwnd();
HDC hDC = ::GetDC(hWnd);
if(SetWindowPixelFormat(hDC)==FALSE)
return FALSE;
if(CreateViewGLContext(hDC)==FALSE)
return FALSE;
glShadeModel(GL_FLAT);
glEnable(GL_NORMALIZE);
// Lights properties
float ambientProperties[] = {0.7f, 0.7f, 0.7f, 1.0f};
float diffuseProperties[] = {0.8f, 0.8f, 0.8f, 1.0f};
float specularProperties[] = {1.0f, 1.0f, 1.0f, 1.0f};
glLightfv( GL_LIGHT0, GL_AMBIENT, ambientProperties);
glLightfv( GL_LIGHT0, GL_DIFFUSE, diffuseProperties);
glLightfv( GL_LIGHT0, GL_SPECULAR, specularProperties);
glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, 1.0);
COLORREF color = GetSysColor(COLOR_3DFACE);
float r = (float)GetRValue(color)/255.0f;
float g = (float)GetGValue(color)/255.0f;
float b = (float)GetBValue(color)/255.0f;
glClearColor(r,g,b,1.0f);
glClearDepth(1.0f);
glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
// Perspective
CRect rect;
GetClientRect(&rect);
double aspect = (rect.Height() == 0) ?
rect.Width() : (double)rect.Width()/(double)rect.Height();
gluPerspective(45,aspect,0.1,1000.0);
glPolygonMode(GL_FRONT,GL_LINE);
glPolygonMode(GL_BACK,GL_LINE);
// Antialiasing
glEnable(GL_LINE_SMOOTH);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glHint(GL_LINE_SMOOTH_HINT,GL_NICEST);
glLineWidth(1.1f);
SetTimer(1,1,NULL);
return 1;
}
void init(void)
{
glClearColor(0.0, 0.0, 0.0, 1.0);
glEnable(GL_DEPTH_TEST);
glEnable(GL_AUTO_NORMAL);
glEnable(GL_NORMALIZE);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHT1);
glLightfv(GL_LIGHT0,GL_DIFFUSE,white); /* 白い光源 */
glLightfv(GL_LIGHT1,GL_DIFFUSE,white);
glLightModelf(GL_LIGHT_MODEL_LOCAL_VIEWER,GL_TRUE);/* 鏡面反射処理をリアルに */
}
void lab2::initGL(void)
{
std::cout << "Initializete GL" << std::endl;
xRot = -30; yRot = 0; zRot = 0;
xTra = 0; yTra = 0; zTra = 0;
nSca = 0.2f;
std::cout << "Setup params for cylinder" << std::endl;
stacks = 25; slices = 25;
xCenterCylinder = 0; yCenterSphere = 0; zCenterCylinder = 0;
baseRad = 1.0; topRad = 1.0; cyheight = 3;
cylinder = gluNewQuadric();
std::cout << "Setup params for conus" << std::endl;
xCenterConus = 0; yCenterConus = 0; zCenterConus = 3;
conusRad = 1.0; coheight = 3;
conus = gluNewQuadric();
std::cout << "Setup params for sphere" << std::endl;
xCenterSphere = 0; yCenterSphere = 0; zCenterSphere = 0;
spRad = 1.0;
sphere = gluNewQuadric();
std::cout << "load image from file texture1.bmp" << std::endl;
image = loadBMP("texture1.bmp");
std::cout << "load image from file texture2.bmp" << std::endl;
img = loadBMP("texture2.bmp");
std::cout << "load image from file texture3.bmp" << std::endl;
img1 = loadBMP("texture3.bmp");
_textureId[0] = loadTexture(image);
_textureId[1] = loadTexture(img);
_textureId[2] = loadTexture(img1);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHT1);
glEnable(GL_LIGHT2);
glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
glViewport(0,0, rect.w, rect.h);
glEnable(GL_DEPTH_TEST);
glEnable(GL_NORMALIZE);
glEnable(GL_COLOR_MATERIAL);
glEnable(GL_CULL_FACE);
glEnable(GL_TEXTURE_2D);
glEnable(GL_MULTISAMPLE);
delete image;
delete img;
delete img1;
}
void grInit(int *argc, char **argv)
{
glutInit(argc, argv);
glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH );
glutInitWindowSize( WIDTH, HEIGHT);
glutCreateWindow( "Rings simulation" );
glEnable(GL_DEPTH_TEST);
//glEnable(GL_CULL_FACE);
//glCullFace(GL_BACK);
glDisable(GL_DITHER);
glClearColor( 0.0, 0.0, 0.0, 0.0 );
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glutSwapBuffers();
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glutSwapBuffers();
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
GLfloat light_position[] = {15.0, 0.0, -5.0, 1.0};
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
glLightModelf(GL_LIGHT_MODEL_LOCAL_VIEWER, 0.0);
glPopMatrix();
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glMatrixMode( GL_PROJECTION );
glLoadIdentity( );
gluPerspective(60.0, ((float)(WIDTH)) / ((float)(HEIGHT)), 0.1, 100.0);
gluLookAt(15, 0, -5, 0, 0, -5, 0, 0, 1);
glMatrixMode( GL_MODELVIEW );
glMaterialfv(GL_FRONT, GL_SPECULAR, sph_specular);
glMaterialfv(GL_FRONT, GL_DIFFUSE, sph_diffuse);
glMaterialfv(GL_FRONT, GL_SHININESS, sph_shininess);
glutKeyboardFunc(KeyboardFunc);
glutDisplayFunc(DisplayFunc);
glutIdleFunc(DisplayFunc);
glutMainLoop();
}
bool init() {
// initialize SDL
if( SDL_Init(SDL_INIT_VIDEO) < 0 ) return false;
// enable double buffering
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
// create indow
// set SDL_WINDOW_OPENGL to use opengl for drawing
window = SDL_CreateWindow(WINDOW_CAPTION.c_str(),
SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
WINDOW_WIDTH, WINDOW_HEIGHT,
SDL_WINDOW_OPENGL);
if (!window) return false;
// create OpenGL context
context = SDL_GL_CreateContext(window);
if (!context) return false;
// setup viewport
glViewport(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glEnable(GL_DEPTH_TEST);
// setup projection matrix
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0, (GLdouble) WINDOW_WIDTH / (GLdouble) WINDOW_HEIGHT, 2.0, 500.0);
// setup light
static GLfloat position[] = {-10.0f, 10.0f, 10.0f, 1.0f};
static GLfloat ambient [] = { 1.0f, 1.0f, 1.0f, 1.0f};
static GLfloat diffuse [] = { 1.0f, 1.0f, 1.0f, 1.0f};
static GLfloat specular[] = { 0.0f, 0.0f, 0.0f, 0.0f};
glLightfv(GL_LIGHT0, GL_POSITION, position);
glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
glLightfv(GL_LIGHT0, GL_SPECULAR, specular);
glLightModelf(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
scene = new ScStart();
return true;
}
//++MgOpenGlContext::LightModelDef [nhpqfohm`mjhiunpefmefg,mgopenglshade.c]
//int MgOpenGlContext::LightModelDef(int lightmodel, MgLighting *lgt,
// int mask, AppearanceStackNode *astk)
int MgOpenGlContext::LightModelDef(int lightmodel, MgLighting *lgt,
int mask, MgAppearanceStackNode *node)
{
GLfloat f[4];
glNewList(( lightmodel, GL_COMPILE));
f[3] = 1.0;
if( mask & MgLighting::F_AMBIENT) {
f[0] = (float)(lgt->GetAmbient()->GetRed());
f[1] = (float)(lgt->GetAmbient()->GetGreen());
f[2] = (float)(lgt->GetAmbient()->GetBlue());
glLightModelfv((GL_LIGHT_MODEL_AMBIENT, f));
}
if( mask & MgLighting::F_LOCALVIEWER) {
glLightModelf((GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE));
}
#ifndef TRUE_EMISSION
/* This causes trouble if the vertex order makes GL consider
* our polygon to be backfacing -- then GL_LIGHT_MODEL_TWO_SIDE causes it
* to be mis-shaded from both sides..
*/
//if((astk->p_mMat.GetValid() & MgMaterial::F_EMISSION) ) {
//glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
//}
if( node->GetAppearance()->GetFrontMaterial()->GetValid()
& MgMaterial::F_EMISSION ) {
glLightModelf((GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE));
}
#endif
glEndList(());
return lightmodel;
}
int main(int argc, char **argv) {
float propertiesAmbient [] = {0.50, 0.50, 0.50, 1.00};
float propertiesDiffuse [] = {0.75, 0.75, 0.75, 1.00};
float propertiesSpecular[] = {1.00, 1.00, 1.00, 1.00};
int width = 640.0;
int height = 480.0;
glutInit(&argc, argv);
glutInitWindowPosition(0, 0);
glutInitWindowSize(width, height);
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
glutCreateWindow("Marching Cubes");
glutDisplayFunc(drawScene);
glutIdleFunc(idle);
glutReshapeFunc(resize);
glutKeyboardFunc(keyboard);
glutSpecialFunc(special);
glClearColor(0.0, 0.0, 0.0, 1.0);
glClearDepth(1.0);
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glLightfv(GL_LIGHT0, GL_AMBIENT, propertiesAmbient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, propertiesDiffuse);
glLightfv(GL_LIGHT0, GL_SPECULAR, propertiesSpecular);
glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, 1.0);
glEnable(GL_LIGHT0);
glMaterialfv(GL_BACK, GL_AMBIENT, ambientGreen);
glMaterialfv(GL_BACK, GL_DIFFUSE, diffuseGreen);
glMaterialfv(GL_FRONT, GL_AMBIENT, ambientBlue);
glMaterialfv(GL_FRONT, GL_DIFFUSE, diffuseBlue);
glMaterialfv(GL_FRONT, GL_SPECULAR, specularWhite);
glMaterialf(GL_FRONT, GL_SHININESS, 25.0);
resize(width, height);
glutMainLoop();
return 0;
}
void main(int argc, char **argv)
{
GLfloat afPropertiesAmbient [] = {0.50, 0.50, 0.50, 1.00};
GLfloat afPropertiesDiffuse [] = {0.75, 0.75, 0.75, 1.00};
GLfloat afPropertiesSpecular[] = {1.00, 1.00, 1.00, 1.00};
GLsizei iWidth = 640.0;
GLsizei iHeight = 480.0;
glutInit(&argc, argv);
glutInitWindowPosition( 0, 0);
glutInitWindowSize(iWidth, iHeight);
glutInitDisplayMode( GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE );
glutCreateWindow( "Marching Cubes" );
glutDisplayFunc( vDrawScene );
glutIdleFunc( vIdle );
glutReshapeFunc( vResize );
glutKeyboardFunc( vKeyboard );
glutSpecialFunc( vSpecial );
glClearColor( 0.0, 0.0, 0.0, 1.0 );
glClearDepth( 1.0 );
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);
glPolygonMode(GL_FRONT_AND_BACK, ePolygonMode);
glLightfv( GL_LIGHT0, GL_AMBIENT, afPropertiesAmbient);
glLightfv( GL_LIGHT0, GL_DIFFUSE, afPropertiesDiffuse);
glLightfv( GL_LIGHT0, GL_SPECULAR, afPropertiesSpecular);
glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, 1.0);
glEnable( GL_LIGHT0 );
glMaterialfv(GL_BACK, GL_AMBIENT, afAmbientGreen);
glMaterialfv(GL_BACK, GL_DIFFUSE, afDiffuseGreen);
glMaterialfv(GL_FRONT, GL_AMBIENT, afAmbientBlue);
glMaterialfv(GL_FRONT, GL_DIFFUSE, afDiffuseBlue);
glMaterialfv(GL_FRONT, GL_SPECULAR, afSpecularWhite);
glMaterialf( GL_FRONT, GL_SHININESS, 25.0);
vResize(iWidth, iHeight);
vPrintHelp();
glutMainLoop();
}
void glLightModeliv(GLenum pname, const GLint *iparams) {
switch (pname) {
case GL_LIGHT_MODEL_AMBIENT: {
GLfloat params[4];
for (int i = 0; i < 4; i++) {
params[i] = iparams[i];
}
glLightModelfv(pname, params);
break;
}
case GL_LIGHT_MODEL_LOCAL_VIEWER:
case GL_LIGHT_MODEL_TWO_SIDE: {
glLightModelf(pname, *iparams);
break;
}
}
}
void vwLight::SetDefaultMaterial()
{
//glEnable(GL_TEXTURE_2D); // Enable Texture Mapping
glShadeModel(GL_SMOOTH); // Enable Smooth Shading
//glClearColor(0.5f,0.5f,0.5f,1.0f); // We'll Clear To The Color Of The Fog
glClearColor(0.0f,0.0f,0.0f,1.0f);
glClearDepth(1.0f); // Depth Buffer Setup
glEnable(GL_DEPTH_TEST); // Enables Depth Testing
glDepthFunc(GL_LEQUAL); // The Type Of Depth Testing To Do
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Really Nice Perspective Calculations
// Enable blending
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
{
// Lights
GLfloat ambientProperties[] = {0.5f, 0.5f, 0.5f, 1.0f};//{0.1f, 0.1f, 0.1f, 1.0f};
GLfloat diffuseProperties[] = {0.5f, 0.5f, 0.5f, 1.0f};
GLfloat specularProperties[] = {0.1f, 0.1f, 0.1f, 1.0f};
glLightfv( GL_LIGHT0, GL_AMBIENT, ambientProperties);
glLightfv( GL_LIGHT0, GL_DIFFUSE, diffuseProperties);
glLightfv( GL_LIGHT0, GL_SPECULAR, specularProperties);
glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, 1.0);
glPolygonMode(GL_FRONT,GL_FILL);
//glPolygonMode(GL_FRONT,GL_LINE);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHTING);
glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,diffuseProperties);
glEnable( GL_COLOR_MATERIAL );
}
{
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
//glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
}
}
/*!
* \internal
* \brief Applies default polygon mode to OpenGL.
*/
static void m3gApplyDefaultPolygonMode()
{
/* cull = BACK */
glCullFace(GL_BACK);
glEnable(GL_CULL_FACE);
/* shading = M3G_SHADE_SMOOTH */
glShadeModel(GL_SMOOTH);
/* winding = M3G_WINDING_CCW */
glFrontFace(GL_CCW);
/* perspective correction = false */
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
/* lighting = ONE_SIDED */
glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE);
}
void CArMaXCtrl::InitScene()
{
// Lights properties
//float ambientProperties[] = {0.1f, 0.1f, 0.1f, 1.0f};
float diffuseProperties[] = {1.0f, 1.0f, 1.0f, 1.0f};
float specularProperties[] = {1.0f, 1.0f, 1.0f, 1.0f};
//glLightfv( GL_LIGHT0, GL_AMBIENT, ambientProperties);
glLightfv( GL_LIGHT0, GL_DIFFUSE,diffuseProperties);
glLightfv( GL_LIGHT0, GL_SPECULAR, specularProperties);
glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, 1.0);
COLORREF backF = GetSysColor(COLOR_BTNFACE);
/*glClearColor(GetRValue(backF)/255.0,
GetGValue(backF)/255.0,
GetBValue(backF)/255.0,
1.0f);#WARNING*/
glClearColor((GLclampf)(GetRValue(backF)/255.0),
(GLclampf)(GetGValue(backF)/255.0),
(GLclampf)(GetBValue(backF)/255.0),
(GLclampf)1.0f);
glHint(GL_LINE_SMOOTH_HINT,GL_FASTEST);
// Texture
glEnable(GL_TEXTURE_2D);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
// Default : lighting
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
// Default : blending
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_DEPTH_TEST);
}
void GloxLightSource::render() const {
if( ! this->isEnabled() ) {
GloxTrace( "GloxLightSource", "Light %d Disabled\n", index );
return ;
}
for( M_lm_map_t::const_iterator itr = lightModelsAttrs.begin();
/* Set all of the attributes in the map */
itr != lightModelsAttrs.end() ; ++ itr ) {
glLightModelf( (*itr).first, (*itr).second );
}
float vec[4];
for( M_lm_map_vec_t::const_iterator itr = lightModelsAttrs_vectors.begin();
/* Set all of the attributes in the map */
itr != lightModelsAttrs_vectors.end() ; ++ itr ) {
(*itr).second.toVector( vec, 4 );
glLightModelfv( (*itr).first, vec );
}
glEnable( m_light );
this->ambient.toVector( vec, 4 );
//GloxTrace( "GloxLightSource", "ambient: {%f, %f, %f, %f}\n", vec[0], vec[1], vec[2], vec[3] );
glLightfv(m_light,GL_AMBIENT, vec);
this->diffuse.toVector( vec, 4 );
//GloxTrace( "GloxLightSource", "diffuse: %s\n", this->diffuse.toString().c_str() );
//GloxTrace( "GloxLightSource", "diffuse: {%f, %f, %f, %f}\n", vec[0], vec[1], vec[2], vec[3] );
glLightfv(m_light,GL_DIFFUSE ,vec);
this->specular.toVector( vec, 4 );
//GloxTrace( "GloxLightSource", "specular: {%f, %f, %f, %f}\n", vec[0], vec[1], vec[2], vec[3] );
glLightfv(m_light,GL_SPECULAR,vec);
/* enable this light */
glEnable( this->m_light );
this->m_pos.toVector( vec, 4 );
glLightfv(m_light,GL_POSITION,vec);
}
void GLScene::paintGL ()
{
//set background color
//glClearColor(m_background[0], m_background[1], m_background[2], m_background[3]);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//NOTE:
glMatrixMode(GL_MODELVIEW); // Drawing perspective
glLoadIdentity(); // Reset camera position
//Camera Mode Lighting
glLightModelf(GL_LIGHT_MODEL_LOCAL_VIEWER, 1.0f);
// Add ambient light
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, m_ambientColor.c_array());
// Adjust for camera position
Camera.Render();
//Add light
const GLfloat lightColor0[] = {0.5f, 0.2f, 0.2f, 1.0f};
const GLfloat lightPos0[] = {5.0f, 0.0f, -5.0f, 1.0f};
//GLfloat lightPos0[] = {Camera.Position.x, Camera.Position.y, Camera.Position.z, 1.0f};
glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor0);
glLightfv(GL_LIGHT0, GL_POSITION, lightPos0);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, lightColor0);
//Add light
GLfloat lightColor1[] = {0.2f, 0.5f, 0.2f, 1.0f};
GLfloat lightPos1[] = {10.0f, 10.0f, 5.0f, 1.0f};
glLightfv(GL_LIGHT1, GL_DIFFUSE, lightColor1);
glLightfv(GL_LIGHT1, GL_POSITION, lightPos1);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, lightColor1);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, lightColor1);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 20.0f);
// Draw maze
RenderMaze();
}
void grInit(int *argc, char **argv)
{
glutInit(argc, argv);
glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH );
glutInitWindowSize( WIDTH, HEIGHT);
glutCreateWindow( "Bunny simulation" );
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glDisable(GL_DITHER);
glClearColor( 0.0, 0.0, 0.0, 0.0 );
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
GLfloat light_position[] = {2.732*WallDist, 0.0, 0.0, 1.0};
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
glLightModelf(GL_LIGHT_MODEL_LOCAL_VIEWER, 0.0);
glPopMatrix();
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glMatrixMode( GL_PROJECTION );
glLoadIdentity( );
gluPerspective(60.0, ((float)(WIDTH)) / ((float)(HEIGHT)), 0.1, 10000.0);
gluLookAt(2.732*WallDist, 0, 0, 0, 0, 0, 0, 0, 1);
glMatrixMode( GL_MODELVIEW );
glutDisplayFunc(DisplayFunc);
glutIdleFunc(DisplayFunc);
glutKeyboardFunc(KeyboardFunc);
glutMainLoop();
}
void GLWidget::initializeGL(){
glClearColor(0, 0, 0, 1);
glShadeModel(GL_FLAT);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glLoadIdentity();
//glOrtho(-50,50,-50,50,-2000,2000);
gluPerspective(75,1,50,2000);
glMatrixMode(GL_MODELVIEW);
//Enabling the shading model
glEnable(GL_LIGHTING);
//Enabling normal vector normalization
glEnable(GL_NORMALIZE);
//Disabling global ambient light (In this example no ambient light will be present.)
GLfloat globalAmbient[]={0,0,0};
glLightModelf(GL_LIGHT_MODEL_TWO_SIDE,GL_TRUE);
// glLightModelfv(GL_LIGHT_MODEL_AMBIENT,globalAmbient);
//Defining the position of the point light source GL_LIGHT0 at (x,y,z)=(0,0,40)
GLfloat light0Position[]={-90,-90,40,1};
glLightfv(GL_LIGHT0,GL_POSITION,light0Position);
//Defining "diffuse" lighting properties for GL_LIGHT0
GLfloat light0Diffuse[]={1,1,1};
glLightfv(GL_LIGHT0,GL_DIFFUSE,light0Diffuse);
//Defining "specular" lighting properties for GL_LIGHT0
GLfloat light0Specular[]={1,1,1};
glLightfv(GL_LIGHT0,GL_SPECULAR,light0Specular);
glEnable(GL_LIGHT0);
glPointSize(1.8);
scale = 1.0;
}
void initGL( void )
{
glEnable( GL_DEPTH_TEST );
glClearColor( 0,0,1,1 );
glPointSize( 2.0 );
static float light0_ambient[] = {0.1f, 0.1f, 0.1f, 1.0f};
static float light0_diffuse[] = {1.0f, 1.0f, 1.0f, 0.0f};
static float light0_position[] = {0.0f, 0.0f,1000.0f, 0.0f};
static float light0_specular[] = {0.4f, 0.4f, 0.4f, 1.0f};
glLightfv( GL_LIGHT0, GL_AMBIENT, light0_ambient );
glLightfv( GL_LIGHT0, GL_DIFFUSE, light0_diffuse );
glLightfv( GL_LIGHT0, GL_SPECULAR, light0_specular );
glLightfv( GL_LIGHT0, GL_POSITION, light0_position );
glLightModelf( GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE );
glEnable( GL_LIGHT0 );
glEnable( GL_LIGHTING );
}
void PickScene::init()
{
// normal init, no changes needed
// Enables lighting computations
glEnable(GL_LIGHTING);
// Sets up some lighting parameters
glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, CGFlight::background_ambient); // Define ambient light
// Declares and enables a light
float light0_pos[4] = {4.0, 6.0, 5.0, 1.0};
light0 = new CGFlight(GL_LIGHT0, light0_pos);
light0->enable();
// Defines a default normal
glNormal3f(0,0,1);
obj=new ExampleObject();
materialAppearance=new CGFappearance();
}
//
// InitScene()
// Called when the OpenGL RC has been created. Sets initial state for the OpenGL scene.
//
void CDemoApp::InitScene()
{
OnBnClickedPrSpheres();
// Lights properties
//float ambientProperties[] = {0.1f, 0.1f, 0.1f, 1.0f};
float diffuseProperties[] = {1.0f, 1.0f, 1.0f, 1.0f};
float specularProperties[] = {1.0f, 1.0f, 1.0f, 1.0f};
//glLightfv( GL_LIGHT0, GL_AMBIENT, ambientProperties);
glLightfv( GL_LIGHT0, GL_DIFFUSE,diffuseProperties);
glLightfv( GL_LIGHT0, GL_SPECULAR, specularProperties);
glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, 1.0);
glClearColor(1.0,1.0,1.0,1.0f);
glHint(GL_LINE_SMOOTH_HINT,GL_FASTEST);
// Texture
glEnable(GL_TEXTURE_2D);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
// Default : lighting
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
// Default : blending
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_DEPTH_TEST);
// glEnable(GL_CULL_FACE);
}
