DGL • Thema anzeigen - Kein Select der Objekte...

Kein Select der Objekte...

Moderator: DGL-Team

Seite 1 von 1

[ 6 Beiträge ]

Vorheriges Thema | Nächstes Thema

Autor

Nachricht

grenzgaenger

Betreff des Beitrags: Kein Select der Objekte...

Verfasst: So Sep 09, 2007 11:55

DGL Member

Registriert: Sa Aug 04, 2007 19:22
Beiträge: 5

Hallo Leuts,

ich versuch mir grad 'n objekt zu schreiben, das es auch solchen dummies, wie mich, ermöglicht mal ein OGL auf den Bildschirm zu zaubern, doch leider klappt das noch nicht ganz ...

hier mein Beispielcode:

Code:

unit Unit1;
 
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, glObj, dglOpenGL;
 
type
  tMyGL = class(tGL)
   procedure ErrorHandler; override;  
   procedure run;          override;
   procedure OnLastHit(sender: tObject);
  end;
 
  TForm1 = class(TForm)
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
  private
    { Private-Deklarationen }
    gl: tMyGL;
   
  public
    { Public-Deklarationen }
  end;
 
var
  Form1: TForm1;
 
implementation
 
{$R *.dfm}
 
procedure TForm1.FormCreate(Sender: TObject);
begin
 gl := tMyGl.create(self.Handle, application, self);
 gl.IsSelectNames := true;
 gl.OnHit := gl.OnLastHit;
end;
 
procedure TForm1.FormDestroy(Sender: TObject);
begin
 if gl <> NIL then FreeAndNil(GL);
end;
 
procedure tMyGL.OnLastHit(sender: tObject);
begin
 case LastHit of
  1: printtext(20,20, 'in Eins');
  2: printText(20,20, 'in Zwei');
  3: printText(20,20, 'in Drei');
 end;
end;
 
{ tMyGL }
 
procedure tMyGL.ErrorHandler;
begin
 
end;
 
procedure tMyGL.run;
begin
  glTranslatef(0,0,-6);
 
  glColor3f(1,0,0);
  glLoadName(1);
  glBegin(gl_triangles);
    glVertex3f(-0.5,1,0);
    glVertex3f(0.5,1,0);
    glVertex3f(0,2,0);
  glEnd;
 
  glLoadName(2);
  glColor3f(0,1,0);
  glBegin(gl_quads);
    glVertex3f(-1,0,0);
    glVertex3f(-2,0,0);
    glVertex3f(-2,-1,0);
    glVertex3f(-1,-1,0);
  glEnd;
  
  glLoadName(3);
  glColor3f(1,1,0);
  glBegin(gl_triangles);
    glVertex3f(1,0,0);
    glVertex3f(2,0,0);
    glVertex3f(1.5,-1,0);
 
    glVertex3f(1,-0.65,0);
    glVertex3f(2,-0.65,0);
    glVertex3f(1.5,0.35,0);
  glEnd;
end;
 
end.

der selektiert jedoch nicht das letzte gefunde objekt... weiss jemand, an was es liegen kann...

hier noch die klasse dazu...

Code:

unit glObj;
interface
uses dglOpenGL, Windows, Forms, sysutils, Classes;
 
