DGL • Thema anzeigen - Off-Screen-Rendern

Off-Screen-Rendern

Moderator: DGL-Team

Seite 1 von 1

[ 9 Beiträge ]

Vorheriges Thema | Nächstes Thema

Autor

Nachricht

Prime

Betreff des Beitrags: Off-Screen-Rendern

Verfasst: Do Mai 13, 2004 15:19

DGL Member

Registriert: Do Mai 13, 2004 14:52
Beiträge: 10

Hi folks!

Ich steige grad erst in die OGL-Programmierung ein.
Ich progge unter Delphi6 mit "uses OpenGL".
Folgendes Problem:
Ich möchte OpenGL nutzen um eine 3D-Grafik zu erstellen und auszudrucken.
Da OpenGL mir bei überlappten Fenstern usw. kein gescheites Bild liefert und ich zum Ausdruck hohe Auflösungen brauche möchte ich die Grafik gerne "off-screen" rendern. Ich weiß dass ich dann keine Hardware-Beschleunigung mehr habe, aber das ist nicht weiter wichtig.
Meine Frage ist jetzt: Wie erstelle ich so einen Context ?
Alle meine versuche das ganze intern zu erstellen und mit glReadPixels auszulesen scheitern - vermutlich an diesem "Pixel Ownership Test".
Kann mir da irgendwer helfen ?

Nach oben

Lossy eX

Betreff des Beitrags:

Verfasst: Do Mai 13, 2004 15:46

DGL Member

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

Moin. An deiner Stelle würde ich gar nicht so kompliziert denken.

Als erstes solltest du dir einen anderen OpenGL Header zulegen. Die Unit OpenGL von Borland ist so ziemlich das Älteste was man im Bezug auf OpenGL finden kann. Die besste Alternative ist der boardeigene Header.

Und um dein Problem zu lösen schau dir mal diese Seite von Tom Nuydens an. Da findest du ziemlich genau in der Mitte eine Datei namen Hiresshot.zip. In dieser Quelle erzeugt er mit Hardwarebeschleunigung Onscreen ein sehr großes Bitmap. Er rendert mehrfach kleine Stückchen. Schau es dir einfach mal an. Bei Fragen stehen wir dir gerne zur Verfügung.

Nach oben

Prime

Betreff des Beitrags:

Verfasst: Do Mai 13, 2004 16:05

DGL Member

Registriert: Do Mai 13, 2004 14:52
Beiträge: 10

Hab mir die Header-Datei geladen.
Die Möglichkeit Hi-Res-Shots zu kacheln ist mir bekannt.
Aber bei meiner Anwendung soll definitiv im Hintergrund gerendert werden, die Grafik soll gar nicht auf dem Monitor erscheinen.
Der Anwender klickt auf drucken und es werden 3 - 4 Ansichten im Hintergrund erstellt und auf dem Drucker ausgegeben.

Hier mein bisheriger (nicht funktionierender) Code:
(Ursprünglich habe ich in ein Panel gerendert, was auch funktionierte)

Code:

 
unit FormMain;
 
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, ExtCtrls, Menus, OpenGL;
 
type
 
  TBmpHeader = Packed Record
    bfType1         : Byte;
    bfType2         : Byte;
    bfSize          : LongInt;
    bfReserved1     : Word;
    bfReserved2     : Word;
    bfOffBits       : LongInt;
    biSize          : LongInt;
    biWidth         : LongInt;
    biHeight        : LongInt;
    biPlanes        : Word;
    biBitCount      : Word;
    biCompression   : LongInt;
    biSizeImage     : LongInt;
    biXPelsPerMeter : LongInt;
    biYPelsPerMeter : LongInt;
    biClrUsed       : LongInt;
    biClrImportant  : LongInt;
  end;
 
  Tform_main = class(TForm)
    ...
  private
    { Private-Deklarationen }
    oglDC :hDC;
    oglRC :hGLRC;
    oglPalette :hPALETTE;
    hPic  :hBITMAP;
    procedure SetupPixelFormat;
  public
    { Public-Deklarationen }
    procedure render;
  end;
 
var
  form_main: Tform_main;
 
implementation
 
