imported>Unknown at 05:28, 7 February 2021

2021-02-07T05:28:04Z

New page

#include <windows.h>
#include <gl\gl.h>
#include <gl\glu.h>
#include <gl\glaux.h>
#include <stdio.h>
#include <cmath>
HGLRC hRC=NULL;
HDC hDC=NULL;
HWND hWnd = NULL;
HINSTANCE hInstance;

GLUquadricObj *obj;

GLfloat xrot=0.0f;
GLfloat yrot=0.0f;

GLfloat o1_rot = 0.0f;
GLfloat o2_rot1 = 0.0f;
GLfloat o2_rot2 = 0.0f; //수성
GLfloat o3_rot = 0.0f; //금성
GLfloat o4_rot = 0.0f;//지구
GLfloat o5_rot = 0.0f;//화성
GLfloat o6_rot = 0.0f;//목성
GLfloat o7_rot = 0.0f;//토성
GLfloat o8_rot = 0.0f;//천왕성
GLfloat o9_rot = 0.0f;//해왕성
GLfloat o10_rot = 0.0f;//명왕성

GLfloat distance1 = 2.0f;//수성
GLfloat distance2 = 3.2f;//금성
GLfloat distance3 = 4.2f;//지구
GLfloat distance4 = 5.2f;//화성
GLfloat distance5 = 6.2f;//목성
GLfloat distance6 = 7.2f;//토성
GLfloat distance7 = 8.2f;//천왕성
GLfloat distance8 = 9.2f;//해왕성
GLfloat distance9 = 10.2f;//명왕성

float ambientLight[] = {0.5f,0.5f,0.5f,1.0f};
float diffuseLight[] = {0.25f,0.25f,0.25f,1.0f};
float lightPosition[] = {0.0f,0.0f,0.0f,1.0f};

float matAmbient[] = {1.0f,1.0f,1.0f,1.0f};
float matDiff[] = {1.0f,1.0f,1.0f,1.0f};

bool keys[256];
bool active=TRUE;
bool fullscreen=TRUE;

LRESULT CALLBACK WndProc(HWND,UINT,WPARAM,LPARAM);

GLvoid ReSizeGLScene(GLsizei width, GLsizei height)
{
if(height==0)
height=1;

glViewport(0,0,width,height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
// Calculate The Aspect Ratio Of The Window
gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,100.0f);

glMatrixMode(GL_MODELVIEW); // Select The Modelview Matrix
glLoadIdentity();
}

int InitGL(GLvoid)
{
glClearColor(0.0f,0.0f,0.0f,0.0f);
glShadeModel(GL_SMOOTH);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glFrontFace(GL_CCW);
glEnable(GL_LIGHTING);

glMaterialfv(GL_FRONT,GL_AMBIENT,matAmbient);
glMaterialfv(GL_FRONT,GL_DIFFUSE,matDiff);

glLightfv(GL_LIGHT0,GL_AMBIENT, ambientLight);
glLightfv(GL_LIGHT0,GL_DIFFUSE,diffuseLight);
glLightfv(GL_LIGHT0,GL_POSITION,lightPosition);

glEnable(GL_LIGHT0);

glClearDepth(1.0f);

glDepthFunc(GL_LEQUAL);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);

obj = gluNewQuadric();
gluQuadricNormals(obj, GLU_SMOOTH);
gluQuadricOrientation(obj, GLU_OUTSIDE);
gluQuadricTexture(obj,GL_FALSE);

// glEnable(GL_LIGHT0);
glEnable(GL_COLOR_MATERIAL);

return TRUE;
}

void CorrectOfCoordinate(float distance,float x,float y, float z)
{
float absolute = float(sqrt(x*x+y*y+z*z));
float cosin = x/absolute;
float sin = y/absolute;
glTranslatef(-distance*cosin*cosin,-distance*sin*cosin,0.0f);
}

int DrawGLScene(GLvoid)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glTranslatef(0.0f,0.0f,-22.0f);
glRotatef(yrot,1.0f,0.0f,0.0f);
glRotatef(xrot,0.0f,1.0f,0.0f);

glPushMatrix();
glRotatef(o1_rot,0.0f,1.0f,0.0f);
gluQuadricDrawStyle(obj,GLU_FILL);
glColor3f(0.5f,0.0f,0.0f);
gluSphere(obj,1.0f,24,24);
gluQuadricDrawStyle(obj,GLU_LINE);
glColor3f(1.0f,1.0f,1.0f);
gluCylinder(obj,1.0f,1.0f,0.1,24,24);
glPopMatrix();

