DGL • Thema anzeigen - 2 Probleme mit dem VertexBufferObjekt

2 Probleme mit dem VertexBufferObjekt

Moderator: DGL-Team

Seite 1 von 1

[ 9 Beiträge ]

Vorheriges Thema | Nächstes Thema

Autor

Nachricht

Bergmann89

Betreff des Beitrags: 2 Probleme mit dem VertexBufferObjekt

Verfasst: Fr Jul 24, 2009 03:35

DGL Member

Registriert: Di Apr 29, 2008 18:56
Beiträge: 1213
Programmiersprache: Delphi/FPC

HI,

ich bin grad dabei VBOs in mein Programm einzubauen. Um das alles n bisl einfacher zu gestalten, hab ich mir das in ne extra Klasse gekapselt. Aber ich hab noch 2 Sachen womit ich nich klar komm:
1. ich habe 20.000 verschiedene "WriteBufferData"-Prozeduren, die funktionieren auch, aber das sieht etwas unschön aus, also wollt ich die alle in eine Prozedur kapseln (procedure TVertexBufferObject.WriteBufferData(Data: Pointer; VertexType, Usage: Cardinal)) Da wird aber irgendwie der Pointer net weiter gegeben?! die ganzen Variablen haben die richtigen werte, das hab ich schon mit den anderen Prozeduren verglichen...

2. beim direkten schreiben in den Speicher erhalt ich beim schließen des Programms eine zugriffsverletzung. Und das Quad wird auch nich gerendert.

wäre net wenn sich das ma jmd ansehen könnte, code folgt...

Mfg & Thx Bergmann

Code:

procedure TForm1.Init;
var Vertex: TVertexT2fV3fArray;
begin
  VBO := TVertexBufferObject.Create;
 
  SetLength(vertex, 4);
  with vertex[0] do
    begin S := 1; T := 1; X :=  1; Y :=  1; Z := 0; end;
  with vertex[1] do
    begin S := 0; T := 1; X := -1; Y :=  1; Z := 0; end;
  with vertex[2] do
    begin S := 0; T := 0; X := -1; Y := -1; Z := 0; end;
  with vertex[3] do
    begin S := 1; T := 0; X :=  1; Y := -1; Z := 0; end;
  VBO.WriteBufferData(vertex, GL_STATIC_DRAW); //geht
  VBO.WriteBufferData(@Vertex, GL_T2F_V3F, GL_STATIC_DRAW); //geht nich, Quad wird nich gezeichnet...
 
 
  //geht nich, Quad wird nich gezeichnet + Zugriffsverletzung beim beenden...
  VBO.InitDirectWrite(4, GL_T2F_V3F, GL_STATIC_DRAW);
  VBO.DirectWrite(1,1, 1, 1,0);
  VBO.DirectWrite(0,1,-1, 1,0);
  VBO.DirectWrite(0,0,-1,-1,0);
  VBO.DirectWrite(1,0, 1,-1,0);
  VBO.FinishDirectWrite;
 
//natürlich nehm ich nur eine der 3 Menthoden....
end;

