Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » OpenGL » OpenGL Klasse / VC++

Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: > 1 <
000
22.05.2008, 18:45 Uhr
~Alex__
Gast


Hallo zusammen,

ich bin zugegebenermaßen ein C++ Neuling. Und nun komme ich nicht weiter.
Ich habe eine Klasse Cube, die mit OpenGL einen Würfel zeichnet. Diesen Würfel kann ich dann drehen.

Was ich jetzt machen will, ist diesen Würfel in einer anderen Klasse instanziieren. Ich möchte auf meine "Drehmethode" von aussen zugreifen.

Ich habe es so ausprobiert:

Cube.cpp:

Code:
/*
*        This Code Was Created By Jeff Molofee 2000
*        A HUGE Thanks To Fredric Echols For Cleaning Up
*        And Optimizing The Base Code, Making It More Flexible!
*        If You've Found This Code Useful, Please Let Me Know.
*        Visit My Site At nehe.gamedev.net
*/

#include <windows.h>        // Header File For Windows
#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
#include "Cube.h"

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    rquad;                // Angle For The Quad ( NEW )

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
}

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,-7.0f);                        // Move Right 1.5 Units And Into The Screen 7.0
    
    glRotatef(rquad,0.0f,1.0f,0.0f);                    // Rotate The Quad On The X axis ( NEW )

    glBegin(GL_QUADS);                                    // Draw A Quad
        
..
..
..
..
..
}



Cube.h :

Code:
class Cube
{
public:
    
};


Test.cpp :

Code:
    #include<iostream>
    #include "Cube.h"

    using namespace std;

    int main()
    {
        //Cube cubus;

      cout<<"Hallo Welt\n";
      cin.get();
    }


Das Problem ist, wenn ich das Projekt starte, wird immer Cube.cpp ausgeführt. Ich möchte aber, dass mit meiner Test.cpp gestartet wird und ich von da aus die Cube Klasse instanziieren kann.

Was mache ich falsch?

Grüße
Alex
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
30.08.2008, 20:00 Uhr
cmos



Hallo,
was meinst du mit ausgeführt ? Und wo ist denn in deiner Draw Funktion die Anweisung das
Cube gezeichnet werden soll ?

Das ist jetz mal als Einstieg gedacht. Schreibe die doch eine abstrakte Basisklasse
z.b. 3D Object


C++:
class C3DObject
{
      virtual C3DObject();
      virtual ~C3DObject();

      virtual void DrawObject() = 0;
      virtual void MoveObject(float fX, float fY, float fZ);
      virtual void RotateObject(float fArg, bool X, bool Y, bool Z);
}



Und von dieser leitest du dir dein Cube Object ab


C++:
class Cube : public C3DObject
{
     private:
         float PosX,PosY,PosZ;

     public:
           virtual void DrawObject()
           {
                 // OpenGl Anweisung zum Zeichnen
                glBegin(GL_QUADS);
                
                glEnd();
           }
           virtual void MoveObject(float fX, float fY, float fZ)
           {
           }
           virtual void RotateObject(float fArg, bool X, bool Y, bool Z)
           {
           }
}



In deiner Hauptklasse oder Haupfunktion kannst du nun ein Array oder vector anlegen
der Zeiger vom Typ C3DObject aufnimmt. Ein vector z.b. aus der STL
oder das CAtlArray aus der ATL bietet sich dafür eher an.

z.B.

C++:
Cube cube;
Sphere sphere;

CAtlArray<C3DObject*> Objects;
Objects.Add((C3DObject*)&cube);
Objects.Add((C3DObject*)&sphere);


size_t Objects = Objects.GetCount();

// in deiner Hauptfunktion bzw. hauptklasse in der draw methode/funktion
for(size_t i = 0; i < Objects; i++)
{
    Objects.GetAt(i)->DrawObject();
}




oder


C++:

C3DObject* Objects[3];

Cube cube;
Objects[0] = (C3DObject*)&cube;




in deiner Draw methode der Hauptklasse oder Hauptfunktion (je nach dem was du machst)
kannst du dann in einer for schleife z.b. deine Objekte Zeichnen lassen

for(int i = 0; i < NumberOfObjects; i++)
{
Objects[i]->DrawObject();
}

Grüße,
cmos
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 <     [ OpenGL ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: