Unterschied zwischen dynamischen und statischen Array ??

[Corpsman]

Hi Leuts,

Ich hab folgendes Gecooded

Delphi-Quellcode:

Function LoadAplhaSourceTexture(Maskname, Filename: String): Gluint;
Var
  a: Array[0..127] Of Array[0..127] Of Array[0..3] Of byte;
  c: Array Of Array Of Array Of byte;
  i, j: Integer;
  b, b2: Tbitmap;
Begin
  b2 := TBitmap.create;
  b2.LoadFromFile(Filename);
  b := TBitmap.create;
  b.LoadFromFile(Maskname);
  setlength(c, 128, 128, 4);
  For i := 0 To high(a) Do
    For j := 0 To high(a[0]) Do Begin
      a[j, i, 0] := getrvalue(b2.canvas.pixels[i, 127 - j]);
      a[j, i, 1] := getgvalue(b2.canvas.pixels[i, 127 - j]);
      a[j, i, 2] := getbvalue(b2.canvas.pixels[i, 127 - j]);
      If b.Canvas.pixels[i, 127 - j] = clblack Then Begin
        a[j, i, 3] := 255;
      End
      Else Begin
        a[j, i, 3] := 0;
      End;
      c[j, i, 0] := a[j, i, 0];
      c[j, i, 1] := a[j, i, 1];
      c[j, i, 2] := a[j, i, 2];
      c[j, i, 3] := a[j, i, 3];
    End;
  glGenTextures(1, @Result);
  glBindTexture(GL_TEXTURE_2D, result);
  glEnable(GL_TEXTURE_2D);
  glTexParameteri(gl_texture_2d, GL_GENERATE_MIPMAP_SGIS, GL_TRUE);
  glTexParameteri(gl_texture_2d, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
  glTexParameteri(gl_texture_2d, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR);

  //                                      Höhe                    Format der Quelldaten
  //                                       ||            Breite            ||
  //                                       ||              ||              ||

  gluBuild2DMipmaps(gl_Texture_2d, GL_RGBA, high(a) + 1, high(a[0]) + 1, GL_RGBA, GL_UNSIGNED_BYTE, @a);
  //  gluBuild2DMipmaps(gl_Texture_2d, GL_RGBA, 128, 128, GL_RGBA, GL_UNSIGNED_BYTE, @c[0, 0, 0]);
  setlength(c, 0, 0, 0);
  b.free;
  b2.free;
End;

Eigentlich sollte man meinen das es Egal ist ob ich gluBuild2DMipmaps mit a oder mit C aufrufe.

Leider ist dies aber nicht der Fall, nur wenn ich es mit a aufrufe gehts. Im fall mit C kommt absoluter schwachsinn raus.

Kann mir jemand sagen warum, oder noch besser wies richtig geht ? Denn auf dauer will ich natürlich die Variante mit c nehmen, da die ja dynamisch ist.

Mit Getmem hab ichs auch schon Probiert, da kommt aber jedesmal ne Exception wenn ich dann das Array befüllen will.

Weis jemand wie man das mit Getmem machen würde ?

[Khabarakh]

Dynamisch- Array-Variablen sind bereits Zeiger, benutze deshalb einen Zeiger auf das erste Element: @c[0, 0, 0]

[mkinzler]

c ist schon ein Zeiger

[Corpsman]

hab ich doch

Delphi-Quellcode:

gluBuild2DMipmaps(gl_Texture_2d, GL_RGBA, 128, 128, GL_RGBA, GL_UNSIGNED_BYTE, @c[0, 0, 0]);

Der Rechner Lädt ja die Graphik auch, nur eben lädt er totalen müll mir scheint das die Bytes in falscher Reihenfolge im Speicher stehn, oder so was.

[himitsu]

dynamische Arrays sind Zeiger, demnach sind die Unterarrays dieses auch :zwinker:

Delphi-Quellcode:

c: Array Of Array Of Array Of byte;

Delphi-Quellcode:

type c2 = Array Of byte;
type c1 = Array Of c2;
var c: Array Of c1;

die ganzen unterarrays (c2) liegen also beim dynamischen Array nicht hintereinander, da für jedes dynamische array ein eigener Speicherblock resserviert wird.
Stell dir C einfach so vor:

Delphi-Quellcode:

type c2 = Array Of byte;
type c1 = Array Of Pointer{@c2};
var c: Array Of Pointer{@c1};

demnach ist @c[0, 0, 0] nur ein Zeiger auf c[0, 0, 0] bis c[0, 0, ende].
du ließt also nur einen ArrayTeil aus, nämlich c[0, 0] und nachfolgend 'ne Menge Bytes, welche nicht zu deinem Array gehören müssen (halt "undefinierten" Speicher).


[add]
wenn du eine dynamisch Größe brauchst, dann kommst du am einfachsten wenn du nur ein dynamisches Array nimmst und dessen Speicher selber einteilst.

z.B.: (ungetestet, aber ich denk mal es stimmt)

Delphi-Quellcode:

Function LoadAplhaSourceTexture(Maskname, Filename: String): Gluint; 
Var 
  a: packed Array Of Record  r, g, b, a: Byte;  end; 
  i, j: Integer; 
  b, b2: Tbitmap; 
const
  x = 128;
  y = 128;
Begin 
  b2 := TBitmap.create; 
  b2.LoadFromFile(Filename); 
  b := TBitmap.create; 
  b.LoadFromFile(Maskname); 
  setlength(c, x * y); 
  For i := 0 To high(a) Do 
    For j := 0 To high(c[0]) Do Begin 
      a[j * y + i].r := getrvalue(b2.canvas.pixels[i, y - 1 - j]); 
      a[j * y + i].g := getgvalue(b2.canvas.pixels[i, y - 1 - j]); 
      a[j * y + i].b := getbvalue(b2.canvas.pixels[i, y - 1 - j]); 
      If b.Canvas.pixels[i, y - 1 - j] = clblack Then a[j * y + i].a := 255
      Else a[j * y + i].a := 0; 
    End; 
  glGenTextures(1, @Result); 
  glBindTexture(GL_TEXTURE_2D, Result); 
  glEnable(GL_TEXTURE_2D); 
  glTexParameteri(gl_texture_2d, GL_GENERATE_MIPMAP_SGIS, GL_TRUE); 
  glTexParameteri(gl_texture_2d, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); 
  glTexParameteri(gl_texture_2d, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR); 
  gluBuild2DMipmaps(gl_Texture_2d, GL_RGBA, x, y, GL_RGBA, GL_UNSIGNED_BYTE, @a[0]); 
  a := nil;  // SetLength(a, 0);
  b.free; 
  b2.free; 
End;

PS: high(a) + 1 = Length(a)

[Khabarakh]

Zitat:

Zitat von Corpsman

hab ich doch

:duck:
Um das von himitsu beschriebene Verhalten zu umgehen, musst du wohl oder übel ein eindimensionales Array mit dem Produkt der ursprünglichen Dimensionsgrößen als neue Größe erstellen und den Index entsprechend errechnen. Zur Erleichterung würde ich allerdings kein Array of Byte sondern of TColor/TRGBQuad/wasauchimmerpasst benutze

[Corpsman]

Über Geil,

Danke, ist immer wieder schön wenn einem Geholfen wird, und das dann auch noch so schnell ;)