Code:

  //VertexTypen für das VertexBufferObject
  //T - Texture, C - Color, N - Normale, V - Vertex
  //f - Float, b - Byte
  //Bsp.: TVertex T2fV3f erwartet 2-FloatParameter für Texturen
  //      und 3 FloatParameter Vertex
  TVertexV2f          = packed record                   X,Y  : TGLFloat; end;   //GL_V2F
  TVertexV3f          = packed record                   X,Y,Z: TGLFloat; end;   //GL_V3F
  TVertexC4bV2f       = packed record     R,G,B,A: Byte;X,Y  : TGLFloat; end;   //GL_C4UB_V2F
  TVertexC4bV3f       = packed record     R,G,B,A: Byte;X,Y,Z: TGLFLoat; end;   //GL_C4UB_V3F
  TVertexC3fV3f       = packed record     R,G,B,        X,Y,Z: TGlFloat; end;   //GL_C3F_V3F
  TVertexN3fV3f       = packed record             U,V,W,X,Y,Z: TGLFloat; end;   //GL_N3F_V3F
  TVertexC4fN3fV3f    = packed record     R,G,B,A,U,V,W,X,Y,Z: TGLFloat; end;   //GL_C4F_N3F_V3F
  TVertexT2fV3f       = packed record S,T,              X,Y,Z: TGLFloat; end;   //GL_T2F_V3F
  TVertexT2fC4bV3f    = packed record S,T: TGLFloat;                            //T2F
                                          R,G,B,A: Byte;                        //C4UB
                                                        X,Y,Z: TGLFloat; end;   //V3F - GL_T2F_C4UB_V3F
  TVertexT2fC3fV3f    = packed record S,T,R,G,B,        X,Y,Z: TGLFloat; end;   //GL_T2F_C3F_V3F
  TVertexT2fN3fV3f    = packed record S,T,        U,V,W,X,Y,Z: TGLFloat; end;   //GL_T2F_N3F_V3F
  TVertexT2fC4fN3fV3f = packed record S,T,R,G,B,A,U,V,W,X,Y,Z: TGLFloat; end;   //GL_T2F_C4F_N3F_V3F
 
  //ArrayTypen der VertexTypen
  TVertexV2fArray           = array of TVertexV2f;
  TVertexV3fArray           = array of TVertexV3f;
  TVertexC4bV2fArray        = array of TVertexC4bV2f;
  TVertexC4bV3fArray        = array of TVertexC4bV3f;
  TVertexC3fV3fArray        = array of TVertexC3fV3f;
  TVertexN3fV3fArray        = array of TVertexN3fV3f;
  TVertexC4fN3fV3fArray     = array of TVertexC4fN3fV3f;
  TVertexT2fV3fArray        = array of TVertexT2fV3f;
  TVertexT2fC4bV3fArray     = array of TVertexT2fC4bV3f;
  TVertexT2fC3fV3fArray     = array of TVertexT2fC3fV3f;
  TVertexT2fN3fV3fArray     = array of TVertexT2fN3fV3f;
  TVertexT2fC4fN3fV3fArray  = array of TVertexT2fC4fN3fV3f;
 
  //Pointer der Arrays
  PVertexV2fArray           = ^TVertexV2fArray;
  PVertexV3fArray           = ^TVertexV3fArray;
  PVertexC4bV2fArray        = ^TVertexC4bV2fArray;
  PVertexC4bV3fArray        = ^TVertexC4bV3fArray;
  PVertexC3fV3fArray        = ^TVertexC3fV3fArray;
  PVertexN3fV3fArray        = ^TVertexN3fV3fArray;
  PVertexC4fN3fV3fArray     = ^TVertexC4fN3fV3fArray;
  PVertexT2fV3fArray        = ^TVertexT2fV3fArray;
  PVertexT2fC4bV3fArray     = ^TVertexT2fC4bV3fArray;
  PVertexT2fC3fV3fArray     = ^TVertexT2fC3fV3fArray;
  PVertexT2fN3fV3fArray     = ^TVertexT2fN3fV3fArray;
  PVertexT2fC4fN3fV3fArray  = ^TVertexT2fC4fN3fV3fArray;  
 
  VertexBufferException = class(Exception);
  TVertexBufferObject = class(TObject)
  private
    //das eigentliche VBO (Index von OpenGL)
    fVertexBufferObject                         : gluInt;
    //Anzahl der zu übergebenden Vertex (für Speicherreservierung)
    //|            Anzahl der bereits übergebenen Vertex
    fVertexAnzahl, fVertexCount                 : Integer;
    //Typ der zu zeichnenden Vertex (GL_V2F, ...)
    fVertexType                                 : Cardinal;
    //gibt an ob das DirectWrite richtig initialisiert wurde
    fDirectWriteInit                            : Boolean;
    //StartAdresse der Vertex im GrakaSpeicher
    //|                  Adresse des nächsten vertex was übergeben wird
    fStartAdressPointer, fActiveAdressPointer   : Pointer;
  public
    //Übergibt die erhaltenen Daten an den GrakaSpeicher
    procedure WriteBufferData(Data: Pointer; VertexType, Usage: Cardinal); overload;
    procedure WriteBufferData(Data: array of          TVertexV2f; Usage: Cardinal); overload;
    procedure WriteBufferData(Data: array of          TVertexV3f; Usage: Cardinal); overload;
    procedure WriteBufferData(Data: array of       TVertexC4bV2f; Usage: Cardinal); overload;
    procedure WriteBufferData(Data: array of       TVertexC4bV3f; Usage: Cardinal); overload;
    procedure WriteBufferData(Data: array of       TVertexC3fV3f; Usage: Cardinal); overload;
    procedure WriteBufferData(Data: array of       TVertexN3fV3f; Usage: Cardinal); overload;
    procedure WriteBufferData(Data: array of    TVertexC4fN3fV3f; Usage: Cardinal); overload;
    procedure WriteBufferData(Data: array of       TVertexT2fV3f; Usage: Cardinal); overload;
    procedure WriteBufferData(Data: array of    TVertexT2fC4bV3f; Usage: Cardinal); overload;
    procedure WriteBufferData(Data: array of    TVertexT2fC3fV3f; Usage: Cardinal); overload;
    procedure WriteBufferData(Data: array of    TVertexT2fN3fV3f; Usage: Cardinal); overload;
    procedure WriteBufferData(Data: array of TVertexT2fC4fN3fV3f; Usage: Cardinal); overload;
    procedure InitDirectWrite(VertexCount: Integer; VertexType, Usage: Cardinal);//initialisiert die direkte Eingabe in den Speicher
    function  DirectWrite(S,T,X,Y,Z: TGLFloat): Boolean;                        //schreibt ein neues Vertex (vom Typ GL_T2F_V3F) in den Speicher
    procedure FinishDirectWrite;                                                //schließt das Directe Schreiben in den Speicher ab
    procedure Render(Mode: Cardinal);                                           //Zeichnet das VBO
    constructor Create;                                                         //erzeugt das VBO
    destructor  Destroy; override;                                              //gibt das VBO frei
  end;
 