type
 tGLClearColor = record
  red, green, blue, alpha: single;
 end;
 
 tGL = class
  private
   RC               : HGLRC;
   DC               : HDC;
   FontBase         : GLUInt;
   StartTick        : Cardinal;
   fLastError       : word;
   fHandle          : HWND;
   fFrames          : Integer;
   fFPS             : Single;
 
   fClearColor      : tGLClearColor;
   fNearClipping    ,
   fFarClipping     : word;
   ffovy            : single;
   
   fSavedOnIdle     : TIdleEvent;
   fRaise_error     : boolean;
   f_if_full_screen : boolean;
   fSelectNames     : boolean;
   fLastHit         : integer;
 
   fHitEvent        : TNotifyEvent;
   
   procedure wClearColor(const Value: TGLClearColor);
   
  protected
   fForm            : tForm;
   fApp             : tApplication;
   
  public
   constructor create(handle: HWND;
                      const TApp  : TApplication;
                      const Form  : tForm;
                      fullscreen  : boolean = false;
                      raise_error : boolean = false;
                      Select_Names: boolean = false);
   destructor Destroy; override;
 
   procedure Init;
 
   procedure BuildFont(pFontName : String);
   procedure GoToFullScreen(pWidth, pHeight, pBPP, pFrequency : Word);
   procedure PrintText(pX,pY : Integer; const pText : String);
   procedure Idle(Sender: TObject; var Done: Boolean);
   procedure FormResize;
   
   procedure ErrorHandler; virtual; abstract;
   procedure run;          virtual; abstract;
   
   property  Frames: integer read fFrames write fFrames;
   property  FPS: single read fFPS write fFPS;
   property  NearClipping: word read fNearClipping write fNearClipping;
   property  FarClipping : word read fFarClipping  write fFarClipping;
   property  ClearColor: TGLClearColor read fClearColor write wClearColor;
   property  LastError: word read fLastError write fLastError;
   property  fovy: single read ffovy write ffovy;
   property  IsSelectNames: boolean read fSelectNames write fSelectNames;
   property  LastHit: integer read fLastHit;
 
   property  OnHit: TNotifyEvent read fHitEvent write fHitEvent;
 end;
 
 EErrorGoToFullScreen = class(exception);
 
resourcestring 
 Res_Error_on_FullScreen_Call = 'Konnte Vollbildmodus nicht aktivieren!';
 Res_Error                    = 'Error';
 
const
 No_Error                     =    0;
 Error_on_FullScreen_Call     = 1000; 
 
implementation
 
procedure tGL.Init;
begin
 fNearClipping := 1;
 fFarClipping  := 1000;
 fovy          := 45.0;
 
 glClearColor(fClearColor.red, fClearColor.green, 
              fClearColor.blue, fClearColor.alpha); // Löschfarbe für Farbpuffer setzen
 
 BuildFont('MS Sans Serif');// Displayfont erstellen
 
 glMatrixMode(GL_PROJECTION); // In die Projektionsmatrix wechseln
 glLoadIdentity;             // Identitätsmatrix laden
 glViewPort(0, 0, fForm.ClientWidth, fForm.ClientHeight); // Viewport an Clientareal des Fensters anpassen 
 
end;
 
constructor tGL.create(handle: HWND;
                      const TApp: TApplication;
                      const Form: tForm;
                      fullscreen: boolean  = false;
                      raise_error: boolean = false;
                      Select_Names: boolean = false);
begin
 inherited create;
 fHandle           := handle;
 fForm             := Form;
 fApp              := TApp;
 fraise_error      := raise_error;
 f_if_full_screen  := false;
 fSelectNames      := Select_Names;
 
 fLastError        := No_Error;
 
 // Wenn gewollt, dann hier in den Vollbildmodus wechseln
 // Muss vorm Erstellen des Kontextes geschehen, da durch den Wechsel der
 // Gerätekontext ungültig wird!
 if fullscreen then
  GoToFullscreen(1600, 1200, 32, 75);
 
 InitOpenGL; // OpenGL-Funtionen initialisieren
 
 DC := GetDC(fHandle); // Gerätekontext holen
 
 // Renderkontext erstellen (32 Bit Farbtiefe, 24 Bit Tiefenpuffer, Doublebuffering)
 RC := CreateRenderingContext(DC, [opDoubleBuffered], 32, 24, 0, 0, 0, 0);
 
 ActivateRenderingContext(DC, RC); // Erstellten Renderkontext aktivieren
 
 glEnable(GL_DEPTH_TEST); // Tiefenpuffer aktivieren
 glEnable(GL_CULL_FACE);  //Backface Culling aktivieren    
//   glEnable(GL_LIGHTING) ;
//   glEnable(GL_COLOR_MATERIAL);
//   glEnable(GL_LIGHT0);
 
 // Nur Fragmente mit niedrigerem Z-Wert (näher an Betrachter) "durchlassen"
 glDepthFunc(GL_LESS);
 
  // Idleevent für Rendervorgang zuweisen
 fSavedOnIdle := fApp.OnIdle;
 fApp.OnIdle  := Idle;
 
 init; //Initialisierung aufrufen
 
 StartTick := GetTickCount; // Zeitpunkt des Programmstarts für FPS-Messung speichern
 
