Hi,
Attached is the code below for projectile motion. I am trying to
draw the graph but OpenGL is giving me some strange problem.

Can anyone please tell me the problem and solution.

Thank You,
Raja
---------------------------------------------------------------------------------------
#include
#include
#include
#include
#include // Header File For The OpenGL32 Library
#include
#include
#pragma comment( lib, "opengl32.lib" ) // Search For OpenGL32.lib
While Linking
#pragma comment( lib, "glu32.lib" ) // Search For GLu32.lib While
Linking
#pragma comment( lib, "vfw32.lib" ) // Search For VFW32.lib While
Linking

double xold=0, yold=0;
int Paint(void);
LONG WINAPI WndProc(HWND,UINT,WPARAM,LPARAM);//Window procedure
HGLRC SetUpOpenGL(HWND hwnd);//Initialize OpenGL
void DrawOpenGLScene(void);//Actual Drawing code
double **arry;
int count=0;

int main()
{

double v,a,t,r,s,c,x=0,y;
int i=0;

//clrscr();

printf("Projectile Motion Program\n");
do {
printf("Enter initial velocity (floating point number): ");
scanf("%%lf",&v);
}while ((v < 0) || (v > 100));
do {
printf("Enter the angle of projection (in degrees): ");
scanf("%%lf",&a);
}while ((a < 5) || (a > 85));
a=0.0175*a; //Converting degrees into radians

printf("The range of the projectile is: %%lf \n ",pow(v,2)*(sin(2*a))/
10);

r=pow(v,2)*(sin(2*a))/10;
s=v*sin(a);
c=v*cos(a);

for(t=0;x<=r;t=t+0.5)
{
x=c*t;
count++;
}
printf("%%d is the count for range %%lf \n", count, r);
arry=(double **)malloc(sizeof(double *)*count);
for(i=0;i {
arry[i]=(double *)malloc(sizeof(double)*2);
}
x=0;
for(i=0,t=0;x<=r;t=t+0.5,i++)
{
x=c*t;
y=s*t - 5*t*t;
arry[i][0]=x;
arry[i][1]=y;

}
getch();
Paint();
return 0;
}

int Paint(void)
{
HINSTANCE hInstance=NULL,hPrevInstance=NULL;
LPSTR lpCmdLine;
int nCmdShow;
static char szAppName[] = "OpenGL";
static char szTitle[]="Getting Started With Projectile Motion";
WNDCLASS wc; // windows class sruct
MSG msg; // message struct
HWND hWnd; // Main window handle.

// Fill in window class structure with parameters that
// describe the main window.

wc.style =
CS_HREDRAW | CS_VREDRAW;// Class style(s).
wc.lpfnWndProc =
(WNDPROC)WndProc; // Window Procedure
wc.cbClsExtra = 0; // No per-class extra data.
wc.cbWndExtra = 0; // No per-window extra data.
wc.hInstance =
hInstance; // Owner of this class
wc.hIcon = NULL; // Icon name
wc.hCursor =
LoadCursor(NULL, IDC_ARROW);// Cursor
wc.hbrBackground =
(HBRUSH)(COLOR_WINDOW+1);// Default color
wc.lpszMenuName = NULL; // Menu from .RC
wc.lpszClassName =
szAppName; // Name to register as

// Register the window class
RegisterClass( &wc );

// Create a main window for this application instance.

hWnd = CreateWindow(
szAppName, // app name
szTitle, // Text for window title bar
WS_OVERLAPPEDWINDOW// Window style
// NEED THESE for OpenGL calls to work!
| WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
CW_USEDEFAULT, 0, CW_USEDEFAULT, 0,
NULL, // no parent window
NULL, // Use the window class menu.
hInstance,// This instance owns this window
NULL // We don't use any extra data
);

// If window could not be created, return zero
if ( !hWnd )
{
return( 0 );
}

// Make the window visible & update its client area
ShowWindow( hWnd, 1 );// Show the window
UpdateWindow( hWnd ); // Sends WM_PAINT message

// Enter the Windows message loop
// Get and dispatch messages until WM_QUIT
while (GetMessage(&msg, // message structure
NULL, // handle of window receiving
// the message
0, // lowest message id to examine
0)) // highest message id to examine
{
TranslateMessage( &msg ); // Translates messages
DispatchMessage( &msg ); // then dispatches
}

return( msg.wParam );

}

LONG WINAPI WndProc( HWND hWnd, UINT msg,
WPARAM wParam, LPARAM lParam )
{
HDC hDC;
static HGLRC hRC; // Note this is STATIC!
PAINTSTRUCT ps;
GLdouble gldAspect;
GLsizei glnWidth, glnHeight;

switch(msg)
{
case WM_CREATE:
// Select a pixel format and then
// create a rendering context from it.
hRC = SetUpOpenGL(hWnd);
return 0;

case WM_SIZE:
// Redefine the viewing volume and viewport
// when the window size changes.

// Make the RC current since we're going to
// make an OpenGL call here...
hDC = GetDC(hWnd);
wglMakeCurrent(hDC,hRC);

// get the new size of the client window
// note that we size according to the height,
// not the smaller of the height or width.
glnWidth = (GLsizei) LOWORD (lParam);
glnHeight = (GLsizei) HIWORD (lParam);
gldAspect =
(GLdouble)glnWidth/(GLdouble)glnHeight;

// set up a projection matrix to fill the
// client window
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
// a perspective-view matrix...
gluPerspective(
30.0, // Field-of-view angle
gldAspect, // Aspect ratio of view volume
1.0, // Distance to near clipping plane
10.0 ); // Distance to far clipping plane

glViewport( 0, 0, glnWidth, glnHeight );
wglMakeCurrent( NULL, NULL );
ReleaseDC( hWnd, hDC );

return 0;

case WM_PAINT:

// Draw the scene.

// Get a DC, then make the RC current and
// associate with this DC
hDC = BeginPaint( hWnd, &ps );
wglMakeCurrent( hDC, hRC );

DrawOpenGLScene();

// we're done with the RC, so
// deselect it
// (note: This technique is not recommended!)
wglMakeCurrent( NULL, NULL );

EndPaint( hWnd, &ps );
return 0;

case WM_DESTROY:
// Clean up and terminate.
wglDeleteContext( hRC );
PostQuitMessage( 0 );
return 0;

}

// This function handles any messages that we didn't.
// (Which is most messages) It belongs to the OS.
return DefWindowProc( hWnd, msg, wParam, lParam );

}

HGLRC SetUpOpenGL( HWND hWnd )
{
static PIXELFORMATDESCRIPTOR pfd = {
sizeof (PIXELFORMATDESCRIPTOR), // strcut size
1, // Version number
PFD_DRAW_TO_WINDOW | // Flags, draw to a window,
PFD_SUPPORT_OPENGL, // use OpenGL
PFD_TYPE_RGBA, // RGBA pixel values
32, // 32-bit color
0, 0, 0, // RGB bits & shift sizes.
0, 0, 0, // Don't care about them
0, 0, // No alpha buffer info
0, 0, 0, 0, 0, // No accumulation buffer
32, // 32-bit depth buffer
0, // No stencil buffer
0, // No auxiliary buffers
PFD_MAIN_PLANE, // Layer type
0, // Reserved (must be 0)
0, // No layer mask
0, // No visible mask
0 // No damage mask
};

int nMyPixelFormatID;

HDC hDC;
HGLRC hRC;

hDC = GetDC( hWnd );

nMyPixelFormatID = ChoosePixelFormat( hDC, &pfd );

// catch errors here.
// If nMyPixelFormat is zero, then there's
// something wrong... most likely the window's
// style bits are incorrect (in CreateWindow() )
// or OpenGl isn't installed on this machine
if(nMyPixelFormatID==0)
exit(0);
SetPixelFormat( hDC, nMyPixelFormatID, &pfd );

hRC = wglCreateContext( hDC );
ReleaseDC( hWnd, hDC );

return hRC;
}

void DrawOpenGLScene()
{

glEnable( GL_DEPTH_TEST );

//
// Define the modelview transformation.
//
int i;
glMatrixMode( GL_PROJECTION );
glLoadIdentity();

// move the viewpoint out to where we can see everything
glTranslatef( 10.0f, 10.0f, 0.0f );

glBegin(GL_LINES);
glColor3d(1,0,0);
for(i=0;i < count ;i++)
{
glVertex2d(xold,yold);
glVertex2d(arry[i][0],arry[i][1]);
xold=arry[i][0];
yold=arry[i][1];
}

glEnd();

glFlush();
}