implementation
 
////////////////////////////////////////////////////////////////////////////////
//VertexBufferObject////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
 
procedure TVertexBufferObject.WriteBufferData(Data: Pointer; VertexType, Usage: Cardinal);
var size: Integer;
begin
  size := 0;
  case VertexType of
    GL_V2F: begin
      fVertexAnzahl :=  Length(PVertexV2fArray(Data)^);
      size := fVertexAnzahl*SizeOf(TVertexV2f);
    end;
    GL_V3F: begin
      fVertexAnzahl :=  Length(PVertexV3fArray(Data)^);
      size := fVertexAnzahl*SizeOf(TVertexV3f);
    end;
    GL_C4UB_V2F: begin
      fVertexAnzahl :=  Length(PVertexC4bV2fArray(Data)^);
      size := fVertexAnzahl*SizeOf(TVertexC4bV2f);
    end;
    GL_C4UB_V3F: begin
      fVertexAnzahl :=  Length(PVertexC4bV3fArray(Data)^);
      size := fVertexAnzahl*SizeOf(TVertexC4bV3f);
    end;
    GL_C3F_V3F: begin
      fVertexAnzahl :=  Length(PVertexC3fV3fArray(Data)^);
      size := fVertexAnzahl*SizeOf(TVertexC3fV3f);
    end;
    GL_N3F_V3F: begin
      fVertexAnzahl :=  Length(PVertexN3fV3fArray(Data)^);
      size := fVertexAnzahl*SizeOf(TVertexN3fV3f);
    end;
    GL_C4F_N3F_V3F: begin
      fVertexAnzahl :=  Length(PVertexC4fN3fV3fArray(Data)^);
      size := fVertexAnzahl*SizeOf(TVertexC4fN3fV3f);
    end;
    GL_T2F_V3F: begin
      fVertexAnzahl :=  Length(PVertexT2fV3fArray(Data)^);
      size := fVertexAnzahl*SizeOf(TVertexT2fV3f);
    end;
    GL_T2F_C4UB_V3F: begin
      fVertexAnzahl :=  Length(PVertexT2fC4bV3fArray(Data)^);
      size := fVertexAnzahl*SizeOf(TVertexT2fC4bV3f);
    end;
    GL_T2F_C3F_V3F: begin
      fVertexAnzahl :=  Length(PVertexT2fC3fV3fArray(Data)^);
      size := fVertexAnzahl*SizeOf(TVertexT2fC3fV3f);
    end;
    GL_T2F_N3F_V3F: begin
      fVertexAnzahl :=  Length(PVertexT2fN3fV3fArray(Data)^);
      size := fVertexAnzahl*SizeOf(TVertexT2fN3fV3f);
    end;
    GL_T2F_C4F_N3F_V3F: begin
      fVertexAnzahl :=  Length(PVertexT2fC4fN3fV3fArray(Data)^);
      size := fVertexAnzahl*SizeOf(TVertexT2fC4fN3fV3f);
    end;
  end;
 
  fVertexType := VertexType;