{$R *.dfm}
 
{ TForm1 }
 
procedure Tform_main.FormCreate(Sender: TObject);
begin
  oglDC := CreateCompatibleDC(panel_ogl.Handle);
  hPic := CreateCompatibleBitmap(oglDC,panel_ogl.Width,panel_ogl.Height);
//  SelectObject(oglDC,hPic);
  SetupPixelFormat;
  oglRC := wglCreateContext(oglDC);
  wglMakeCurrent(oglDC, oglRC);
  glEnable(GL_DEPTH_TEST);
  glLoadIdentity;
end;
 
procedure Tform_main.SetupPixelFormat;
var
  hHeap :THandle;
  nColors :integer;
  i :integer;
  lpPalette :PLogPalette;
  byRedMask,
  byGreenMask,
  byBlueMask :Byte;
  nPixelFormat :Integer;
  pfd :TPixelFormatDescriptor;
begin
  FillChar(pfd, SizeOf(pfd), 0);
  with pfd do
  begin
    nSize := sizeOf(pfd);
    nVersion := 1;
    dwFlags := PFD_DRAW_TO_BITMAP or PFD_SUPPORT_OPENGL;
    iPixelType := PFD_TYPE_RGBA;
    cColorBits := 24;
    cRedBits := 8;
    cGreenBits := 8;
    cBlueBits := 8;
    cDepthBits := 16;
    iLayerType := PFD_MAIN_PLANE;
  end;
  nPixelFormat := ChoosePixelFormat(oglDC, @pfd);
  SetPixelFormat(oglDC, nPixelFormat, @pfd);
  DescribePixelFormat(oglDC, nPixelFormat, sizeOf(TPixelFormatDescriptor), pfd);
  if ((pfd.dwFlags and PFD_NEED_PALETTE) <> 0) then
  begin
    nColors := 1 shl pfd.cColorBits;
    hHeap := GetProcessHeap;
    lpPalette := HeapAlloc(hHeap, 0, sizeOf(TLogPalette)+(nColors*sizeOf(TPaletteEntry)));
    lpPalette^.palVersion := $300;
    lpPalette^.palNumEntries := nColors;
    byRedMask := (1 shl pfd.cRedBits) -1;
    byGreenMask := (1 shl pfd.cGreenBits) -1;
    byBlueMask := (1 shl pfd.cBlueBits) -1;
    for i := 0 to pred(nColors) do
    begin
      lpPalette^.palPalEntry[i].peRed := (((i shr pfd.cRedShift) and byRedMask) *255) div byRedMask;
      lpPalette^.palPalEntry[i].peGreen := (((i shr pfd.cGreenShift) and byGreenMask) *255) div byGreenMask;
      lpPalette^.palPalEntry[i].peBlue := (((i shr pfd.cBlueShift) and byBlueMask) *255) div byBlueMask;
      lpPalette^.palPalEntry[i].peFlags := 0;
    end;
    oglPalette := CreatePalette(lpPalette^);
    HeapFree(hHeap, 0, lpPalette);
    if (oglPalette <> 0) then
    begin
      SelectPalette(oglDC, oglPalette, false);
      RealizePalette(oglDC);
    end;
  end;
end;
 
procedure Tform_main.render;
begin
  glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
  glLoadIdentity;
 
  glColor3f(random,random,random);
  glBegin(gl_quads);
    glVertex3f(1,1,-6);
    glVertex3f(-1,1,-6);
    glVertex3f(-1,-1,-6);
    glVertex3f(1,-1,-6);
  glEnd;
 
  glFinish;
end;
 
procedure Tform_main.bt_initClick(Sender: TObject);
begin
  glViewPort(0,0,panel_ogl.Width,panel_ogl.Height);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluPerspective(45.0, panel_ogl.Width/panel_ogl.Height, 1.0, 100.0);
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity;
end;
 
procedure Tform_main.bt_offscreenClick(Sender: TObject);
var
  pic :TBitmap;
  x,y :integer;
  w,h :integer;
  pba :pByteArray;
  buf :^Byte;
  PByte :^Byte;
