Anmelden

Archiv verlassen und diese Seite im Standarddesign anzeigen : C++/OpenGL -> 3D-Objekt-Müll



Kernle 32DLL
27.05.2005, 11:33
Hi !

Ich weis,der Threadname sagt nicht viel aus,aber mir fällt im moment nix
besseres ein.Also,ich habe folgendes Problem:

Seit kurzen,bastle ich jetzt mit C++ und OpenGL rum.Ja,und nebenbei
gucke ich mir den Sourcecode des Spiels Warzone 2100 (http://www.warzone2100.de/pafiledb/pafiledb.php?action=file&id=165) an.

Darin sind die 3D-Modelle,also Gebäude,Rümpfe,Antriebe,ect. drin.
Leider sind diese im .pie format abgespeichert und lassen sich nur
mit einem speziellen Tool (http://www.warzone2100.de/pafiledb/pafiledb.php?action=file&id=33) öffnen.Tja,und wenn man dann ein Modell
öffnet sieht das so aus:

http://kernel32dll.ke.funpic.de/Other%20things/Pic1.png
http://kernel32dll.ke.funpic.de/Other%20things/Pic2.png

Wie man sieht: Alles in Ordnung.Außerdem kann man noch in einem
Fenster an der Seite (nicht im Bild) die einzelnen Punkte "markieren".
Das sind genau 125 Punkte.Soooo,und was hat das mit meinem problem
zu tuhen ??? Tja, wenn man in C++/OpenGL ein 3D-Modell "zeichnet"
gibt man ja auch die einzelnen Punkte an.Also dachte ich mir,dann
sagt ich C++/OpenGL einfach,das er halt an diesen Punkten zeichnen soll.
Also einfach die gleichen Cordinaten des 3D-Modells zu benutzen.

Gesagt,getahn (anmerkung: öffnet man den .pie File mit einem texteditor,
kann man mit Copy&Paste die Cordinaten direkt aus der Datei in C++/OpenGL
einfügen).So,Code kompliert,und was kam raus ? "3D-Objekt-Müll".

http://kernel32dll.ke.funpic.de/Other%20things/Pic3.png

Weiß einer wodran das liegen könnte ?
Hab was davon gehört das man im "Uhrzeigersinn" zeichnen muss.
Naja,der Code: (Mods,nicht böse sein falls das irgentwie zu lang ist oder
so. Bei bedarf löche ich es auch sofort wieder)



//-------------------------------------------------------------------------------------------------
//Include important things
//-------------------------------------------------------------------------------------------------

#include <windows.h> // Header File For Windows
#include <stdio.h> // Header File For ???
#include <stdarg.h> // Header File For ???
#include <stdlib.h> // Header File For ???
#include <gl\gl.h> // Header File For The OpenGL32 Library
#include <gl\glu.h> // Header File For The GLu32 Library
#include <gl\glaux.h> // Header File For The Glaux Library

//-------------------------------------------------------------------------------------------------
//Variable Defintion & More
//-------------------------------------------------------------------------------------------------

HDC hDC=NULL; // Private GDI Device Context
HGLRC hRC=NULL; // Permanent Rendering Context
HWND hWnd=NULL; // Holds Our Window Handle
HINSTANCE hInstance; // Holds The Instance Of The Application

bool keys[256]; // Array Used For The Keyboard Routine
bool active=TRUE; // Window Active Flag Set To TRUE By Default
bool fullscreen=TRUE; // Fullscreen Flag Set To Fullscreen Mode By Default

GLfloat rpoly; // Angle For The Polygon
int Cubeturn; // Variable Definition For Cube Rotation

//-------------------------------------------------------------------------------------------------
//Main setup
//-------------------------------------------------------------------------------------------------

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM); // Declaration For WndProc

GLvoid ReSizeGLScene(GLsizei width, GLsizei height) // Resize And Initialize The GL Window
{
if (height==0) // Prevent A Divide By Zero By
{
height=1; // Making Height Equal One
}

glViewport(0,0,width,height); // Reset The Current Viewport

//-------------------------------------------------------------------------------------------------

glMatrixMode(GL_PROJECTION); // Select The Projection Matrix
glLoadIdentity(); // Reset The Projection Matrix

// 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(); // Reset The Modelview Matrix
}

//-------------------------------------------------------------------------------------------------

int InitGL(GLvoid) // All Setup For OpenGL Goes Here
{
glShadeModel(GL_SMOOTH); // Enable Smooth Shading
glClearColor(0.0f, 0.0f, 0.0f, 0.5f); // Black Background
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
return TRUE; // Initialization Went OK
}

//-------------------------------------------------------------------------------------------------
//OpenGL drawing and more
//-------------------------------------------------------------------------------------------------

int DrawGLScene(GLvoid) // Here's Where We Do All The Drawing
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear Screen And Depth Buffer
glLoadIdentity(); // Reset The Current Modelview Matrix

//---------------------
glTranslatef(0.0f,0.0f,-20.0f);
//-------
glRotatef(rpoly,1.0f,1.0f,0.0f);

glColor3f(0.5f,0.5f,0.9f);

glBegin(GL_POLYGON);
//------
glVertex3f( -1.0f, -1.0f, 1.0f);
glVertex3f( -6.5f, -0.0f, -2.7f );
glVertex3f( -2.7f, -0.0f, -6.5f );
glVertex3f( -2.7f, -6.5f, -6.5f );
glVertex3f( -6.5f, -6.5f, -2.7f );
glVertex3f( 2.7f, -0.0f, -6.5f );
glVertex3f( 2.7f, -6.5f, -6.5f );
glVertex3f( 6.5f, -0.0f, -2.7f );
glVertex3f( 6.5f, -6.5f, -2.7f );
glVertex3f( 6.5f, -0.0f, 2.7f );
glVertex3f( 6.5f, -6.5f, 2.7f );
glVertex3f( 2.7f, -0.0f, 6.5f );
glVertex3f( 2.7f, -6.5f, 6.5f );
glVertex3f( -2.7f, -0.0f, 6.5f );
glVertex3f( -2.7f, -6.5f, 6.5f );
glVertex3f( -6.5f, -0.0f, 2.7f );
glVertex3f( -6.5f, -6.5f, 2.7f );
glVertex3f( -0.0f, -6.5f, -0.0f );
glVertex3f( 1.3f, -6.5f, -1.2f );
glVertex3f( 1.3f, -6.5f, 1.3f );
glVertex3f( -0.0f, -17.4f, -0.0f );
glVertex3f( 4.0f, -3.9f, -5.1f );
glVertex3f( 7.3f, -0.0f, -8.2f );
glVertex3f( 8.3f, -0.0f, -7.3f );
glVertex3f( 5.1f, -3.9f, -4.0f );
glVertex3f( 4.0f, -0.0f, -5.1f );
glVertex3f( 5.1f, -0.0f, -4.0f );
glVertex3f( 6.9f, -0.0f, -9.0f );
glVertex3f( 9.2f, -0.0f, -11.3f );
glVertex3f( 9.1f, -14.4f, -9.9f );
glVertex3f( 8.3f, -14.4f, -9.0f );
glVertex3f( 11.4f, -0.0f, -9.1f );
glVertex3f( 9.1f, -0.0f, -6.8f );
glVertex3f( 9.1f, -14.4f, -8.2f );
glVertex3f( 10.0f, -14.4f, -9.0f );
glVertex3f( -1.2f, -6.5f, -1.2f );
glVertex3f( -1.2f, -6.5f, 1.3f );
glVertex3f( -8.1f, -14.4f, -9.1f );
glVertex3f( -8.9f, -14.4f, -8.3f );
glVertex3f( -9.8f, -14.4f, -9.1f );
glVertex3f( -9.0f, -14.4f, -10.0f );
glVertex3f( -5.1f, -3.9f, -4.0f );
glVertex3f( -8.2f, -0.0f, -7.3f );
glVertex3f( -7.3f, -0.0f, -8.2f );
glVertex3f( -4.0f, -3.9f, -5.1f );
glVertex3f( -5.1f, -0.0f, -4.0f );
glVertex3f( -4.0f, -0.0f, -5.1f );
glVertex3f( -6.7f, -0.0f, -9.1f );
glVertex3f( -8.9f, -0.0f, -6.9f );
glVertex3f( -11.2f, -0.0f, -9.2f );
glVertex3f( -9.0f, -0.0f, -11.4f );
glVertex3f( -9.0f, -14.4f, 8.1f );
glVertex3f( -8.2f, -14.4f, 8.9f );
glVertex3f( -9.1f, -14.4f, 9.8f );
glVertex3f( -9.9f, -14.4f, 9.0f );
glVertex3f( -4.0f, -3.9f, 5.1f );
glVertex3f( -7.3f, -0.0f, 8.3f );
glVertex3f( -8.2f, -0.0f, 7.3f );
glVertex3f( -5.1f, -3.9f, 4.0f );
glVertex3f( -4.0f, -0.0f, 5.1f );
glVertex3f( -5.1f, -0.0f, 4.0f );
glVertex3f( -9.0f, -0.0f, 6.7f );
glVertex3f( -6.8f, -0.0f, 8.9f );
glVertex3f( -9.1f, -0.0f, 11.2f );
glVertex3f( -11.3f, -0.0f, 9.0f );
glVertex3f( 8.2f, -14.4f, 9.0f );
glVertex3f( 9.0f, -14.4f, 8.2f );
glVertex3f( 9.9f, -14.4f, 9.1f );
glVertex3f( 9.0f, -14.4f, 9.9f );
glVertex3f( 5.1f, -3.9f, 4.0f );
glVertex3f( 8.3f, -0.0f, 7.3f );
glVertex3f( 7.3f, -0.0f, 8.3f );
glVertex3f( 4.0f, -3.9f, 5.1f );
glVertex3f( 5.1f, -0.0f, 4.0f );
glVertex3f( 4.0f, -0.0f, 5.1f );
glVertex3f( 6.8f, -0.0f, 9.0f );
glVertex3f( 9.0f, -0.0f, 6.8f );
glVertex3f( 11.3f, -0.0f, 9.1f );
glVertex3f( 9.0f, -0.0f, 11.3f );
glVertex3f( 4.0f, -6.6f, 5.6f );
glVertex3f( -3.0f, -6.6f, 5.6f );
glVertex3f( -3.0f, -6.6f, 4.8f );
glVertex3f( 4.0f, -6.6f, 4.8f );
glVertex3f( 4.0f, -6.6f, -4.7f );
glVertex3f( -3.0f, -6.6f, -4.7f );
glVertex3f( -3.0f, -6.6f, -5.5f );
glVertex3f( 4.0f, -6.6f, -5.5f );
glVertex3f( -4.7f, -3.6f, -5.0f );
glVertex3f( -4.9f, -3.6f, -4.7f );
glVertex3f( -6.7f, -1.5f, -6.4f );
glVertex3f( -6.4f, -1.5f, -6.7f );
glVertex3f( -5.1f, -3.6f, 4.9f );
glVertex3f( -4.8f, -3.6f, 5.1f );
glVertex3f( -6.5f, -1.5f, 6.9f );
glVertex3f( -6.8f, -1.5f, 6.6f );
glVertex3f( 4.8f, -3.6f, 5.1f );
glVertex3f( 5.1f, -3.6f, 4.8f );
glVertex3f( 6.8f, -1.5f, 6.5f );
glVertex3f( 6.5f, -1.5f, 6.8f );
glVertex3f( 5.1f, -3.6f, -4.9f );
glVertex3f( 4.8f, -3.6f, -5.2f );
glVertex3f( 6.6f, -1.5f, -6.9f );
glVertex3f( 6.8f, -1.5f, -6.6f );
glVertex3f( 4.0f, -6.5f, -5.1f );
glVertex3f( -5.4f, -6.5f, 3.7f );
glVertex3f( -5.4f, -0.0f, 3.7f );
glVertex3f( 4.0f, -6.5f, 5.1f );
glVertex3f( 5.1f, -6.5f, -4.0f );
glVertex3f( 4.0f, -4.1f, -5.1f );
glVertex3f( 5.1f, -3.8f, -4.0f );
glVertex3f( 4.0f, -3.8f, -5.1f );
glVertex3f( 5.1f, -6.5f, 4.0f );
glVertex3f( 4.0f, -4.0f, 5.1f );
glVertex3f( 5.1f, -4.0f, 4.0f );
glVertex3f( 4.0f, -3.8f, 5.1f );
glVertex3f( 5.1f, -3.8f, 4.0f );
glVertex3f( -5.1f, -6.5f, 4.0f );
glVertex3f( -4.0f, -6.5f, 5.1f );
glVertex3f( -5.1f, -4.0f, 4.0f );
glVertex3f( -4.0f, -4.0f, 5.1f );
glVertex3f( -5.1f, -3.8f, 4.0f );
glVertex3f( -4.0f, -3.8f, 5.1f );
glVertex3f( -4.0f, -6.5f, -5.1f );
glVertex3f( -5.1f, -6.5f, -4.0f );
glVertex3f( -4.0f, -3.8f, -5.1f );
glVertex3f( -5.1f, -3.8f, -4.0f );
//------
glEnd();
//-------

//---------------------

if (keys[VK_F2]) // Is F1 Being Pressed?
{
keys[VK_F2]=FALSE;
if (Cubeturn != 1)
{
Cubeturn = 1;
}
else
{
Cubeturn = 0;
}
}

if (Cubeturn == 1) // Is Qrotate = 1 ?
{
rpoly+=0.2f;
}


return TRUE; // Everything Went OK
}