//HIER ist ein Fehler. ich glaub ma das der Pointer (Data) irgendwie ncih richtig
//weitergegeben wird, denn wenn ich eine extra übergabe-variable mach und das
//@vertex im prozedur-aufruf hab, dann gehts?!
  glBufferDataARB(GL_ARRAY_BUFFER, size, Data, Usage);
end;
 
//Übergibt die erhaltenen Daten an den GrakaSpeicher
procedure TVertexBufferObject.WriteBufferData(Data: array of TVertexV2f; Usage: Cardinal);
begin
  fVertexAnzahl := Length(Data);                                                //VertexAnzahl speichern (wichtig beim rendern)
  fVertexType := GL_V2F;                                                        //VertexTyp speichern (wichtig beim rendern)
  glBufferDataARB(GL_ARRAY_BUFFER, SizeOf(Data), @Data, Usage);
end;
 
//analog zu oben
procedure TVertexBufferObject.WriteBufferData(Data: array of TVertexV3f; Usage: Cardinal);
begin
  fVertexAnzahl := Length(Data);
  fVertexType := GL_V3F;
  glBufferDataARB(GL_ARRAY_BUFFER, SizeOf(Data), @Data, Usage);
end;
 
//analog zu oben
procedure TVertexBufferObject.WriteBufferData(Data: array of TVertexC4bV2f; Usage: Cardinal);
begin
  fVertexAnzahl := Length(Data);
  fVertexType := GL_C4UB_V2F;
  glBufferDataARB(GL_ARRAY_BUFFER, SizeOf(Data), @Data, Usage);
end;
 
//analog zu oben
procedure TVertexBufferObject.WriteBufferData(Data: array of TVertexC4bV3f; Usage: Cardinal);
begin
  fVertexAnzahl := Length(Data);
  fVertexType := GL_C4UB_V3F;
  glBufferDataARB(GL_ARRAY_BUFFER, SizeOf(Data), @Data, Usage);
end;
 
//analog zu oben
procedure TVertexBufferObject.WriteBufferData(Data: array of TVertexC3fV3f; Usage: Cardinal);
begin
  fVertexAnzahl := Length(Data);
  fVertexType := GL_C3F_V3F;
  glBufferDataARB(GL_ARRAY_BUFFER, SizeOf(Data), @Data, Usage);
end;
 
//analog zu oben
procedure TVertexBufferObject.WriteBufferData(Data: array of TVertexN3fV3f; Usage: Cardinal);
begin
  fVertexAnzahl := Length(Data);
  fVertexType := GL_N3F_V3F;
  glBufferDataARB(GL_ARRAY_BUFFER, SizeOf(Data), @Data, Usage);
end;
 
//analog zu oben
procedure TVertexBufferObject.WriteBufferData(Data: array of TVertexC4fN3fV3f; Usage: Cardinal);
begin
  fVertexAnzahl := Length(Data);
  fVertexType := GL_C4F_N3F_V3F;
  glBufferDataARB(GL_ARRAY_BUFFER, SizeOf(Data), @Data, Usage);