// if fRaise_error then
//  Case fLastError of
//   Error_on_FullScreen_Call: MessageBox(0, pChar(Res_Error_on_FullScreen_Call), 
//                                        pChar(res_error), MB_OK or MB_ICONERROR);
//  end; 
 
end;
 
Destructor tGL.Destroy;
begin
 FApp.OnIdle := fSavedOnIdle; //Idle Procedure zurücksetzen
 
 DeactivateRenderingContext; // Renderkontext deaktiveren
 DestroyRenderingContext(RC);
 //wglDeleteContext(RC);       // Renderkontext "befreien"
 ReleaseDC(fHandle, DC); // Erhaltenen Gerätekontext auch wieder freigeben
 
 // Falls wir im Vollbild sind, Bildschirmmodus wieder zurücksetzen
 if f_if_full_screen then
  ChangeDisplaySettings(devmode(nil^), 0);
 
 inherited destroy;
end;
 
//procedure tGL.ErrorHandler;
//begin
// //  msg.SimpleText := gluErrorString(glGetError);
//end;
 
procedure tGL.FormResize;
begin
 glViewport(0, 0, fForm.ClientWidth, fForm.ClientHeight);
 glMatrixMode(GL_PROJECTION);
 glLoadIdentity;
 gluPerspective(ffovy, fform.ClientWidth / fform.ClientHeight, 
                      fNearClipping, fFarClipping);    
 
 glMatrixMode(GL_MODELVIEW);
 glLoadIdentity;
end;
 
procedure tGL.PrintText(pX,pY : Integer; const pText : String);
// =============================================================================
//  Gibt einen Text an Position x/y aus
// =============================================================================
begin
 if pText <> '' then
 begin
  // Tiefentest und Texturierung für Textanzeige deaktivieren
  glDisable(GL_DEPTH_TEST);
  glDisable(GL_TEXTURE_2D);
  // In orthagonale (2D) Ansicht wechseln
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity;
  glOrtho(0,640,480,0, -1,1);
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity;
 
  glPushAttrib(GL_LIST_BIT);
  glRasterPos2i(pX, pY);
  glListBase(FontBase);
  glCallLists(Length(pText), GL_UNSIGNED_BYTE, pChar(pText));
  glPopAttrib;
 
  glEnable(GL_DEPTH_TEST);
  glEnable(GL_TEXTURE_2D);  
 end;
end;
 
procedure tGL.wClearColor(const Value: TGLClearColor);
begin
 fClearColor := value;
 glClearColor(fClearColor.red,  fClearColor.green,
              fClearColor.blue, fClearColor.alpha);
end;
 
procedure tGL.BuildFont(pFontName : String);
//==============================================================================
//  Displaylisten für Bitmapfont erstellen
// =============================================================================
var
 Font : HFONT;
begin
 FontBase := glGenLists(96); // Displaylisten für 256 Zeichen erstellen
 
 // Fontobjekt erstellen
 Font     := CreateFont(16, 0, 0, 0, FW_MEDIUM, 0, 0, 0,
                        ANSI_CHARSET, OUT_TT_PRECIS, CLIP_DEFAULT_PRECIS,
                        ANTIALIASED_QUALITY, FF_DONTCARE or DEFAULT_PITCH,
                        PChar(pFontName));
 
 SelectObject(DC, Font);  // Fontobjekt als aktuell setzen
 wglUseFontBitmaps(DC, 0, 256, FontBase); // Displaylisten erstellen
 DeleteObject(Font) // Fontobjekt wieder freigeben
end;
 
procedure tGL.GoToFullScreen(pWidth, pHeight, pBPP, pFrequency : Word);
// =============================================================================
//  Wechselt in den mit den Parametern angegebenen Vollbildmodus
// =============================================================================
var
 dmScreenSettings : DevMode;