begin
  screen.Cursor := crHourGlass;
 
  pic := TBitmap.Create;
  pic.Width := panel_ogl.Width;
  pic.Height := panel_ogl.Height;
  pic.PixelFormat := pf24Bit;
 
  w := panel_ogl.Width;
  h := panel_ogl.Height;
  GetMem(Buf,3 * w * h);
  glReadPixels(0,0,w,h,GL_RGB,GL_UNSIGNED_BYTE,buf);
  PByte := @(buf^);
  for y := pred(h) downto 0 do
  begin
    pba := pic.ScanLine[y];
    for x := 0 to pred(w) do
    begin
      pba[x*3+2] := PByte^;
      inc(PByte);
      pba[x*3+1] := PByte^;
      inc(PByte);
      pba[x*3] := PByte^;
      inc(PByte);
    end;
    for x := 1 to w mod 4 do
      inc(PByte);
  end;
  FreeMem(buf);
 
  img_ogl.Picture.Bitmap.Assign(pic);
  pic.Free;
 
  screen.Cursor := crDefault;
end;
 
end.
 

Irgendwelche Ideen ?

Nach oben

Lossy eX

Betreff des Beitrags:

Verfasst: Fr Mai 14, 2004 07:46

DGL Member

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

Es besteht auch noch die Möglichkeit, dass du dir einen PBuffer (PixelBuffer) erstellt. Da du es gerne OffScreen haben möchtest ist dies genau das richtige für dich.

Aber vorher noch eine kleine Anmerkung. Deine OpenGL initialisierung hat ein kleines Problem. Sobald ein Fehler auftritt macht du so lange weiter bis es irgendwann in Fehlern erstickt. Oder anders gesagt. Du überprüfst nicht ob deine Aktionen auch tatsächlich erfolgreich waren. Als beispiel hier nur mal der Befehl ChoosePixelformat. So habe ich das in meinem Programm gelöst.

Code:

  PixelFormat := ChoosePixelFormat(FDC, @pfd);
  if (PixelFormat = 0) then begin
    MessageBox(0, 'Unable to find a suitable pixel format', 'Error', MB_OK or MB_ICONERROR);
    Exit;
  end;

Aber wie gesagt. Dein Code funktioniert auch sollange es keine Fehler gibt. ;-)

Jetzt zu den PBuffern. Im normalfall würde ich dich auf die Seite von Jason Allen verweisen. Aber die ist schon seit monaten tot. Hmmmm. Und per Zufall habe ich seine Klasse zur Verwendung von PBufferm noch auf meinem System gefunden. Was ein Glück, dass ich so gut wie nie meine Quellen aufräume. :twisted:

So du benötigst für die PBuffers 3 Extension. Als erstes die WGL_ARB_extensions_string. Diese wird von so ziemlich jeder OpenGL unterstützt.
Die beiden Folgenden sind da schon etwas anspruchsvoller. WGL_ARB_pixel_format und WGL_ARB_pbuffer
Bei den beiden letzten musst du schauen ob diese auch unterstützt werden. Andernfalls musst du dir etwas anderes einfallen lassen.
Hier findest du eine Liste mit allen Extensions und im Detail eine Liste von Treibern/Hardware die diese Extension unterstützen.

Für die Initialisierung des PBuffers musst du Allerdings auf einen aktuellen OpenGL Header zurückgreifen. Siehe erstes Post von mir.

Und ich habe dir mal die Klasse von Jason Allen angehangen. Wenn du die Methoden Init und Release in dein Program umsetzt sollte das schon funktionieren.

Für den Fall, dass diese Extensions nicht unterstützt werden (je nachdem welche Zielhardware du ansprechen möchtest) Kannst du entweder einen Fehler ausgeben oder aber du musst es sichtbar rendern.

Du hast keine ausreichende Berechtigung, um die Dateianhänge dieses Beitrags anzusehen.

Nach oben

Prime

Betreff des Beitrags:

Verfasst: Fr Mai 14, 2004 07:57

DGL Member

Registriert: Do Mai 13, 2004 14:52
Beiträge: 10

@Lossy eX
Danke für die Tipps! Werd ich gleich mal ausprobieren!
Für mich ist es wichtig, dass das ganze auf möglichst vielen Rechnern läuft. Soll halt besser zuverlässig funktionieren als schnell!