end;
 
//analog zu oben
procedure TVertexBufferObject.WriteBufferData(Data: array of TVertexT2fV3f; Usage: Cardinal);
begin
  fVertexAnzahl := Length(Data);
  fVertexType := GL_T2F_V3F;
  glBufferDataARB(GL_ARRAY_BUFFER, SizeOf(Data), @Data, Usage);
end;
 
//analog zu oben
procedure TVertexBufferObject.WriteBufferData(Data: array of TVertexT2fC4bV3f; Usage: Cardinal);
begin
  fVertexAnzahl := Length(Data);
  fVertexType := GL_T2F_C4UB_V3F;
  glBufferDataARB(GL_ARRAY_BUFFER, SizeOf(Data), @Data, Usage);
end;
 
//analog zu oben
procedure TVertexBufferObject.WriteBufferData(Data: array of TVertexT2fC3fV3f; Usage: Cardinal);
begin
  fVertexAnzahl := Length(Data);
  fVertexType := GL_T2F_C3F_V3F;
  glBufferDataARB(GL_ARRAY_BUFFER, SizeOf(Data), @Data, Usage);
end;
 
//analog zu oben
procedure TVertexBufferObject.WriteBufferData(Data: array of TVertexT2fN3fV3f; Usage: Cardinal);
begin
  fVertexAnzahl := Length(Data);
  fVertexType := GL_T2F_N3F_V3F;
  glBufferDataARB(GL_ARRAY_BUFFER, SizeOf(Data), @Data, Usage);
end;
 
//analog zu oben
procedure TVertexBufferObject.WriteBufferData(Data: array of TVertexT2fC4fN3fV3f; Usage: Cardinal);
begin
  fVertexAnzahl := Length(Data);
  fVertexType := GL_T2F_C4F_N3F_V3F;
  glBufferDataARB(GL_ARRAY_BUFFER, SizeOf(Data), @Data, Usage);
end;
 
////////////////////////////////////////////////////////////////////////////////
 
//initialisiert die direkte Eingabe in den Speicher
procedure TVertexBufferObject.InitDirectWrite(VertexCount: Integer; VertexType, Usage: Cardinal);
var Size: Integer;
begin
  fVertexAnzahl     := VertexCount;                                             //VertexAnzahl übernehmen
  fVertexType       := VertexType;                                              //VertexTyp übernehmen
  Size := 0;                                                                    //size initialisieren
  case fVertexType of                                                           //je nach Typ die größe bestimmen
                GL_V2F: Size := SizeOf(TVertexV2f);
                GL_V3F: Size := SizeOf(TVertexV3f);
           GL_C4UB_V2F: Size := SizeOf(TVertexC4bV2f);
           GL_C4UB_V3F: Size := SizeOf(TVertexC4bV3f);
            GL_C3F_V3F: Size := SizeOf(TVertexC3fV3f);
            GL_N3F_V3F: Size := SizeOf(TVertexN3fV3f);
        GL_C4F_N3F_V3F: Size := SizeOf(TVertexC4fN3fV3f);
            GL_T2F_V3F: Size := SizeOf(TVertexT2fV3f);
       GL_T2F_C4UB_V3F: Size := SizeOf(TVertexT2fC4bV3f);
        GL_T2F_C3F_V3F: Size := SizeOf(TVertexT2fC3fV3f);
        GL_T2F_N3F_V3F: Size := SizeOf(TVertexT2fN3fV3f);
    GL_T2F_C4F_N3F_V3F: Size := SizeOf(TVertexT2fC4fN3fV3f);
  end;
  glBufferDataARB(GL_ARRAY_BUFFER, fVertexAnzahl*Size, nil, Usage);             //Speicher reservieren
 
  fStartAdressPointer := glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);           //StartAdr. des reserv. Speichers holen
  fActiveAdressPointer := fStartAdressPointer;                                  //Adresse des nächsten vertex festlegen 
  fVertexCount := 0;                                                            //vertexCount initialisieren
 
  fDirectWriteInit := True;                                                     //Initialisiereung abgeschlossen --> TRUE