begin
 // Fenster vor Vollbild vorbereiten
 fForm.BorderStyle    := bsNone;
 fForm.WindowState    := wsMaximized;
 ZeroMemory(@dmScreenSettings, SizeOf(dmScreenSettings));
 with dmScreenSettings do
 begin
  dmSize              := SizeOf(dmScreenSettings);
  dmPelsWidth         := pWidth;                    // Breite
  dmPelsHeight        := pHeight;                   // Höhe
  dmBitsPerPel        := pBPP;                      // Farbtiefe
  dmDisplayFrequency  := pFrequency;                // Bildwiederholfrequenz
  dmFields            := DM_PELSWIDTH  or DM_PELSHEIGHT 
                      or DM_BITSPERPEL or DM_DISPLAYFREQUENCY;
 end;
 
 if (ChangeDisplaySettings(dmScreenSettings, CDS_FULLSCREEN) = DISP_CHANGE_FAILED) then
 begin
  f_if_full_screen := false;
  fLastError       := Error_on_FullScreen_Call;
  if fRaise_error then
   raise EErrorGoToFullScreen.Create(Res_Error_on_FullScreen_Call) 
 end
 else
 begin
   f_if_full_screen := true;
 end;
end;
 
procedure tGL.Idle(Sender: TObject; var Done: Boolean);
// =============================================================================
//  Hier wird gerendert.
// =============================================================================
var
 SelectBuffer : array[0..1024] of TGLUInt;
 Viewport     : TGLArrayi4;
 Hits,i       : Integer;
 HitZValue    : TGLUInt;
 Hit          : TGLUInt; 
begin
 if fSelectNames then //Wenn Selektion aktiv ist
 begin
  glGetIntegerv(GL_VIEWPORT, @viewport);
  glSelectBuffer(1024, @SelectBuffer);
  glMatrixMode(GL_MODELVIEW); //In's Modelview schalten
  glRenderMode(GL_SELECT);
  glInitNames;                //Name Stack Initialisieren
  glPushName(0);              //Default Name einsetzen  
  glMatrixMode(GL_PROJECTION);
  glPushMatrix;
  glLoadIdentity;
  gluPickMatrix(0, 0, fForm.ClientWidth, fForm.ClientHeight, viewport);
  gluPerspective(fovy, fForm.ClientWidth/fForm.ClientHeight, 
                       fNearClipping, fFarClipping);
  glRenderMode(GL_RENDER);                     
 end;
 
 glMatrixMode(GL_PROJECTION); // In die Projektionsmatrix wechseln
 glLoadIdentity;             // Identitätsmatrix laden
// glViewPort(0, 0, fForm.ClientWidth, fForm.ClientHeight); // Viewport an Clientareal des Fensters anpassen
 gluPerspective(fovy, fForm.ClientWidth/fForm.ClientHeight, 
                      fNearClipping, fFarClipping);// Perspective, FOV und Tiefenreichweite setzen
 glMatrixMode(GL_MODELVIEW);  // In die Modelansichtsmatrix wechseln
 glLoadIdentity;              // Identitätsmatrix laden
 glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT); // Farb- und Tiefenpuffer löschen
 
 run; //hier ist die Zeichenroutine
 
 SwapBuffers(DC);  // Hinteren Puffer nach vorne bringen
 
 if fSelectNames then  //Wenn Selektion aktiv ist
 begin
  glMatrixMode(GL_PROJECTION);
  glPopMatrix;
  Hits      := glRenderMode(GL_RENDER);
  Hit       := High(TGLUInt);
  HitZValue := High(TGLUInt);
  for i := 0 to Hits-1 do
   if SelectBuffer[(i*4)+1] < HitZValue then
    begin
    Hit       := SelectBuffer[(i*4)+3];
    HitZValue := SelectBuffer[(i*4)+1];
    end;
  fLastHit := Hit;
  if assigned(onHit) then
   OnHit(sender);
 end
 else
  fLastHit := -1;
 
 inc(fFrames);     // Nummer des gezeichneten Frames erhöhen
 if (GetTickCount - StartTick) >= 1000 then // FPS aktualisieren
 begin
  fFPS       := fFrames/(GetTickCount-StartTick)*1000;
  fFrames    := 0;
  StartTick  := GetTickCount;
 end;
 
 ErrorHandler;
 done := false;
end;
 
end.

dank für euere hilf