//-------------------------------------------------------------------------------------------------
//Exiting
//-------------------------------------------------------------------------------------------------

GLvoid KillGLWindow(GLvoid) // Properly Kill The Window
{
if (fullscreen) // Are We In Fullscreen Mode?
{
ChangeDisplaySettings(NULL,0); // If So Switch Back To The Desktop
ShowCursor(TRUE); // Show Mouse Pointer
}
//------------
if (hRC) // Do We Have A Rendering Context?
{
if (!wglMakeCurrent(NULL,NULL)) // Are We Able To Release The DC And RC Contexts?
{
MessageBox(NULL,"Release Of DC And RC Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
}

if (!wglDeleteContext(hRC)) // Are We Able To Delete The RC?
{
MessageBox(NULL,"Release Rendering Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
}
hRC=NULL; // Set RC To NULL
}
//------------
if (hDC && !ReleaseDC(hWnd,hDC)) // Are We Able To Release The DC
{
MessageBox(NULL,"Release Device Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
hDC=NULL; // Set DC To NULL
}
//------------
if (hWnd && !DestroyWindow(hWnd)) // Are We Able To Destroy The Window?
{
MessageBox(NULL,"Could Not Release hWnd.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
hWnd=NULL; // Set hWnd To NULL
}
//------------
if (!UnregisterClass("OpenGL",hInstance)) // Are We Able To Unregister Class
{
MessageBox(NULL,"Could Not Unregister Class.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
hInstance=NULL; // Set hInstance To NULL
}
}

//------------

/* This Code Creates A OpenGL Window. Parameters Are: *
* title - Title To Appear At The Top Of The Window *
* width - Width Of The GL Window Or Fullscreen Mode *
* height - Height Of The GL Window Or Fullscreen Mode *
* bits - Number Of Bits To Use For Color (8/16/24/32) *
* fullscreenflag - Use Fullscreen Mode (TRUE) Or Windowed Mode (FALSE) */

//------------

//-------------------------------------------------------------------------------------------------
//All window actions
//-------------------------------------------------------------------------------------------------

BOOL CreateGLWindow(char* title, int width, int height, int bits, bool fullscreenflag)
{
GLuint PixelFormat; // Holds The Results After Searching For A Match
WNDCLASS wc; // Windows Class Structure
DWORD dwExStyle; // Window Extended Style
DWORD dwStyle; // Window Style
RECT WindowRect; // Grabs Rectangle Upper Left / Lower Right Values
WindowRect.left=(long)0; // Set Left Value To 0
WindowRect.right=(long)width; // Set Right Value To Requested Width
WindowRect.top=(long)0; // Set Top Value To 0
WindowRect.bottom=(long)height; // Set Bottom Value To Requested Height

fullscreen=fullscreenflag; // Set The Global Fullscreen Flag

hInstance = GetModuleHandle(NULL); // Grab An Instance For Our Window
wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC; // Redraw On Size, And Own DC For Window.
wc.lpfnWndProc = (WNDPROC) WndProc; // WndProc Handles Messages
wc.cbClsExtra = 0; // No Extra Window Data
wc.cbWndExtra = 0; // No Extra Window Data
wc.hInstance = hInstance; // Set The Instance
wc.hIcon = LoadIcon(NULL, IDI_WINLOGO); // Load The Default Icon
wc.hCursor = LoadCursor(NULL, IDC_ARROW); // Load The Arrow Pointer
wc.hbrBackground = NULL; // No Background Required For GL
wc.lpszMenuName = NULL; // We Don't Want A Menu
wc.lpszClassName = "OpenGL"; // Set The Class Name

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

if (fullscreen) // Attempt Fullscreen Mode?
{
DEVMODE dmScreenSettings; // Device Mode
memset(&dmScreenSettings,0,sizeof(dmScreenSettings)); // Makes Sure Memory's Cleared
dmScreenSettings.dmSize=sizeof(dmScreenSettings); // Size Of The Devmode Structure
dmScreenSettings.dmPelsWidth = width; // Selected Screen Width
dmScreenSettings.dmPelsHeight = height; // Selected Screen Height
dmScreenSettings.dmBitsPerPel = bits; // Selected Bits Per Pixel
dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;

// Try To Set Selected Mode And Get Results. NOTE: CDS_FULLSCREEN Gets Rid Of Start Bar.
if (ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL)
{
// If The Mode Fails, Offer Two Options. Quit Or Use Windowed Mode.
if (MessageBox(NULL,"The Requested Fullscreen Mode Is Not Supported By\nYour Video Card. Use Windowed Mode Instead?","NeHe GL",MB_YESNO|MB_ICONEXCLAMATION)==IDYES)
{
fullscreen=FALSE; // Windowed Mode Selected. Fullscreen = FALSE
}
else
{
// Pop Up A Message Box Letting User Know The Program Is Closing.
MessageBox(NULL,"Program Will Now Close.","ERROR",MB_OK|MB_ICONSTOP);
return FALSE; // Return FALSE
}
}
}

if (fullscreen) // Are We Still In Fullscreen Mode?
{
dwExStyle=WS_EX_APPWINDOW; // Window Extended Style
dwStyle=WS_POPUP; // Windows Style
ShowCursor(FALSE); // Hide Mouse Pointer
}
else
{
dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE; // Window Extended Style
dwStyle=WS_OVERLAPPEDWINDOW; // Windows Style
}

AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle); // Adjust Window To True Requested Size

// Create The Window
if (!(hWnd=CreateWindowEx( dwExStyle, // Extended Style For The Window
"OpenGL", // Class Name
title, // Window Title
dwStyle | // Defined Window Style
WS_CLIPSIBLINGS | // Required Window Style
WS_CLIPCHILDREN, // Required Window Style
0, 0, // Window Position
WindowRect.right-WindowRect.left, // Calculate Window Width
WindowRect.bottom-WindowRect.top, // Calculate Window Height
NULL, // No Parent Window
NULL, // No Menu
hInstance, // Instance
NULL))) // Dont Pass Anything To WM_CREATE
{
KillGLWindow(); // Reset The Display
MessageBox(NULL,"Window Creation Error.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}

static PIXELFORMATDESCRIPTOR pfd= // pfd Tells Windows How We Want Things To Be
{
sizeof(PIXELFORMATDESCRIPTOR), // Size Of This Pixel Format Descriptor
1, // Version Number
PFD_DRAW_TO_WINDOW | // Format Must Support Window
PFD_SUPPORT_OPENGL | // Format Must Support OpenGL
PFD_DOUBLEBUFFER, // Must Support Double Buffering
PFD_TYPE_RGBA, // Request An RGBA Format
bits, // Select Our Color Depth
0, 0, 0, 0, 0, 0, // Color Bits Ignored
0, // No Alpha Buffer
0, // Shift Bit Ignored
0, // No Accumulation Buffer
0, 0, 0, 0, // Accumulation Bits Ignored
16, // 16Bit Z-Buffer (Depth Buffer)
0, // No Stencil Buffer
0, // No Auxiliary Buffer
PFD_MAIN_PLANE, // Main Drawing Layer
0, // Reserved
0, 0, 0 // Layer Masks Ignored
};

if (!(hDC=GetDC(hWnd))) // Did We Get A Device Context?
{
KillGLWindow(); // Reset The Display
MessageBox(NULL,"Can't Create A GL Device Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}

if (!(PixelFormat=ChoosePixelFormat(hDC,&pfd))) // Did Windows Find A Matching Pixel Format?
{
KillGLWindow(); // Reset The Display
MessageBox(NULL,"Can't Find A Suitable PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}

if(!SetPixelFormat(hDC,PixelFormat,&pfd)) // Are We Able To Set The Pixel Format?
{
KillGLWindow(); // Reset The Display
MessageBox(NULL,"Can't Set The PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}

if (!(hRC=wglCreateContext(hDC))) // Are We Able To Get A Rendering Context?
{
KillGLWindow(); // Reset The Display
MessageBox(NULL,"Can't Create A GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}

if(!wglMakeCurrent(hDC,hRC)) // Try To Activate The Rendering Context
{
KillGLWindow(); // Reset The Display
MessageBox(NULL,"Can't Activate The GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}

ShowWindow(hWnd,SW_SHOW); // Show The Window
SetForegroundWindow(hWnd); // Slightly Higher Priority
SetFocus(hWnd); // Sets Keyboard Focus To The Window
ReSizeGLScene(width, height); // Set Up Our Perspective GL Screen

if (!InitGL()) // Initialize Our Newly Created GL Window
{
KillGLWindow(); // Reset The Display
MessageBox(NULL,"Initialization Failed.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}

return TRUE; // Success
}

LRESULT CALLBACK WndProc( HWND hWnd, // Handle For This Window
UINT uMsg, // Message For This Window
WPARAM wParam, // Additional Message Information
LPARAM lParam) // Additional Message Information
{
switch (uMsg) // Check For Windows Messages
{
case WM_ACTIVATE: // Watch For Window Activate Message
{
if (!HIWORD(wParam)) // Check Minimization State
{
active=TRUE; // Program Is Active
}
else
{
active=FALSE; // Program Is No Longer Active
}

return 0; // Return To The Message Loop
}

case WM_SYSCOMMAND: // Intercept System Commands
{
switch (wParam) // Check System Calls
{
case SC_SCREENSAVE: // Screensaver Trying To Start?
case SC_MONITORPOWER: // Monitor Trying To Enter Powersave?
return 0; // Prevent From Happening
}
break; // Exit
}

case WM_CLOSE: // Did We Receive A Close Message?
{
PostQuitMessage(0); // Send A Quit Message
return 0; // Jump Back
}

case WM_KEYDOWN: // Is A Key Being Held Down?
{
keys[wParam] = TRUE; // If So, Mark It As TRUE
return 0; // Jump Back
}

case WM_KEYUP: // Has A Key Been Released?
{
keys[wParam] = FALSE; // If So, Mark It As FALSE
return 0; // Jump Back
}

case WM_SIZE: // Resize The OpenGL Window
{
ReSizeGLScene(LOWORD(lParam),HIWORD(lParam)); // LoWord=Width, HiWord=Height
return 0; // Jump Back
}
}

// Pass All Unhandled Messages To DefWindowProc
return DefWindowProc(hWnd,uMsg,wParam,lParam);
}

int WINAPI WinMain( HINSTANCE hInstance, // Instance
HINSTANCE hPrevInstance, // Previous Instance
LPSTR lpCmdLine, // Command Line Parameters
int nCmdShow) // Window Show State
{
MSG msg; // Windows Message Structure
BOOL done=FALSE; // Bool Variable To Exit Loop

// Set Screen Mode
{
fullscreen=TRUE; // Windowed Mode
}

// Create Our OpenGL Window
if (!CreateGLWindow("Test",800,600,32,fullscreen))
{
return 0; // Quit If Window Was Not Created
}

while(!done) // Loop That Runs While done=FALSE
{
if (PeekMessage(&msg,NULL,0,0,PM_REMOVE)) // Is There A Message Waiting?
{
if (msg.message==WM_QUIT) // Have We Received A Quit Message?
{
done=TRUE; // If So done=TRUE
}
else // If Not, Deal With Window Messages
{
TranslateMessage(&msg); // Translate The Message
DispatchMessage(&msg); // Dispatch The Message
}
}
else // If There Are No Messages
{
// Draw The Scene. Watch For ESC Key And Quit Messages From DrawGLScene()
if (active) // Program Active?
{
if (keys[VK_ESCAPE]) // Was ESC Pressed?
{
done=TRUE; // ESC Signalled A Quit
}
else // Not Time To Quit, Update Screen
{
DrawGLScene(); // Draw The Scene
SwapBuffers(hDC); // Swap Buffers (Double Buffering)
}
}

if (keys[VK_F1]) // Is F1 Being Pressed?
{
keys[VK_F1]=FALSE; // If So Make Key FALSE
KillGLWindow(); // Kill Our Current Window
fullscreen=!fullscreen; // Toggle Fullscreen / Windowed Mode

// Recreate Our OpenGL Window
if (!CreateGLWindow("Test",800,600,32,fullscreen))
{
return 0; // Quit If Window Was Not Created
}

}
}
}

// Shutdown
KillGLWindow(); // Kill The Window
return (msg.wParam); // Exit The Program
}



Ich weis,der Code ist ein einziges Durcheinander,aber er funktioniert.
Hoffe mir kann jemand helfen.


Gruß:
Kernle

PS: Die Bilder loaden up...Dauert noch ein bissel...

EDIT:
Ach Shit.... Externen Linken geht nicht.Dann müst ihr wohl einfach unter
http://kernel32dll.ke.funpic.de/Other%20things/ gehen und dann Pics1.png,
Pic2.png und Pic3.png so anschauen.

EDIT2:
Hmmm,oder ihr benutzt: rechtsklick,speichern unter...

Ynnus
27.05.2005, 11:52
Ja, ich weiß woran das liegen kann.^^

Woher soll denn OpenGL wissen, wie es diese Vertexe verbinden soll? In der Welt der dritten Dimension geht es normalerweise nur um Dreiecke. Also setzt man drei Punkte, die dann zu Dreiecken verbunden werden. Vieeeele dieser Dreiecke zusammen und man kann damit Kugeln, Figuren, Menschen, ja alles mögliche basteln. Daher ist das eher ein Modellieren als ein Zeichnen. Was du jetzt gemacht hast, ist, alle möglichen Vertics zu setzen, ohne Rücksicht auf die Reihenfolge und die Dreiecke. Daher hat OpenGL die auch so verbunden, wie du sie gesetzt hast, in der Reihnfolg, immer zu Dreiecken. (Mit Speziellen Befehlen lassen sich mehrere Vertexe auch zu Vierecken oder anderen Formen bilden, im Grunde bestehen sie aber immer aus mehreren Dreiecken die diese Form bilden).
Was du also machen müsstest ist, die Dreiecke richtig setzen. Es bringt nichts, wenn alle Vertics bekannt sind, aber du die Reihnfolge nicht kennst. Vielleicht findet sich in diesem Format der Objekte ja eine gewisse Reihnfolge die du übersehen hast?

Btw. Der Download des Sourcecodes von Warzone 2100 ist offline, schickst du mir den bitte per mail an: EDIT: Ist ok, hab den Sourcecode woanders im Web gefunden. ;)
(Ich liebe dieses Spiel, habs früher bis zur Vergasung gespielt. :))

Kernle 32DLL
27.05.2005, 12:42
Hmm..ne,also ne Reihenfolge kann man daraus wohl eher nicht lesen:




PIE 2
TYPE 200
TEXTURE 0 page-11-player buildings.pcx 256 256
LEVELS 1
LEVEL 1
POINTS 125
65 0 27
27 0 65
27 65 65
65 65 27
-27 0 65
-27 65 65
-65 0 27
-65 65 27
-65 0 -27
-65 65 -27
-27 0 -65
-27 65 -65
27 0 -65
27 65 -65
65 0 -27
65 65 -27
0 65 0
-13 65 12
-13 65 -13
0 174 0
-40 39 51
-73 0 82
-83 0 73
-51 39 40
-40 0 51
-51 0 40
-69 0 90
-92 0 113
-91 144 99
-83 144 90
-114 0 91
-91 0 68
-91 144 82
-100 144 90
12 65 12
12 65 -13
81 144 91
89 144 83
98 144 91
90 144 100
51 39 40
82 0 73
73 0 82
40 39 51
51 0 40
40 0 51
67 0 91
89 0 69
112 0 92
90 0 114
90 144 -81
82 144 -89
91 144 -98
99 144 -90
40 39 -51
73 0 -83
82 0 -73
51 39 -40
40 0 -51
51 0 -40
90 0 -67
68 0 -89
91 0 -112
113 0 -90
-82 144 -90
-90 144 -82
-99 144 -91
-90 144 -99
-51 39 -40
-83 0 -73
-73 0 -83
-40 39 -51
-51 0 -40
-40 0 -51
-68 0 -90
-90 0 -68
-113 0 -91
-90 0 -113
-4 66 -56
3 66 -56
3 66 -48
-4 66 -48
-4 66 47
3 66 47
3 66 55
-4 66 55
47 36 50
49 36 47
67 15 64
64 15 67
51 36 -49
48 36 -51
65 15 -69
68 15 -66
-48 36 -51
-51 36 -48
-68 15 -65
-65 15 -68
-51 36 49
-48 36 52
-66 15 69
-68 15 66
-40 65 51
54 65 -37
54 0 -37
-40 65 -51
-51 65 40
-40 41 51
-51 38 40
-40 38 51
-51 65 -40
-40 40 -51
-51 40 -40
-40 38 -51
-51 38 -40
51 65 -40
40 65 -51
51 40 -40
40 40 -51
51 38 -40
40 38 -51
40 65 51
51 65 40
40 38 51
51 38 40
POLYGONS 71
200 4 33 32 31 30 213 33 214 41 151 48 151 27
200 4 33 28 29 32 26 193 41 193 41 208 26 208
200 4 29 28 27 26 151 42 151 34 213 27 213 48
200 4 28 33 30 27 213 42 214 34 151 27 151 48
200 4 32 29 26 31 213 33 214 41 151 48 151 27
200 4 65 66 76 75 151 42 151 34 213 27 213 48
200 4 67 64 74 77 213 33 214 41 151 48 151 27
200 4 67 66 65 64 26 193 41 193 41 208 26 208
200 4 64 65 75 74 213 33 214 41 151 48 151 27
200 4 38 39 49 48 213 42 214 34 151 27 151 48
200 4 37 38 48 47 151 42 151 34 213 27 213 48
200 4 39 38 37 36 26 193 41 193 41 208 26 208
200 4 39 36 46 49 213 33 214 41 151 48 151 27
200 4 36 37 47 46 213 33 214 41 151 48 151 27
200 4 51 52 62 61 151 42 151 34 213 27 213 48
200 4 53 52 51 50 26 193 41 193 41 208 26 208
200 4 53 50 60 63 213 33 214 41 151 48 151 27
200 4 50 51 61 60 213 33 214 41 151 48 151 27
200 4 20 23 108 109 0 109 0 81 0 81 0 109
200 4 25 24 107 108 125 34 120 34 120 12 125 13
200 4 22 21 109 108 40 81 40 109 0 109 0 81
200 4 101 100 99 98 63 47 67 47 67 51 63 51
200 4 102 106 108 107 120 0 125 0 125 13 120 12
200 3 25 22 23 42 168 0 169 42 136
200 4 68 71 113 114 0 109 0 81 0 81 0 109
200 4 73 72 112 111 125 34 120 34 120 12 125 12
200 4 70 69 114 113 40 81 40 109 0 109 0 81
200 4 97 96 95 94 63 47 67 47 67 51 63 51
200 4 110 105 111 112 120 0 125 0 125 12 120 12
200 3 69 72 68 42 168 0 169 0 136
200 4 7 9 8 6 87 0 113 0 113 34 87 34
200 4 8 9 110 72 114 34 114 0 120 0 120 34
200 4 7 6 25 106 132 0 132 34 125 34 125 0
200 3 73 70 71 42 168 0 169 42 136
200 4 54 57 119 120 0 109 0 81 0 81 0 109
200 4 59 58 118 117 124 34 119 34 119 12 124 12
200 4 56 55 120 119 40 81 40 109 0 109 0 81
200 4 93 92 91 90 63 47 67 47 67 51 63 51
200 4 116 115 117 118 119 0 124 0 124 12 119 12
200 3 55 58 54 42 168 0 169 0 136
200 4 11 13 12 10 87 0 113 0 113 34 87 34
200 4 12 13 116 58 114 34 114 0 119 0 119 34
200 3 59 56 57 42 168 0 169 42 136
200 4 103 104 59 115 126 0 126 34 124 34 124 0
200 4 11 10 73 105 132 0 132 34 125 34 125 0
200 3 21 24 20 42 168 0 169 0 136
200 4 40 43 123 124 0 109 0 81 0 81 0 109
200 4 45 44 124 123 125 34 120 34 120 13 125 13
200 4 42 41 124 123 40 81 40 109 0 109 0 81
200 4 89 88 87 86 63 47 67 47 67 51 63 51
200 4 122 121 123 124 120 0 125 0 125 13 120 13
200 3 41 44 40 42 168 0 169 0 136
200 4 0 3 122 44 114 34 114 0 120 0 120 34
200 4 15 3 0 14 87 0 113 0 113 34 87 34
200 3 45 42 43 42 168 0 169 42 136
200 4 2 5 4 1 87 0 113 0 113 34 87 34
200 4 2 1 45 121 132 0 132 34 125 34 125 0
200 4 4 5 102 24 114 34 114 0 120 0 120 34
200 4 15 14 104 103 132 0 132 34 126 34 126 0
200 4 2 3 15 16 42 2 59 18 59 41 31 31
200 4 7 5 2 16 2 19 18 2 42 2 31 30
200 4 11 9 7 16 19 58 2 42 2 19 30 30
200 4 15 13 11 16 59 41 43 58 19 58 30 31
200 3 19 35 18 200 12 141 21 141 4
200 4 81 80 79 78 63 47 67 47 67 51 63 51
200 3 19 17 34 200 13 141 4 141 21
200 4 85 84 83 82 63 47 67 47 67 51 63 51
200 3 19 34 35 200 13 141 4 141 21
200 3 19 18 17 200 12 141 21 141 4
200 4 52 53 63 62 213 42 214 34 151 27 151 48
200 4 66 67 77 76 213 42 214 34 151 27 151 48
CONNECTORS 1
90 -90 0



naja,was solls.Jedenfalls,danke für den Tipp,also das mit den 3´ecken.
eine frage aber noch: wenn ich 6 punkte habe,also z.B.
. . .
. . .

Wie müsste ich die verbinden ?
ich glaube so oder ? :

1 2 3
6 5 4


Naja,was solls....blöd,weil ich dann doch:

- überlegen,wo kommt der nächste Punkt hin
- im Programm Punkt suchen und anvisieren
- Daten ablesen (X.X,X.X,X.X) und in Programm eintippen
- von vorne beginnen

Und das dann 125 mal...
Oje,oje,oje...

:( :( :( :( :(

Gruß:
kernle

PS: Cool,ein gleich gesinnter ^^
Arbeite derzeit an eineem Warzone 2100
Projekt.Könntest mir evt. helfe :)
Ich schick dir mal ne PN.

Ynnus
27.05.2005, 12:50
Ich würde eher schauen, ob man dieses Format nicht in was allgemeineres exportieren kann, etwa in das .3ds Format, womit OpenGL dann unter Umständen auch was anfangen kann. ;)

MagicMagor
27.05.2005, 13:05
Wenn du Dreiecke, oder Vierecke oder sonstwas in OpenGL zeichnest und die einzelnen Punkte angibst, solltest du sie entgegen dem Uhrzeigersinn an OpenGL übergeben, dann sollten sie korrekt gezeichnet werden.

Wie Ynnus gesagt hat, bei komplexeren Modellen, die aus mehreren hunderten oder gar tausenden Polygonen bestehen macht man sich nicht die Mühe alle Dreiecke selbst zu zeichnen. Stattdessen benutzt man Loader für Modellformate, wie eben 3ds. Wie man diese geladenen Modelle dann aber zeichnet weiß ich ehrlich gesagt auch nicht. Hab längere Zeit nichts mehr mit OpenGL gemacht und 3D-Modelle laden sowieso nicht.

Ansonsten gilt auch bei OpenGL derselbe Rat wie bei Programmiersprachen, erstmal klein anfangen. nehe-Tuts durcharbeiten oder die auf www.delphigl.com (OpenGL programmiert sich unter jeder Sprache identisch).
Oder du greifst direkt zu einer schon bestehenden 3D-Engine..

Ynnus
27.05.2005, 17:05
Wenn du Dreiecke, oder Vierecke oder sonstwas in OpenGL zeichnest und die einzelnen Punkte angibst, solltest du sie entgegen dem Uhrzeigersinn an OpenGL übergeben, dann sollten sie korrekt gezeichnet werden.
Um noch hinzuzufügen -> Ein Polygon (also eines dieser besagten Dreiecke) hat immer zwei Seiten. Ist also ein einfaches 3D-Object, mit einer Vorderseite und einer Rückseite. Standardgemäß blendet man die Rückseite aus, da man diese sowieso nicht sieht. (Etwa bei 3D Figuren sieht man diese ja nur von Außen und nicht von Ihnen her. Ebenso sieht man eine Kiste nur von Außen und sitzt nicht drinne und sieht heraus).
Demnach blendet man diese Innenseiten aus, dies geht in OpenGL mittels der glEnable(GL_CULL_FACE) Funktion Funktion. Man kann aber auch die Vorderseite ausblenden, indem man diese mittels der Funktion glCullFace() wählt.
Wie auch immer, wenn du die Vertics gegen den Uhrzeigersinn verbindest, schaut dir die Vorderseite entgegen. Im Uhrzeigersinn schaut dir die Rückseite entgegen. (In anderen APIs ist es genau anders herum, ich kenne es aus dem 3D Gamestudio, wo man im Uhrzeigersinn verbindet für die Vorderseite. Und afaik ist es in DirectX auch anders herum, das ist aber mehr eine Hören-Sagen-Vermutung).

Feenstaub
31.05.2005, 11:57
Wie auch immer, wenn du die Vertics gegen den Uhrzeigersinn verbindest, schaut dir die Vorderseite entgegen. Im Uhrzeigersinn schaut dir die Rückseite entgegen. (In anderen APIs ist es genau anders herum, ich kenne es aus dem 3D Gamestudio, wo man im Uhrzeigersinn verbindet für die Vorderseite. Und afaik ist es in DirectX auch anders herum, das ist aber mehr eine Hören-Sagen-Vermutung).
Das ist so nicht ganz richtig. Du kannst in OpenGL (und ich vermute stark, auch in DX) festlegen, in welcher Weise die Vorderseite eines Polygons interpretiert wird. Die Funktion dazu heisst glFrontFace, sie übernimmt als einzigen Parameter einen Wert, der entweder GL_CCW (counter clockwise; entgegen dem Uhrzeigersinn; die default Einstellung) oder GL_CW (clockwise; im Uhrzeigersinn) annehmen kann. Er bestimmt, welche Vertex-Reihenfolge als Vorderseite dargestellt wird.

@kernle:
Es steht alles in dieser PIE-Datei. Sieh sie dir nur richtig an. Die Stelle "POINTS 125" verrät dir, dass anschliessend 125 Punkte in der Datei definiert werden. Die darauffolgende Zeile "POLYGONS 71" sagt dir, dass du genau 71 Polygone aus diesen Punkten bauen musst, deren Definition in den folgenden 71 Zeilen folgt. Nun müsstest du mal in die Doku von Warzone schauen, was eine einzelne Zeile für ein Polygon bedeutet. Hier kann ich nur raten, weil ich weder das Spiel, noch den Code kenne:

200 4 33 32 31 30 213 33 214 41 151 48 151 27
+ 200 - wahrscheinlich ein Bitfeld und 200 bedeutet solid... kann aber auch irgendwas anderes sein ^^
+ 4 - schätze, das ist die Anzahl der Punkte im Polygon (hier also ein Viereck)
+ 33 32 31 30 - ich denke, dass dies hier die INDIZES in die Pointlist für deine Punkte sind
mit dem Rest bin ich so von aussen überfragt; wahrscheinlich sind es texturdaten.

Küsschen,
Feenstaub.

Ineluki
31.05.2005, 18:32
Falls einer den Quatsch gelesen hat, den ich zuvor geschrieben hab, dann sei ihm gewiss, ich kann nicht lesen -__-


Ich gebe unserer schlauen Feenstaub natuerlich in allen Punkten recht.
Ich vermute mal, dass die Daten, die sie nicht zu verzeichnen wusste, die Texturkoordinaten U und V sind (da sie eich alle ausnahmslos im bereich 0..255 bewegen, wie in der textur angegeben)

200 4 A B C D UA VA UB VB UC VC UD VD
bzw
200 3 A B C UA VA UB VB UC VC