end;
 
//schreibt das Vertex direkt in den Speicher
function TVertexBufferObject.DirectWrite(S,T,X,Y,Z: TGLFloat): Boolean;
//Zeiger auf ein TVertexT2fV3f
var Pointer: ^TVertexT2fV3f;
begin
//HIER muss auch irgendwo der Wurm drin sein, obwohl ich mich eigentlich strikt 
//an das Tutorial gehalten hab, auch wenn ich das bisl zerstückelt hab...
 
  result := False;
  if not fDirectWriteInit           then exit;                                  //wenn noch nicht inisialisiert, dann exit
  if fVertexType <> GL_T2F_V3F      then exit;                                  //wenn nicht der korrekte vertexTyp, dann exit
  if fVertexCount >= fVertexAnzahl  then exit;                                  //wenn max. Anzahl erreicht, dann exit
 
  Pointer := fActiveAdressPointer;                                              //Pointer übergeben
  Pointer^.S := S;                                                              //Daten übernehmen
  Pointer^.T := T;
  Pointer^.X := X;
  Pointer^.Y := Y;
  Pointer^.Z := Z;
 
  inc(PInteger(fActiveAdressPointer), SizeOf(TVertexT2fV3f));                   //Pointer erhöhen, um so auf nächsten Vertex zu zeigen
  inc(fVertexCount);                                                            //VertexCounter erhöhen
 
  result := true;
end;
 
//beendet das Direkte Schreiben in den Speicher
procedure TVertexBufferObject.FinishDirectWrite;
begin
  fDirectWriteInit := False;
  glUnmapBuffer(GL_ARRAY_BUFFER);                                           
end;
 
//rendert das VBO
procedure TVertexBufferObject.Render(Mode: Cardinal);
//speicher die Größe
var Size: Integer;
begin
  Size := 0;                                                                    //initialisieren
  case fVertexType of                                                           //je nach VertexTyp größe berechnen
                GL_V2F: Size := SizeOf(TVertexV2f);
                GL_V3F: Size := SizeOf(TVertexV3f);
           GL_C4UB_V2F: Size := SizeOf(TVertexC4bV2f);
           GL_C4UB_V3F: Size := SizeOf(TVertexC4bV3f);
            GL_C3F_V3F: Size := SizeOf(TVertexC3fV3f);
            GL_N3F_V3F: Size := SizeOf(TVertexN3fV3f);
        GL_C4F_N3F_V3F: Size := SizeOf(TVertexC4fN3fV3f);
            GL_T2F_V3F: Size := SizeOf(TVertexT2fV3f);
       GL_T2F_C4UB_V3F: Size := SizeOf(TVertexT2fC4bV3f);
        GL_T2F_C3F_V3F: Size := SizeOf(TVertexT2fC3fV3f);
        GL_T2F_N3F_V3F: Size := SizeOf(TVertexT2fN3fV3f);
    GL_T2F_C4F_N3F_V3F: Size := SizeOf(TVertexT2fC4fN3fV3f);
  end;
 
  glInterleavedArrays(fVertexType, Size, nil);                                  //zeichnen
  glDrawArrays(Mode, 0, fVertexAnzahl);
end;
 
//erzeugt ein VBO
constructor TVertexBufferObject.Create;
begin
  if not GL_ARB_Vertex_Buffer_Object then                                       //wenn nich unterstützt, dann
    raise VertexBufferException.Create('VertexBuffer: not supported');          //erzeuge neue Exception
 
  inherited create;                                                             //erzeugen
 
  glGenBuffers(1, @fVertexBufferObject);                                        //VBO erzeugen
  glBindBufferARB(GL_ARRAY_BUFFER, fVertexBufferObject);                        //VBO binden
  glEnableClientState(GL_VERTEX_ARRAY);                                         //VertexArrays aktivieren
end;
 
//gibt das VBO frei
destructor TvertexBufferObject.Destroy;
begin
  glDeleteBuffers(1, @fVertexBufferObject);                                     //VBO löschen
  inherited Destroy;                                                            //Objekt freigeben