Danke auch für die Tips bei der Initialisierung. Hab mich damit noch nicht näher beschäftigt, sondern einfach so aus 'nem Tut kopiert. Wollte mir das aber nochmal ansehen sobald ich weiß dass ich keine Probleme mit meinem Vorhaben unter OpenGL bekomme ;-)

Nach oben

Lossy eX

Betreff des Beitrags:

Verfasst: Fr Mai 14, 2004 08:32

DGL Member

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

Kein problem.

Um in ein Fenster zu Rendern genügt es normal schon, wenn GetDC(Panel.Handle) machst. Und dann diesen DC benutzt. Du musst dazu nicht mal einen Kompatiblen erstellen.

Um dich jetzt noch richtig mit Wissen zu bombardieren habe ich noch etwas für dich. ;-)

In der OpenGL 1.2 Header Konvertierung von Mike Lischke befindet sich ein Programm namens GLDiag. Dieses solltest du dir auch einmal anschauen. In diesem Programm erstellt er auch Testweise einen RC direkt auf der Canvas von einem Drucker. Allerdings sei dort ein Wort der Warnung angebacht (oder auch zwei). Wie man in dem Programm schön sehen kann wird für das Rendern in Bitmaps und auf dem Drucker die Software Implementation von Microsoft verwendet.
Da Microsoft nichts so sehr wie DirectX (Direct3D) am Herzen liegt kannst du dir selber ausmalen wie diese Implementation dieses OpenGL Treibers aussieht. So gut wie keine Extensions. Total langsam. OpenGL 1.1 und diverse Implementationsfehler die laut Kleinweich nicht behoben werden.

Falls dir Softwarerendering nichts ausmacht und du dennoch direkt auf den Drucker rendern willst solltest du dir mal die MesaGL anschauen. Das ist eine OpenGL 1.5 Softwareimplementation. Sollte genügen, wenn man nur die DLL dazu mit ins Programmverzeichnis legt. Bin ich aber der Falsche Ansprechpartner für. Solltest da mal Mars frage. Der hat mit Mesa schon recht viel gemacht.

So ich glaube das war es erst einmal. ;-)

Nach oben

Prime

Betreff des Beitrags: So geht's

Verfasst: Fr Mai 14, 2004 12:31

DGL Member

Registriert: Do Mai 13, 2004 14:52
Beiträge: 10

Prima Tip war das!
Hab mir Mesa mal angesehen, damit müsst's auch gehen.
Hab jetzt mit Mike Lischkes OpenGL12 rumgedoktert und das Ganze ans laufen gebracht. Der Code ist noch nicht ganz clean aber es funktioniert!

Danke nochmal @lossy eX

Für Interessierte:

Code:

 
unit FormMain;
 
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, ExtCtrls, Menus, OpenGL12;
 
type
 
  Tform_main = class(TForm)
    ...
  private
    oglPic :TBitmap;
    oglDC  :hDC;
    oglRC  :hGLRC;
  public
    procedure render;
  end;
 
var
  form_main: Tform_main;
 
implementation
 
{$R *.dfm}
 
{ TForm1 }
 
procedure Tform_main.FormCreate(Sender: TObject);
begin
  InitOpenGL;
  oglPic := TBitmap.Create;
  oglPic.Height := panel_ogl.Height;
  oglPic.Width := panel_ogl.Width;
  oglPic.PixelFormat := pf24Bit;
  randomize;
end;
 
procedure Tform_main.FormDestroy(Sender: TObject);
begin
  if HasActiveContext then DeactivateRenderingContext;
  if oglRC <> 0 then DestroyRenderingContext(oglRC);
  if (oglPic.Canvas.LockCount > 0) then oglPic.Canvas.Unlock;
  oglPic.Free;
end;
 
procedure Tform_main.render;
begin
  if HasActiveContext then
  begin
    glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
    glLoadIdentity;
 
    glColor3f(random,random,random);
    glBegin(gl_quads);
      glVertex3f(1,1,-6);
      glVertex3f(-1,1,-6);
      glVertex3f(-1,-1,-6);
      glVertex3f(1,-1,-6);
    glEnd;
 
    glFinish;
  end;