glPushMatrix();
glRotatef(o2_rot1,0.0f,1.0f,0.0f);
glTranslatef(distance1,0.0f,0.0f);
glRotatef(o2_rot2,0.0f,1.0f,0.0f);
gluQuadricDrawStyle(obj,GLU_FILL);
glColor3f(0.3f,0.5f,0.8f);
gluSphere(obj,0.4f,12,12);
glPopMatrix();

glPushMatrix();
CorrectOfCoordinate(distance2,1.0f,1.0f,0.0f);
glRotatef(o3_rot,1.0f,1.0f,0.0f);
glTranslatef(distance2,0,0.0f);
glRotatef(o3_rot,0.0f,1.0f,0.0f);
gluQuadricDrawStyle(obj,GLU_FILL);
glColor3f(0.2f,0.1f,0.4f);
gluSphere(obj,0.2f,12,12);
glPopMatrix();

glPushMatrix();
CorrectOfCoordinate(distance3,1.0f,1.0f,0.0f);
glRotatef(o4_rot,0.2f,0.2f,0.0f);
glTranslatef(distance3,0.0f,0.0f);
glRotatef(o4_rot,0.0f,1.0f,0.0f);
gluQuadricDrawStyle(obj,GLU_FILL);
glColor3f(0.3f,0.5f,0.8f);
gluSphere(obj,0.4f,12,12);
glPopMatrix();

glPushMatrix();
CorrectOfCoordinate(distance4,0.1f,1.2f,0.0f);
glRotatef(o5_rot,0.1f,1.2f,0.0f);
glTranslatef(distance4,0.0f,0.0f);
glRotatef(o5_rot,0.0f,1.0f,0.0f);
gluQuadricDrawStyle(obj,GLU_FILL);
glColor3f(0.2f,0.7f,0.7f);
gluSphere(obj,0.4f,12,12);
glPopMatrix();

glPushMatrix();
CorrectOfCoordinate(distance5,0.07f,0.06f,0.0f);
glRotatef(o6_rot,0.07f,0.06f,0.0f);
glTranslatef(distance5,0.0f,0.0f);
glRotatef(o6_rot,0.0f,1.0f,0.0f);
gluQuadricDrawStyle(obj,GLU_FILL);
glColor3f(0.7f,0.8f,0.4f);
gluSphere(obj,0.4f,12,12);
glPopMatrix();

glPushMatrix();
CorrectOfCoordinate(distance6,0.0f,1.0f,0.0f);
glRotatef(o7_rot,0.0f,1.0f,0.0f);
glTranslatef(distance6,0.0f,0.0f);
glRotatef(o7_rot,0.0f,1.0f,0.0f);
gluQuadricDrawStyle(obj,GLU_FILL);
glColor3f(0.0f,0.5f,0.2f);
gluSphere(obj,0.4f,12,12);
glPopMatrix();

glPushMatrix();
CorrectOfCoordinate(distance7,0.7f,1.0f,0.0f);
glRotatef(o8_rot,0.7f,1.0f,0.0f);
glTranslatef(distance7,0.0f,0.0f);
glRotatef(o8_rot,0.0f,1.0f,0.0f);
gluQuadricDrawStyle(obj,GLU_FILL);
glColor3f(0.0f,0.5f,0.8f);
gluSphere(obj,0.4f,12,12);
glPopMatrix();

glPushMatrix();
CorrectOfCoordinate(distance8,0.1f,1.0f,0.0f);
glRotatef(o9_rot,0.1f,1.0f,0.0f);
glTranslatef(distance8,0.0f,0.0f);
glRotatef(o9_rot,0.0f,1.0f,0.0f);
gluQuadricDrawStyle(obj,GLU_FILL);
glColor3f(0.7f,0.8f,1.0f);
gluSphere(obj,0.9f,12,12);
glPopMatrix();

glPushMatrix();
CorrectOfCoordinate(distance2,0.3f,1.0f,0.0f);
glRotatef(o10_rot,0.3f,1.0f,0.0f);
glTranslatef(distance9,0.0f,0.0f);
glRotatef(o10_rot,0.0f,1.0f,0.0f);
gluQuadricDrawStyle(obj,GLU_FILL);
glColor3f(0.3f,0.5f,1.0f);
gluSphere(obj,0.7f,12,12);
glPopMatrix();
o1_rot+=2.5f;
if(o1_rot>359.9f)
o1_rot=0.0f;
o2_rot1+=1.05f;
if(o2_rot1>359.95f)
o2_rot1=0.0f;
o2_rot2+=4.0f;
if(o2_rot2>358.0f)
o2_rot2=0;
o3_rot+=1.2f;
o4_rot+=1.8f;
o5_rot+=2.6f;
o6_rot+=3.9f;
o7_rot+=0.6f;
o8_rot+=1.3f;
o9_rot+=3.4f;
o10_rot+=3.8f;