end;
 
end.

Nach oben

Lossy eX

Betreff des Beitrags:

Verfasst: Fr Jul 24, 2009 08:25

DGL Member

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

Code:

VBO.WriteBufferData(@Vertex, GL_T2F_V3F, GL_STATIC_DRAW); //geht nich, Quad wird nich gezeichnet...

Das funktioniert deswegen nicht, weil du ein dynamisches Array hast. Ein dynamisches Array ist eigentlich nur ein Pointer und die Variable Vertex zeigt in diesem Falle lediglich auf den Speicherbereich an dem sich die Daten in Wirklichkeit befinden. Wenn du also sagst @Vertex übergibst du lediglich die Adresse der Variable Vertex. Und die befindet sich auf den Stack (wo andere Variablen, Rücksprungadressen etc liegen). Und da rein zu schreiben würde mit Sicherheit sehr sehr hässlich enden. Im Falle von dem @Operator (oder auch var und const Parametern) musst du dem Kompiler bewusst sagen, dass du die Daten haben willst. Also @Vertex[0]. Damit meinst du unmissverständlich den ersten Eintrag aus dem Array. Das gleiche gilt für Strings. Das sind auch fast nur dynamische Arrays of char. Genau das Gleiche musst du auch bei Stream.Read/Write beachten.

Ich habe mir bei so etwas angewöhnt wirklich grundsätzlich IMMER genau die Stelle anzugeben die ich haben will. Selbst bei statischen Arrays wo die Variable wirklich auf den Speicher zeigt.

Zitat:

2. beim direkten schreiben in den Speicher erhalt ich beim schließen des Programms eine zugriffsverletzung. Und das Quad wird auch nich gerendert.

Die Berechnung deines Speicheroffsets ist falsch.

Code:

inc(PInteger(fActiveAdressPointer), SizeOf(TVertexT2fV3f)); //Pointer erhöhen, um so auf nächsten Vertex zu zeigen

Du setzt damit den Pointer nicht auf das nächste Vertex sondern du überspringst 3 Vertices. Inc hat eine Besonderheit. Es erhöht Zahlen um 1. Bei Pointern allerdings um die Größe des Types, auf welchen der Pointer zeigt. In deinem Falle castest du auf PInteger, damit zeigt der Pointer auf 4 Bytes Speicher und inc(PIntger) erhöht den Pointer um 4 Bytes. Würdest du auf PByte casten, dann würde der Pointer auf 1 Byte Speicher zeigen und inc(pByte) würde die Adresse nur um 1 erhöhen.

Wenn du also einen Pointer "Vertex: PVertexT2fV3f" hättest, dann würde es genügen "inc(Vertex)" zu machen. Da Inc per Default die Größe berücksichtig und um 1 erhöht landest du genau auf dem nächsten Eintrag. Kannst du die Pointer nicht so typisieren, dann musst du einen Typen benutzen der auf 1 Byte Speicher zeigt. Also "Inc(PByte(Vertex), SizeOf(TVertexT2fV3f))".

PS: Wenn du Pointer auf Records benutzt, dann solltest du diese auch direkt als Typen deklarieren. Denn wenn du Lokal eine Variable vom Typ ^Blah erstellst, dann kann es mitunter vorkommen, dass Delphi rumzickt. Entsprechend oben PBlah = ^TBlah definieren und bei Pointerbenutzung dann PBlah verwenden. Dann gibts auch keine Probleme.

Nach oben

waran

Betreff des Beitrags:

Verfasst: Fr Jul 24, 2009 09:41

DGL Member

Registriert: Mi Okt 04, 2006 15:42
Beiträge: 78
Wohnort: Bonn
Programmiersprache: Python, C++, Delphi

Soweit ich weiß wäre die Berechnung des Offsets in Delphi korrekt - unter Freepascal jedoch nicht,
da es wie C Pointerarithmetik unterstützt.

Absolut sicher wäre die Schreibweise "someFloatPointer[i]" - welche unter Delphi nicht kompilierbar ist
und unter FPC auf jeden Fall den richtigen Offset berechnet.

