forked from bartvdbraak/blender
551 lines
15 KiB
C
551 lines
15 KiB
C
/**
|
|
* ***** BEGIN GPL LICENSE BLOCK *****
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*
|
|
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
|
* All rights reserved.
|
|
*
|
|
* The Original Code is: all of this file.
|
|
*
|
|
* Contributor(s): none yet.
|
|
*
|
|
* ***** END GPL LICENSE BLOCK *****
|
|
*/
|
|
|
|
/**
|
|
* Copyright (C) 2001 NaN Technologies B.V.
|
|
*
|
|
* Simple test file for the GHOST library.
|
|
* The OpenGL gear code is taken from the Qt sample code which,
|
|
* in turn, is probably taken from somewhere as well.
|
|
* \author Maarten Gribnau
|
|
* \date May 31, 2001
|
|
*/
|
|
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <math.h>
|
|
|
|
#define FALSE 0
|
|
|
|
#include "GHOST_C-api.h"
|
|
|
|
#if defined(WIN32) || defined(__APPLE__)
|
|
# ifdef WIN32
|
|
# include <windows.h>
|
|
# include <GL/gl.h>
|
|
# else /* WIN32 */
|
|
/* __APPLE__ is defined */
|
|
# include <AGL/gl.h>
|
|
# endif /* WIN32 */
|
|
#else /* defined(WIN32) || defined(__APPLE__) */
|
|
# include <GL/gl.h>
|
|
#endif /* defined(WIN32) || defined(__APPLE__) */
|
|
|
|
|
|
static void gearsTimerProc(GHOST_TimerTaskHandle task, GHOST_TUns64 time);
|
|
int processEvent(GHOST_EventHandle hEvent, GHOST_TUserDataPtr userData);
|
|
|
|
static GLfloat view_rotx = 20.0, view_roty = 30.0, view_rotz = 0.0;
|
|
static GLfloat fAngle = 0.0;
|
|
static int sExitRequested = 0;
|
|
static GHOST_SystemHandle shSystem = NULL;
|
|
static GHOST_WindowHandle sMainWindow = NULL;
|
|
static GHOST_WindowHandle sSecondaryWindow = NULL;
|
|
static GHOST_TStandardCursor sCursor = GHOST_kStandardCursorFirstCursor;
|
|
static GHOST_WindowHandle sFullScreenWindow = NULL;
|
|
static GHOST_TimerTaskHandle sTestTimer;
|
|
static GHOST_TimerTaskHandle sGearsTimer;
|
|
|
|
static void testTimerProc(GHOST_TimerTaskHandle task, GHOST_TUns64 time)
|
|
{
|
|
printf("timer1, time=%d\n", (int)time);
|
|
}
|
|
|
|
|
|
static void gearGL(GLfloat inner_radius, GLfloat outer_radius, GLfloat width, GLint teeth, GLfloat tooth_depth)
|
|
{
|
|
GLint i;
|
|
GLfloat r0, r1, r2;
|
|
GLfloat angle, da;
|
|
GLfloat u, v, len;
|
|
const double pi = 3.14159264;
|
|
|
|
r0 = inner_radius;
|
|
r1 = (float)(outer_radius - tooth_depth / 2.0);
|
|
r2 = (float)(outer_radius + tooth_depth / 2.0);
|
|
|
|
da = (float)(2.0 * pi / teeth / 4.0);
|
|
|
|
glShadeModel(GL_FLAT);
|
|
glNormal3f(0.0, 0.0, 1.0);
|
|
|
|
/* draw front face */
|
|
glBegin(GL_QUAD_STRIP);
|
|
for (i = 0; i <= teeth; i++) {
|
|
angle = (float)(i * 2.0 * pi / teeth);
|
|
glVertex3f((float)(r0 * cos(angle)), (float)(r0 * sin(angle)), (float)(width * 0.5));
|
|
glVertex3f((float)(r1 * cos(angle)), (float)(r1 * sin(angle)), (float)(width * 0.5));
|
|
glVertex3f((float)(r0 * cos(angle)), (float)(r0 * sin(angle)), (float)(width * 0.5));
|
|
glVertex3f((float)(r1 * cos(angle + 3 * da)), (float)(r1 * sin(angle + 3 * da)), (float)(width * 0.5));
|
|
}
|
|
glEnd();
|
|
|
|
/* draw front sides of teeth */
|
|
glBegin(GL_QUADS);
|
|
da = (float)(2.0 * pi / teeth / 4.0);
|
|
for (i = 0; i < teeth; i++) {
|
|
angle = (float)(i * 2.0 * pi / teeth);
|
|
glVertex3f((float)(r1 * cos(angle)), (float)(r1 * sin(angle)), (float)(width * 0.5));
|
|
glVertex3f((float)(r2 * cos(angle + da)), (float)(r2 * sin(angle + da)), (float)(width * 0.5));
|
|
glVertex3f((float)(r2 * cos(angle + 2 * da)), (float)(r2 * sin(angle + 2 * da)), (float)(width * 0.5));
|
|
glVertex3f((float)(r1 * cos(angle + 3 * da)), (float)(r1 * sin(angle + 3 * da)), (float)(width * 0.5));
|
|
}
|
|
glEnd();
|
|
|
|
glNormal3f(0.0, 0.0, -1.0);
|
|
|
|
/* draw back face */
|
|
glBegin(GL_QUAD_STRIP);
|
|
for (i = 0; i <= teeth; i++) {
|
|
angle = (float)(i * 2.0 * pi / teeth);
|
|
glVertex3f((float)(r1 * cos(angle)), (float)(r1 * sin(angle)), (float)(-width * 0.5));
|
|
glVertex3f((float)(r0 * cos(angle)), (float)(r0 * sin(angle)), (float)(-width * 0.5));
|
|
glVertex3f((float)(r1 * cos(angle + 3 * da)), (float)(r1 * sin(angle + 3 * da)), (float)(-width * 0.5));
|
|
glVertex3f((float)(r0 * cos(angle)), (float)(r0 * sin(angle)), (float)(-width * 0.5));
|
|
}
|
|
glEnd();
|
|
|
|
/* draw back sides of teeth */
|
|
glBegin(GL_QUADS);
|
|
da = (float)(2.0 * pi / teeth / 4.0);
|
|
for (i = 0; i < teeth; i++) {
|
|
angle = (float)(i * 2.0 * pi / teeth);
|
|
glVertex3f((float)(r1 * cos(angle + 3 * da)), (float)(r1 * sin(angle + 3 * da)), (float)(-width * 0.5));
|
|
glVertex3f((float)(r2 * cos(angle + 2 * da)), (float)(r2 * sin(angle + 2 * da)), (float)(-width * 0.5));
|
|
glVertex3f((float)(r2 * cos(angle + da)), (float)(r2 * sin(angle + da)), (float)(-width * 0.5));
|
|
glVertex3f((float)(r1 * cos(angle)), (float)(r1 * sin(angle)), (float)(-width * 0.5));
|
|
}
|
|
glEnd();
|
|
|
|
/* draw outward faces of teeth */
|
|
glBegin(GL_QUAD_STRIP);
|
|
for (i = 0; i < teeth; i++) {
|
|
angle = (float)(i * 2.0 * pi / teeth);
|
|
glVertex3f((float)(r1 * cos(angle)), (float)(r1 * sin(angle)), (float)(width * 0.5));
|
|
glVertex3f((float)(r1 * cos(angle)), (float)(r1 * sin(angle)), (float)(-width * 0.5));
|
|
u = (float)(r2 * cos(angle + da) - r1 * cos(angle));
|
|
v = (float)(r2 * sin(angle + da) - r1 * sin(angle));
|
|
len = (float)(sqrt(u * u + v * v));
|
|
u /= len;
|
|
v /= len;
|
|
glNormal3f(v, -u, 0.0);
|
|
glVertex3f((float)(r2 * cos(angle + da)), (float)(r2 * sin(angle + da)), (float)(width * 0.5));
|
|
glVertex3f((float)(r2 * cos(angle + da)), (float)(r2 * sin(angle + da)), (float)(-width * 0.5));
|
|
glNormal3f((float)(cos(angle)), (float)(sin(angle)), 0.0);
|
|
glVertex3f((float)(r2 * cos(angle + 2 * da)), (float)(r2 * sin(angle + 2 * da)), (float)(width * 0.5));
|
|
glVertex3f((float)(r2 * cos(angle + 2 * da)), (float)(r2 * sin(angle + 2 * da)), (float)(-width * 0.5));
|
|
u = (float)(r1 * cos(angle + 3 * da) - r2 * cos(angle + 2 * da));
|
|
v = (float)(r1 * sin(angle + 3 * da) - r2 * sin(angle + 2 * da));
|
|
glNormal3f(v, -u, 0.0);
|
|
glVertex3f((float)(r1 * cos(angle + 3 * da)), (float)(r1 * sin(angle + 3 * da)), (float)(width * 0.5));
|
|
glVertex3f((float)(r1 * cos(angle + 3 * da)), (float)(r1 * sin(angle + 3 * da)), (float)(-width * 0.5));
|
|
glNormal3f((float)(cos(angle)), (float)(sin(angle)), 0.0);
|
|
}
|
|
glVertex3f((float)(r1 * cos(0.0)), (float)(r1 * sin(0.0)), (float)(width * 0.5));
|
|
glVertex3f((float)(r1 * cos(0.0)), (float)(r1 * sin(0.0)), (float)(-width * 0.5));
|
|
glEnd();
|
|
|
|
glShadeModel(GL_SMOOTH);
|
|
|
|
/* draw inside radius cylinder */
|
|
glBegin(GL_QUAD_STRIP);
|
|
for (i = 0; i <= teeth; i++) {
|
|
angle = (float)(i * 2.0 * pi / teeth);
|
|
glNormal3f((float)(-cos(angle)), (float)(-sin(angle)), 0.0);
|
|
glVertex3f((float)(r0 * cos(angle)), (float)(r0 * sin(angle)), (float)(-width * 0.5));
|
|
glVertex3f((float)(r0 * cos(angle)), (float)(r0 * sin(angle)), (float)(width * 0.5));
|
|
}
|
|
glEnd();
|
|
}
|
|
|
|
|
|
|
|
static void drawGearGL(int id)
|
|
{
|
|
static GLfloat pos[4] = { 5.0f, 5.0f, 10.0f, 1.0f };
|
|
static GLfloat ared[4] = { 0.8f, 0.1f, 0.0f, 1.0f };
|
|
static GLfloat agreen[4] = { 0.0f, 0.8f, 0.2f, 1.0f };
|
|
static GLfloat ablue[4] = { 0.2f, 0.2f, 1.0f, 1.0f };
|
|
|
|
glLightfv(GL_LIGHT0, GL_POSITION, pos);
|
|
glEnable(GL_CULL_FACE);
|
|
glEnable(GL_LIGHTING);
|
|
glEnable(GL_LIGHT0);
|
|
glEnable(GL_DEPTH_TEST);
|
|
|
|
switch (id)
|
|
{
|
|
case 1:
|
|
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, ared);
|
|
gearGL(1.0f, 4.0f, 1.0f, 20, 0.7f);
|
|
break;
|
|
case 2:
|
|
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, agreen);
|
|
gearGL(0.5f, 2.0f, 2.0f, 10, 0.7f);
|
|
break;
|
|
case 3:
|
|
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, ablue);
|
|
gearGL(1.3f, 2.0f, 0.5f, 10, 0.7f);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
glEnable(GL_NORMALIZE);
|
|
}
|
|
|
|
|
|
static void drawGL(void)
|
|
{
|
|
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
|
|
glPushMatrix();
|
|
|
|
glRotatef(view_rotx, 1.0, 0.0, 0.0);
|
|
glRotatef(view_roty, 0.0, 1.0, 0.0);
|
|
glRotatef(view_rotz, 0.0, 0.0, 1.0);
|
|
|
|
glPushMatrix();
|
|
glTranslatef(-3.0, -2.0, 0.0);
|
|
glRotatef(fAngle, 0.0, 0.0, 1.0);
|
|
drawGearGL(1);
|
|
glPopMatrix();
|
|
|
|
glPushMatrix();
|
|
glTranslatef(3.1f, -2.0f, 0.0f);
|
|
glRotatef((float)(-2.0 * fAngle - 9.0), 0.0, 0.0, 1.0);
|
|
drawGearGL(2);
|
|
glPopMatrix();
|
|
|
|
glPushMatrix();
|
|
glTranslatef(-3.1f, 2.2f, -1.8f);
|
|
glRotatef(90.0f, 1.0f, 0.0f, 0.0f);
|
|
glRotatef((float)(2.0 * fAngle - 2.0), 0.0, 0.0, 1.0);
|
|
drawGearGL(3);
|
|
glPopMatrix();
|
|
|
|
glPopMatrix();
|
|
}
|
|
|
|
|
|
static void setViewPortGL(GHOST_WindowHandle hWindow)
|
|
{
|
|
GHOST_RectangleHandle hRect = NULL;
|
|
GLfloat w, h;
|
|
|
|
GHOST_ActivateWindowDrawingContext(hWindow);
|
|
hRect = GHOST_GetClientBounds(hWindow);
|
|
|
|
w = (float)GHOST_GetWidthRectangle(hRect) / (float)GHOST_GetHeightRectangle(hRect);
|
|
h = 1.0;
|
|
|
|
glViewport(0, 0, GHOST_GetWidthRectangle(hRect), GHOST_GetHeightRectangle(hRect));
|
|
|
|
glMatrixMode(GL_PROJECTION);
|
|
glLoadIdentity();
|
|
glFrustum(-w, w, -h, h, 5.0, 60.0);
|
|
/* glOrtho(0, bnds.getWidth(), 0, bnds.getHeight(), -10, 10); */
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glLoadIdentity();
|
|
glTranslatef(0.0, 0.0, -40.0);
|
|
|
|
glClearColor(.2f, 0.0f, 0.0f, 0.0f);
|
|
glClear(GL_COLOR_BUFFER_BIT);
|
|
|
|
GHOST_DisposeRectangle(hRect);
|
|
}
|
|
|
|
|
|
|
|
int processEvent(GHOST_EventHandle hEvent, GHOST_TUserDataPtr userData)
|
|
{
|
|
int handled = 1;
|
|
int cursor;
|
|
int visibility;
|
|
GHOST_TEventKeyData *keyData = NULL;
|
|
GHOST_TEventWheelData *wheelData = NULL;
|
|
GHOST_DisplaySetting setting;
|
|
GHOST_WindowHandle window = GHOST_GetEventWindow(hEvent);
|
|
|
|
switch (GHOST_GetEventType(hEvent))
|
|
{
|
|
#if 0
|
|
case GHOST_kEventUnknown:
|
|
break;
|
|
case GHOST_kEventCursorButton:
|
|
break;
|
|
case GHOST_kEventCursorMove:
|
|
break;
|
|
#endif
|
|
case GHOST_kEventWheel:
|
|
{
|
|
wheelData = (GHOST_TEventWheelData *)GHOST_GetEventData(hEvent);
|
|
if (wheelData->z > 0)
|
|
{
|
|
view_rotz += 5.f;
|
|
}
|
|
else {
|
|
view_rotz -= 5.f;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case GHOST_kEventKeyUp:
|
|
break;
|
|
|
|
case GHOST_kEventKeyDown:
|
|
{
|
|
keyData = (GHOST_TEventKeyData *)GHOST_GetEventData(hEvent);
|
|
switch (keyData->key)
|
|
{
|
|
case GHOST_kKeyC:
|
|
{
|
|
cursor = sCursor;
|
|
cursor++;
|
|
if (cursor >= GHOST_kStandardCursorNumCursors)
|
|
{
|
|
cursor = GHOST_kStandardCursorFirstCursor;
|
|
}
|
|
sCursor = (GHOST_TStandardCursor)cursor;
|
|
GHOST_SetCursorShape(window, sCursor);
|
|
}
|
|
break;
|
|
case GHOST_kKeyF:
|
|
if (!GHOST_GetFullScreen(shSystem))
|
|
{
|
|
/* Begin fullscreen mode */
|
|
setting.bpp = 24;
|
|
setting.frequency = 85;
|
|
setting.xPixels = 640;
|
|
setting.yPixels = 480;
|
|
|
|
/*
|
|
* setting.bpp = 16;
|
|
* setting.frequency = 75;
|
|
* setting.xPixels = 640;
|
|
* setting.yPixels = 480;
|
|
*/
|
|
|
|
sFullScreenWindow = GHOST_BeginFullScreen(shSystem, &setting,
|
|
|
|
FALSE /* stereo flag */);
|
|
}
|
|
else {
|
|
GHOST_EndFullScreen(shSystem);
|
|
sFullScreenWindow = 0;
|
|
}
|
|
break;
|
|
case GHOST_kKeyH:
|
|
{
|
|
visibility = GHOST_GetCursorVisibility(window);
|
|
GHOST_SetCursorVisibility(window, !visibility);
|
|
}
|
|
break;
|
|
case GHOST_kKeyQ:
|
|
if (GHOST_GetFullScreen(shSystem))
|
|
{
|
|
GHOST_EndFullScreen(shSystem);
|
|
sFullScreenWindow = 0;
|
|
}
|
|
sExitRequested = 1;
|
|
case GHOST_kKeyT:
|
|
if (!sTestTimer)
|
|
{
|
|
sTestTimer = GHOST_InstallTimer(shSystem, 0, 1000, testTimerProc, NULL);
|
|
}
|
|
else {
|
|
GHOST_RemoveTimer(shSystem, sTestTimer);
|
|
sTestTimer = 0;
|
|
}
|
|
break;
|
|
case GHOST_kKeyW:
|
|
{
|
|
if (sMainWindow)
|
|
{
|
|
char *title = GHOST_GetTitle(sMainWindow);
|
|
char *ntitle = malloc(strlen(title) + 2);
|
|
|
|
sprintf(ntitle, "%s-", title);
|
|
GHOST_SetTitle(sMainWindow, ntitle);
|
|
|
|
free(ntitle);
|
|
free(title);
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case GHOST_kEventWindowClose:
|
|
{
|
|
GHOST_WindowHandle window2 = GHOST_GetEventWindow(hEvent);
|
|
if (window2 == sMainWindow)
|
|
{
|
|
sExitRequested = 1;
|
|
}
|
|
else {
|
|
if (sGearsTimer)
|
|
{
|
|
GHOST_RemoveTimer(shSystem, sGearsTimer);
|
|
sGearsTimer = 0;
|
|
}
|
|
GHOST_DisposeWindow(shSystem, window2);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case GHOST_kEventWindowActivate:
|
|
handled = 0;
|
|
break;
|
|
case GHOST_kEventWindowDeactivate:
|
|
handled = 0;
|
|
break;
|
|
case GHOST_kEventWindowUpdate:
|
|
{
|
|
GHOST_WindowHandle window2 = GHOST_GetEventWindow(hEvent);
|
|
if (!GHOST_ValidWindow(shSystem, window2))
|
|
break;
|
|
setViewPortGL(window2);
|
|
drawGL();
|
|
GHOST_SwapWindowBuffers(window2);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
handled = 0;
|
|
break;
|
|
}
|
|
return handled;
|
|
}
|
|
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
char *title1 = "gears - main window";
|
|
char *title2 = "gears - secondary window";
|
|
GHOST_EventConsumerHandle consumer = GHOST_CreateEventConsumer(processEvent, NULL);
|
|
|
|
/* Create the system */
|
|
shSystem = GHOST_CreateSystem();
|
|
GHOST_AddEventConsumer(shSystem, consumer);
|
|
|
|
if (shSystem)
|
|
{
|
|
/* Create the main window */
|
|
sMainWindow = GHOST_CreateWindow(shSystem,
|
|
title1,
|
|
10,
|
|
64,
|
|
320,
|
|
200,
|
|
GHOST_kWindowStateNormal,
|
|
GHOST_kDrawingContextTypeOpenGL,
|
|
FALSE,
|
|
FALSE);
|
|
if (!sMainWindow)
|
|
{
|
|
printf("could not create main window\n");
|
|
exit(-1);
|
|
}
|
|
|
|
/* Create a secondary window */
|
|
sSecondaryWindow = GHOST_CreateWindow(shSystem,
|
|
title2,
|
|
340,
|
|
64,
|
|
320,
|
|
200,
|
|
GHOST_kWindowStateNormal,
|
|
GHOST_kDrawingContextTypeOpenGL,
|
|
FALSE,
|
|
FALSE);
|
|
if (!sSecondaryWindow)
|
|
{
|
|
printf("could not create secondary window\n");
|
|
exit(-1);
|
|
}
|
|
|
|
/* Install a timer to have the gears running */
|
|
sGearsTimer = GHOST_InstallTimer(shSystem,
|
|
0,
|
|
10,
|
|
gearsTimerProc,
|
|
sMainWindow);
|
|
|
|
/* Enter main loop */
|
|
while (!sExitRequested)
|
|
{
|
|
if (!GHOST_ProcessEvents(shSystem, 0))
|
|
{
|
|
#ifdef WIN32
|
|
/* If there were no events, be nice to other applications */
|
|
Sleep(10);
|
|
#endif
|
|
}
|
|
GHOST_DispatchEvents(shSystem);
|
|
}
|
|
}
|
|
|
|
/* Dispose windows */
|
|
if (GHOST_ValidWindow(shSystem, sMainWindow))
|
|
{
|
|
GHOST_DisposeWindow(shSystem, sMainWindow);
|
|
}
|
|
if (GHOST_ValidWindow(shSystem, sSecondaryWindow))
|
|
{
|
|
GHOST_DisposeWindow(shSystem, sSecondaryWindow);
|
|
}
|
|
|
|
/* Dispose the system */
|
|
GHOST_DisposeSystem(shSystem);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static void gearsTimerProc(GHOST_TimerTaskHandle hTask, GHOST_TUns64 time)
|
|
{
|
|
GHOST_WindowHandle hWindow = NULL;
|
|
fAngle += 2.0;
|
|
view_roty += 1.0;
|
|
hWindow = (GHOST_WindowHandle)GHOST_GetTimerTaskUserData(hTask);
|
|
if (GHOST_GetFullScreen(shSystem))
|
|
{
|
|
/* Running full screen */
|
|
GHOST_InvalidateWindow(sFullScreenWindow);
|
|
}
|
|
else {
|
|
if (GHOST_ValidWindow(shSystem, hWindow))
|
|
{
|
|
GHOST_InvalidateWindow(hWindow);
|
|
}
|
|
}
|
|
}
|