übrigens Hier die Lösung :

Delphi-Quellcode:

Function LoadAplhaSourceTexture(Maskname, Filename: String): Gluint;
Var
  a: Array[0..127] Of Array[0..127] Of Array[0..3] Of byte;
  c: Array Of Array[0..3] Of byte;
  i, j: Integer;
  b, b2: Tbitmap;
Begin
  b2 := TBitmap.create;
  b2.LoadFromFile(Filename);
  b := TBitmap.create;
  b.LoadFromFile(Maskname);
  setlength(c, 128 * 128);
  For i := 0 To high(a) Do
    For j := 0 To high(a[0]) Do Begin
      a[j, i, 0] := getrvalue(b2.canvas.pixels[i, 127 - j]);
      a[j, i, 1] := getgvalue(b2.canvas.pixels[i, 127 - j]);
      a[j, i, 2] := getbvalue(b2.canvas.pixels[i, 127 - j]);
      If b.Canvas.pixels[i, 127 - j] = clblack Then Begin
        a[j, i, 3] := 255;
      End
      Else Begin
        a[j, i, 3] := 0;
      End;
      c[j * 128 + i, 0] := a[j, i, 0];
      c[j * 128 + i, 1] := a[j, i, 1];
      c[j * 128 + i, 2] := a[j, i, 2];
      c[j * 128 + i, 3] := a[j, i, 3];
    End;
  glGenTextures(1, @Result);
  glBindTexture(GL_TEXTURE_2D, result);
  glEnable(GL_TEXTURE_2D);
  glTexParameteri(gl_texture_2d, GL_GENERATE_MIPMAP_SGIS, GL_TRUE);
  glTexParameteri(gl_texture_2d, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
  glTexParameteri(gl_texture_2d, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR);

  //                                      Höhe                    Format der Quelldaten
  //                                       ||            Breite            ||
  //                                       ||              ||              ||
//  gluBuild2DMipmaps(gl_Texture_2d, GL_RGBA, high(a) + 1, high(a[0]) + 1, GL_RGBA, GL_UNSIGNED_BYTE, @a);
  gluBuild2DMipmaps(gl_Texture_2d, GL_RGBA, 128, 128, GL_RGBA, GL_UNSIGNED_BYTE, @c[0]);
  setlength(c, 0);
  b.free;
  b2.free;
End;

[himitsu]

hatte oben noch was nacheditiert und eben eure antworten entdeckt ^^
> http://www.delphipraxis.net/internal...=721123#721123

[DP-Maintenance]

Dieses Thema wurde von "Matze" von "Programmieren allgemein" nach "Sonstige Fragen zu Delphi" verschoben.
Hier geht es speziell um Delphi.