end;
 
procedure Tform_main.bt_captureClick(Sender: TObject);
begin
  render;
  img_ogl.Picture.Bitmap.Assign(oglPic);
end;
 
procedure Tform_main.bt_initClick(Sender: TObject);
const
  BitCounts: array [pf4Bit..pf32Bit] of Byte = (4, 8, 15, 16, 24, 32);
var
  ColorDepth,
  Dummy: HPALETTE;
begin
  try
    oglPic.Canvas.Lock;
    oglDC := oglPic.Canvas.Handle;
    ColorDepth := BitCounts[oglPic.PixelFormat];
    oglRC := CreateRenderingContext(oglDC, [], ColorDepth, 0, 0, 0, 0, Dummy);
    ActivateRenderingContext(oglDC, oglRC);
 
    glViewPort(0,0,oglPic.Width,oglPic.Height);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(45.0, oglPic.Width/oglPic.Height, 1.0, 100.0);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity;
  except
    oglDC := 0;
    if (oglPic.Canvas.LockCount > 0) then oglPic.Canvas.Unlock;
  end;
end;
 
end.
 

Nach oben

Lossy eX

Betreff des Beitrags: Re: So geht's

Verfasst: Fr Mai 14, 2004 13:58

DGL Member

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

Prime hat geschrieben:

Hab jetzt mit Mike Lischkes OpenGL12 rumgedoktert und das Ganze ans laufen gebracht.

Hmmm. Ich kann noch mal auf mein erstes Post verweisen. Der boardeigene Header. Der besste, schönste und aktuellste OpenGL Header den es im Internet zu finden gibt.

Und er ist pflicht für jeden aufm Board. ;-)

Nach oben

Mars

Betreff des Beitrags:

Verfasst: Fr Mai 14, 2004 17:40

DGL Member

Registriert: Fr Dez 13, 2002 12:18
Beiträge: 1063

Du kannst auch ein Bitmap (anstelle eines Fensters) verwenden - und dann den ganz normalen OpenGL Treiber verwenden - allerdings wird dann automatisch die Microsoft Software Implementation genutzt (OpenGL 1.1).

Da du fürs Drucken wahrscheinlich ohnehin damit auskommst, sollte dir dies hier weiterhelfen:
http://support.microsoft.com/default.aspx?scid=http://support.microsoft.com:80/support/kb/articles/Q132/8/66.asp&NoWebContent=1

Alternativ kannst du die Mesa Treiber verwenden - wenn du die Mesa-Bibliotheken erstellst (es ist ein Makefile für MingW dabei, sodass du dafür Freewareprogramme verwendenkannst - ansonsten google mal nach osmesa.dll - wenns gar nicht anders geht kann auch ich ihn dir kompilieren) - so erhältst du neben OpenGL32.dll und GLU32.dll auch OSMESA.DLL, das einfach anstelle von OpenGL32.dll geladen werden muss - und dann kann man direkt in einen Speicherbereich rendern.
Um OSMESA zu laden, kannst du genau so dglOpenGL nutzen, da der Name des OpenGL Treibers frei wählbar ist.

OSMESA hat den Vorteil, dass auch Floating Point Pixelformate möglich sind (sogar mit Double Werten) und dass OpenGL 1.5 unterstützt wird - der Nachteil ist, dass du nicht einfach in ein TBitmap rendern kannst, als das Ganze betriebssystemunabhängig ist und du somit deinen Speicher selbst verwalten musst (bzw. interpretieren, was Mesa da nun hineingerendert hat - Mesa "sieht" einen Speicherblock und interpretiert diesen als rechteckinge Matrix von den entsprechenden Komponenten, die du für dein Pixelformat wählst).

[edit]
die Antwort mit dem Bitmap wäre eh schon dagewesen ...
[/edit]

_________________
Viel Spaß beim Programmieren,
Mars
http://www.basegraph.com/

Nach oben

Seite 1 von 1

[ 9 Beiträge ]

Foren-Übersicht » Programmierung » OpenGL

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 2 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.