return TRUE;
}

GLvoid KillGLWindow(GLvoid)
{
if(fullscreen)
{
ChangeDisplaySettings(NULL,0);
ShowCursor(TRUE);
}

if(hRC)
{
if(!wglMakeCurrent(NULL,NULL))
{
MessageBox(NULL,"Release Of DC And RC Failed.","SHUTDOWN ERROR",
MB_OK | MB_ICONINFORMATION);
}

if(!wglDeleteContext(hRC))
{
MessageBox(NULL,"Release Rendering Context Failed.","SHUTDOWN ERROR",
MB_OK | MB_ICONINFORMATION);
}
hRC = NULL;

if(hDC && !ReleaseDC(hWnd,hDC))
{
MessageBox(NULL,"Release Device Context Failed.","SHUTDOWN ERROR",
MB_OK | MB_ICONINFORMATION);
hDC = NULL;
}

if(hWnd && !DestroyWindow(hWnd))
{
MessageBox(NULL,"Could Not Release hWnd","SHUTDOWN ERROR",
MB_OK | MB_ICONINFORMATION);
hWnd = NULL;
}
if(!UnregisterClass("OpenGL",hInstance))
{
MessageBox(NULL,"Could Not Unregister Class","SHUTDOWN ERROR",
MB_OK | MB_ICONINFORMATION);
hInstance = NULL;
}
}
}