Nach oben

Traude

Betreff des Beitrags:

Verfasst: Fr Jul 24, 2009 10:21

DGL Member

Registriert: Di Okt 03, 2006 14:07
Beiträge: 1277
Wohnort: Wien

waran hat geschrieben:

Soweit ich weiß wäre die Berechnung des Offsets in Delphi korrekt - unter Freepascal jedoch nicht

Doch, es funktioniert in FPC auch.

Nach oben

Lossy eX

Betreff des Beitrags:

Verfasst: Fr Jul 24, 2009 13:14

DGL Member

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

waran hat geschrieben:

Soweit ich weiß wäre die Berechnung des Offsets in Delphi korrekt

Ne. Nicht, wenn man das Offset mit INC errechnet. Denn das arbeitet mit der Datengröße zusammen.

Code:

var
  I: Pointer;
begin
  I := nil;
  Inc(PInteger(I), 2); // I = 8
 
  I := nil;
  Inc(PByte(I), 2);    // I = 2
end;

waran hat geschrieben:

welche unter Delphi nicht kompilierbar ist

Ist das damit dann nicht schon wieder hinfällig?

Nach oben

Traude

Betreff des Beitrags:

Verfasst: Fr Jul 24, 2009 13:40

DGL Member

Registriert: Di Okt 03, 2006 14:07
Beiträge: 1277
Wohnort: Wien

Tschuldigung, ich habe nicht mitgekriegt, dass die ursprüngliche OffSet-Berechnung des Threadstarters gemeint war. Was ich meinte, war natürlich, dass Lossys Angaben stimmen, und sowohl in Delphi als auch in FPC funktionieren. *Inc/Dec* berücksichtigt bei typisierten Pointern immer die Größe der jeweiligen Type.

Nach oben

Lossy eX

Betreff des Beitrags:

Verfasst: Fr Jul 24, 2009 14:13

DGL Member

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

Traude hat geschrieben:

ich habe nicht mitgekriegt, dass die ursprüngliche OffSet-Berechnung des Threadstarters gemeint war.

Also wo du das jetzt so sagst bin ich mir auch ganz und gar nicht sicher was waran gemeint hatte.

Nach oben

Bergmann89

Betreff des Beitrags:

Verfasst: Fr Jul 24, 2009 16:55

DGL Member

Registriert: Di Apr 29, 2008 18:56
Beiträge: 1213
Programmiersprache: Delphi/FPC

HI,

Problem 2 wäre damit gelöst:

Code:

inc(PVertexT2fV3f(fActiveAdressPointer));

aber beim 1. Problem komm ich immer noch nich weiter. wenn ich @vertex[0] übergeb kommt ne Zugriffsverletzung...
Ich hab das genau so wie in dem Tutorial gemacht, nur das ich den Pointer meiner Daten ein Prozeduraufruf weiter oben übergeb. wenn ich die Daten ansich übergeb, un dann erst bei glBufferDataARB den Pointer gehts?! das ist aber unpraktich, weil ich dann die 12 verschiedenen Prozeduren brauche und das wollt ich mit der Pointer-Sache eig. umgehen...

MfG Bergmann.

Nach oben

Lossy eX

Betreff des Beitrags:

Verfasst: Fr Jul 24, 2009 17:18

DGL Member

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

Es kann sein, dass sich das Array genau an dieser Stelle rächt. Denn die Informationen des Arrays liegen nicht bei den Daten. Auf der einen Seite musst du den Pointer der Daten übergeben und auf der anderen Seite brauchst du auch die Nutzdaten des Arrays. Also die Länge.

Alternativ würde mir einfallen, dass du den Pointer auf die Daten übergibst und zusätzlich die Länge (Anzahl Vertices) als Parameter. In der Methode rechnest du dann noch die Größe aus und übergibst das. Sollte ausreichen.

Nach oben

Seite 1 von 1

[ 9 Beiträge ]

Foren-Übersicht » Programmierung » Einsteiger-Fragen

Wer ist online?

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