PS: auch der Textoutput, könnt noch optimierung vertragen...

Nach oben

i0n0s

Betreff des Beitrags:

Verfasst: So Sep 09, 2007 12:12

Ernährungsberater

Registriert: Sa Jan 01, 2005 17:11
Beiträge: 2068
Programmiersprache: C++

Zeile 307.:

Code:

glRenderMode(GL_RENDER);

Du solltest aber im GL_SELECT bleiben. Ansonsten gibt es im Wiki eine Checkliste bzgl. Selektion.

_________________
Steppity,✲steppity,✴step,❆step,✳step! :twisted:

❆ ❄ ❄ ❄ ❅ ❄ ❆ ❄ ❅ ❄ ❅ ❄ ❅ ❄ ❄
❅ ☃ ❄ ❄ ❄ ❅ ❄ ❄ ❄ ❅ ❄ ☃ ❄ ❆ ❄ ❄

Nach oben

grenzgaenger

Betreff des Beitrags:

Verfasst: So Sep 09, 2007 19:40

DGL Member

Registriert: Sa Aug 04, 2007 19:22
Beiträge: 5

danke, für den tipp, aber wenn ich statt

glRenderMode(GL_RENDER);

glRenderMode(GL_SELECT); schreibe, dann zeichnet er mir leider nix mehr...

PS: wo kann ich denn die checkliste finden?

Nach oben

Lossy eX

Betreff des Beitrags:

Verfasst: Mo Sep 10, 2007 08:16

DGL Member

Registriert: Do Dez 05, 2002 10:35
Beiträge: 4234
Wohnort: Dortmund

Die Checkliste kannst du dort finden. http://wiki.delphigl.com/index.php/Hintergrundwissen#Checklisten

Aber du machst bei deiner Selektion ein paar Fehler.

Code:

if fSelectNames then //Wenn Selektion aktiv ist
  glSelectBuffer(...)
  glInitNames(...)
  glPushName(...)
 
  gluPickMatrix(...)
  gluPerspective(...)
 
  glRenderMode(GL_RENDER); <<< Das da!!!
end;
 
glMatrixMode(GL_PROJECTION);
glLoadIdentity()
gluPerspective(...)
 
SwapBuffers(DC);

Das "glRenderMode(GL_RENDER)" ist falsch. Damit verlässt du die Selektion augenblicklich wieder.

Das Neusetzen der Ansicht ist auch falsch, da du dadurch deine für die Selektion eingestellte Ansicht wieder überschreist bzw auf die Darstellungsansicht setzen würdest. Was einer Selektion über den gesammten Bildschirm gleich kommt.

Das "SwapBuffers(DC);" ist auch falsch. Denn wenn du eine normale Selektion hättest würdest du nichts zeichnen und damit würde ein leeres Bild gezeichnet werden.

Korrekt müsste es so aussehen. Kein echter Code sondern eher Pseudocode.

Code:

if fSelectNames then begin
  glSelectBuffer(...)
 
  glRenderMode(GL_SELECT)
  glInitNames
  glPushName(...)
 
  glMatrixMode(GL_PROJECTION)
  glPushMatrix
  glLoadIdentity
 
  gluPickMatrix(...)
  gluPerspective(...)
 
  Objekte Zeichnen
 
  // Ansicht zurücksetzen
  glMatrixMode(GL_PROJECTION);
  glPopMatrix;
 
  // Selektion verlassen und Hits auswerten
  Hits := glRenderMode(GL_RENDER);
  ...
end;
 
// Hier noch einmal normal zeichnen
 
SwapBuffers(DC);

Wobei die Selektion an der Stelle aber genau um ein Bild verzögert wäre. Was im Normalfall aber eher ungüstig ist, denn du würdest erst verspätet darauf reagieren etc. Typischerweise würde ich empfehlen, dass du eine die Selektion nicht direkt beim Rendern erledigst sondern es als extra Methode machst um auf das Ergebniss der Selektion auch reagieren zu können.

Nach oben

Phobeus

Betreff des Beitrags:

Verfasst: Mo Sep 10, 2007 08:59

Fels i.d. Brandung

Registriert: Sa Mai 04, 2002 19:48
Beiträge: 3830
Wohnort: Tespe (nahe Hamburg)