BOOL CreateGLWindow(char *title, int width, int height, int bits, bool fullscreenflag)
{
GLuint PixelFormat;
WNDCLASS wc;
DWORD dwExStyle;
DWORD dwStyle;

RECT WindowRect;
WindowRect.left=(long)0;
WindowRect.right=(long)width;
WindowRect.top=(long)0;
WindowRect.bottom=(long)height;
fullscreen = fullscreenflag;
hInstance = GetModuleHandle(NULL);
wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
wc.lpfnWndProc=(WNDPROC)WndProc;
wc.cbClsExtra=0;
wc.cbWndExtra=0;
wc.hInstance=hInstance;
wc.hIcon = LoadIcon(NULL,IDI_WINLOGO);
wc.hCursor=LoadCursor(NULL,IDC_ARROW);
wc.hbrBackground=NULL;
wc.lpszMenuName=NULL;
wc.lpszClassName="OpenGL";

if(!RegisterClass(&wc))
{
MessageBox(NULL,"Failed To Register The Window Class."
,"ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE;
}

if(fullscreen)
{
DEVMODE dmScreenSettings;
memset(&dmScreenSettings,0,sizeof(dmScreenSettings));
dmScreenSettings.dmPelsWidth = width;
dmScreenSettings.dmPelsHeight = height;
dmScreenSettings.dmBitsPerPel=bits;
dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;

if(ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL)
{
if(MessageBox(NULL,"The Requested FUllscreen Mode is Not Supported By\n Your video Card. Use Windowed Mode Instead?","NeHeGl",MB_YESNO|
MB_ICONEXCLAMATION)==IDYES){
fullscreen=FALSE;
}
else
{
MessageBox(NULL,"Program Will Now Close","ERROR",MB_OK|MB_ICONSTOP);
return FALSE;
}
}
}

if(fullscreen)
{
dwExStyle=WS_EX_APPWINDOW;
dwStyle=WS_POPUP;
ShowCursor(FALSE);
}
else
{
dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
dwStyle=WS_OVERLAPPEDWINDOW;
}

AdjustWindowRectEx(&WindowRect,dwStyle,FALSE,dwExStyle);

if(!(hWnd=CreateWindowEx(dwExStyle,
"OpenGL",
title,
WS_CLIPSIBLINGS |
WS_CLIPCHILDREN |
dwStyle,
0,0,
WindowRect.right-WindowRect.left,
WindowRect.bottom-WindowRect.top,
NULL,
NULL,
hInstance,
NULL)))
{
KillGLWindow();
MessageBox(NULL,"Window Creation Error",
"Error",MB_OK|MB_ICONEXCLAMATION);
return FALSE;
}

static PIXELFORMATDESCRIPTOR pfd =
{
sizeof(PIXELFORMATDESCRIPTOR),
1,
PFD_DRAW_TO_WINDOW |
PFD_SUPPORT_OPENGL |
PFD_DOUBLEBUFFER,
PFD_TYPE_RGBA,
bits,
0,0,0,0,0,0,
0,
0,
0,
0,0,0,0,
16,
0,
0,
PFD_MAIN_PLANE,
0,
0,0,0
};

if(!(hDC=GetDC(hWnd)))
{
KillGLWindow();
MessageBox(NULL,"Can't Creat A GL Device Context","ERROR",MB_OK|MB_ICONEXCLAMATION);

return FALSE;
}

if(!(PixelFormat=ChoosePixelFormat(hDC,&pfd)))
{
KillGLWindow();
MessageBox(NULL,"Can't Find A Suitable PixelFormat"
,"ERROR",MB_OK|MB_ICONEXCLAMATION);

return FALSE;
}

if(!SetPixelFormat(hDC,PixelFormat,&pfd))
{
KillGLWindow();
MessageBox(NULL,"Can't Set The PixelFormat"
,"ERROR",MB_OK|MB_ICONEXCLAMATION);

return FALSE;
}

if(!(hRC=wglCreateContext(hDC)))
{
KillGLWindow();
MessageBox(NULL,"Cant't Create A GL Rendering Context"
,"ERROR",MB_OK|MB_ICONEXCLAMATION);

return FALSE;
}

if(!wglMakeCurrent(hDC,hRC))
{
KillGLWindow();
MessageBox(NULL,"Can't Activate The GL Rendering Context"
,"ERROR",MB_OK|MB_ICONEXCLAMATION);

return FALSE;
}

ShowWindow(hWnd,SW_SHOW);
SetForegroundWindow(hWnd);
SetFocus(hWnd);
ReSizeGLScene(width,height);

if(!InitGL())
{
KillGLWindow();
MessageBox(NULL,"Initialization Failed"
,"ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE;

}

return TRUE;
}

LRESULT CALLBACK WndProc(HWND hWnd,
UINT uMsg,
WPARAM wParam,
LPARAM lParam)
{
switch(uMsg)
{
case WM_ACTIVATE:
{
if(!HIWORD(wParam))
active=TRUE;
else
active = FALSE;
return 0;
}

case WM_SYSCOMMAND:
{
switch(wParam)
{
case SC_SCREENSAVE:
case SC_MONITORPOWER:
return 0;
}
break;
}

case WM_CLOSE:
{
PostQuitMessage(0);
return 0;
}

case WM_KEYDOWN:
{
keys[wParam] = TRUE;
return 0;
}

case WM_KEYUP:
{
keys[wParam] = FALSE;
return 0;
}

case WM_SIZE:
{
ReSizeGLScene(LOWORD(lParam),HIWORD(lParam));

return 0;
}
}
return DefWindowProc(hWnd,uMsg,wParam,lParam);
}

int WINAPI WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow)
{
MSG msg;
BOOL done=FALSE;

if(MessageBox(NULL,"Would you like to run in FullScreen mode?",
"Start FullScreen?",MB_YESNO|MB_ICONQUESTION)==IDNO)
{
fullscreen=FALSE;
}

if(!CreateGLWindow("namsang's OpenGL FrameWork",604,480,16,fullscreen))
{
return 0;
}

while(!done)
{
if(PeekMessage(&msg,NULL,0,0,PM_REMOVE))
{
if(msg.message==WM_QUIT)
done=TRUE;
else
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}

if((active && !DrawGLScene()) || keys[VK_ESCAPE])
done=TRUE;
else
SwapBuffers(hDC);

if(keys[VK_F1])
{
keys[VK_F1]=FALSE;
KillGLWindow();
fullscreen=!fullscreen;
if(!CreateGLWindow("namsang's OPenGL FrameWork"
,640,480,16,fullscreen))
{
return 0;
}
}
if(keys[VK_LEFT])
yrot+=0.2f;
if(keys[VK_RIGHT])
yrot-=0.2f;
if(keys[VK_UP])
xrot+=0.2f;
if(keys[VK_DOWN])
xrot-=0.2f;
if(keys[VK_RETURN])
{
xrot=0;
yrot=0;
}

}
KillGLWindow();
return (msg.wParam);
}

SolarSystem/상협 - Revision history

imported>Unknown at 05:28, 7 February 2021