Aus meiner Sicht einfacher und in einem aktuellen Projekt erfolgreich eingesetzt: Selektion per Farbwahl. Du definierst Dir ein Basis-Objekt, dass die Methode "render" enthält. Hier drinne entscheidest Du Dich, ob Du die Welt gerade für den Nutzer oder für den (ich nenns mal) ColorPicker render willst. Alle davon abgeleiten Objekte müssen von dort an zwei Methoden mitbringen. Ich nannte sie immer "renderColorPicker" und "renderNormal". Es kann sich lohnen die Geometry in einer weiteren Methode "renderObject" zu schreiben, die Du in beiden aufrufst. In der Methode darf dann nur Geometry sein, keine Texturierung oder Farbbelegung. Wieso überhaupt zwei Methoden für beide Modi? Würden beide gleich rendern (was bei vielen Objekten geht), würdest Du keine Möglichkeit haben gesonderte Klickbereiche zu haben, z.B. wenn der klickbare Bereich größer sein soll als das Objekt selbst oder Du Dich im renderNormal dafür entscheidest z.B. einen Schattenwurf einzubauen, der allerdings nicht klickbar sein soll.

Von einer globalen Instanz läßt Du Dir einmalige Farbwerte geben und weist diese dann dem Objekten zu. Vor dem Zeichnen des renderColorPick setzt Du diese Farbe. Nun kannst Du bei einem Mausklick in einen ColorPick-Mode gehen, alle deine Objekte ganz normal rendern lassen, bei der aktuellen Mausposition die Farbe auslesen und danach diese bei der globalen Instanz nachschlagen. Dieses Verfahren hat aus meiner Sicht zwei entscheidende Vorteile. Es ist sehr leicht transparent in eigene Anwendungen einzubauen und es erlaubt ein vorzügliches Debugging, da man die Szene einfach im ColorPick-Mode zeichnen kann, um zu sehen, wie die Klickbereiche aussehen und wie sie sich mit der aktuellen Szene überlagern. Das ganze klingt wesentlich komplizierter als es tatsächlich ist, ist für mich allerdings eine echte Alternative in anbetracht der Tatsache, dass es den Selektion-Mode ab OpenGL3 sowieso nicht mehr geben soll.

Die Anzahl der Objekte mit (256^4)-1 sollten auch locker ausreichen und die Szene untexturiert als reine Geometry nochmal zeichnen schafft jede aktuelle Grafikkarte. Zumal dies nur gemacht werden muss, wenn der Anwender einmal geklickt hat. Für einen Hover-Effekte, der vorraussetzt das man bei jeder Mausbewegung die Szene nochmals zeichnet, kann es auf alten Karten zu kleineren Lags kommen. Dafür ist kostet es dann doch ein wenig. Habe ein solches Verfahren gerade in einem Projekt eingesetzt und hat vorzüglich funktioniert und war für den Einsatzbereich auch sehr performant.... und für die Mahte-Idioten wie mich: kommt ohne eine Zeile Mathe aus ;-)

_________________
"Light travels faster than sound. This is why some people appear bright, before you can hear them speak..."

Nach oben

grenzgaenger

Betreff des Beitrags:

Verfasst: Sa Mai 31, 2008 10:36

DGL Member

Registriert: Sa Aug 04, 2007 19:22
Beiträge: 5

danke, lossy und Phobeus. hab die ganze selektion herausgenommen...

werd mir mal die color pick geschichte von Phobeus ansehen. kennt jemand 'n kleines code beispiel hierfür? hab nur 3 einträge hier gefunden, die nicht grad was damit zu tun haben...

schönes wochenende
GG

Nach oben

Seite 1 von 1

[ 6 Beiträge ]

Foren-Übersicht » Programmierung » OpenGL

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 5 Gäste

Du darfst keine neuen Themen in diesem Forum erstellen.
Du darfst keine Antworten zu Themen in diesem Forum erstellen.
Du darfst deine Beiträge in diesem Forum nicht ändern.
Du darfst deine Beiträge in diesem Forum nicht löschen.
Du darfst keine Dateianhänge in diesem Forum erstellen.