DGL • Thema anzeigen - 2D_Textur_Animation

2D_Textur_Animation_Hilfe!

Moderator: DGL-Team

Seite 1 von 2

[ 18 Beiträge ]

Gehe zu Seite 1, 2 Nächste

Vorheriges Thema | Nächstes Thema

Autor

Nachricht

Anubis

Betreff des Beitrags: 2D_Textur_Animation_Hilfe!

Verfasst: Mi Jul 26, 2006 13:06

DGL Member

Registriert: Mi Jul 26, 2006 12:35
Beiträge: 15

Hallo,

Ich habe folgendes Problem:

Ziel: Ich möchte eine Animation aus 24 verschiedenen Einzelbildern auf einem Qaud anzeigen lassen.

Ich weiß zwar wie ich eine Einzeltextur laden und darstellen kann jedoch nicht wie ich

a) alle Texturen in den Speicher bzw. in ein Array bekomme
b) sie zeitlich in einer endlosschleife abspielen kann.

Code:

 
unit TEX;
 
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs,SDL,dglOpenGL,sdl_image,Logger, ExtCtrls;
 
type
  TForm1 = class(TForm)
 
 
 
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;
 
CONST    WINDOWS_CAPTION     =       'Animated Texture';
 
    SCREEN_WIDTH        = 800;
    SCREEN_HEIGHT       = 600;
    SCREEN_BPP          = 32;
 
    FPS_INTERVAL        = 1000;               // Jede Sekunde FPS berechnen
 
    INVALID_MODULEHANDLE = 0;
var
 
    Form1: TForm1;
    surface     : PSDL_Surface;
    videoInfo   : PSDL_VideoInfo;
    videoflags  : Uint32;
    done        : Integer;                    // Programmstatus : 0 Default -1 Programmabruch
    FPSCount    : LongInt;
    GLHandle: HINST;
    GLUHandle: HINST;
    tex_surface :  PSDL_Surface;
    texture : array[1..24] of gluInt;
 
 
implementation
 
{$R *.dfm}
 
 
 
function IntToStr(Num : Integer) : String;
begin
  Str(Num, result);
end;
 
 
 
//----------------------------------------------------------------------------
// Zeichnen der Szene
//----------------------------------------------------------------------------
procedure glDrawScene;
begin
  // Screen- und Tiefenbuffer bereinigen
  glClear( GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT );
  glLoadIdentity;
  glTranslatef( 0.0, 0.0, -5.0 );
  glMatrixMode(GL_TEXTURE);
   glLoadIdentity;
  glMatrixMode(GL_MODELVIEW);
 
  glEnable(GL_TEXTURE_2D);
  glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_REPLACE);
glBindTexture(GL_TEXTURE_2D, texture);
 glBegin( GL_QUADS );
 glTexCoord2f(0,0);
    glVertex3f( -1.0, 1.0, 0.0 );
 glTexCoord2f(1,0);
    glVertex3f( 1.0, 1.0, 0.0 );
 glTexCoord2f(1,1);
    glVertex3f( 1.0, -1.0, 0.0 );
 glTexCoord2f(0,1);
    glVertex3f( -1.0, -1.0, 0.0 );
 glEnd();
 glFlush();
 glDisable(GL_TEXTURE_2D);
  // Buffer-Wechseln ==> Anzeigen
  SDL_GL_SwapBuffers;
end;
 
//----------------------------------------------------------------------------
// Terminieren der SDL-Anwendung
//----------------------------------------------------------------------------
procedure Quit_App;
  procedure CloseOpenGL;
  begin
    if GLHandle <> INVALID_MODULEHANDLE then
    begin
      FreeLibrary(Cardinal(GLHandle));
      GLHandle := INVALID_MODULEHANDLE;
    end;
 
    if GLUHandle <> INVALID_MODULEHANDLE then
    begin
      FreeLibrary(Cardinal(GLUHandle));
      GLUHandle := INVALID_MODULEHANDLE;
    end;
 
//    ClearProcAddresses;
    ClearExtensions;
  end;
begin;
  // Freigeben der Ressourcen
  SDL_QUIT;
  CloseOpenGL;
  Halt(0);
end;
 
(******************************************************************************)
(******************************************************************************)
//  Events
(******************************************************************************)
(******************************************************************************)
 
//----------------------------------------------------------------------------
// Behandelt Größenveränderung des Fensters
//----------------------------------------------------------------------------
function glResizeWindow( width : integer; height : integer ) : Boolean;
begin
  // Verhindern von "Division by Zero"
  if ( height = 0 ) then height := 1;
 
  // Viewport und Projektions-Matrix aktualisieren
  glViewport( 0, 0, width, height );
 
  glMatrixMode( GL_PROJECTION );
    glLoadIdentity;
    gluPerspective( 45.0, width / height, 0.1, 100.0 );
  glMatrixMode( GL_MODELVIEW );
 
  // Rücksetzen der World-Matrix
  glLoadIdentity;
 
  // Vorgang erfolgreich
  result := true;
end;
 
//----------------------------------------------------------------------------
// Tastatur Eingaben verarbeiten
//----------------------------------------------------------------------------
procedure glHandleKeyPress( keysym : PSDL_keysym );
begin;
  case keysym.sym of
    SDLK_ESCAPE : done := -1;
  end;
end;
 
//----------------------------------------------------------------------------
// Timer-Event für FPS-Berechnung
//----------------------------------------------------------------------------
function glTimer( interval : UInt32; param : Pointer ) : UInt32;
begin;
    SDL_WM_SetCaption(pChar( WINDOWS_CAPTION + ' ['+IntToStr(Round(FPSCount * 1000/FPS_INTERVAL))+' FPS]') , nil);
    FPSCount := 0;
    Result := interval;
end;
 
//----------------------------------------------------------------------------
// Reagieren auf Programm_Events
//----------------------------------------------------------------------------
procedure glHandleEvents;
var event       : TSDL_Event;
begin;
    // Verarbeiten der Events
    while ( SDL_PollEvent( @event ) = 1 ) do
    begin
      case event.type_ of
 
        // Beenden der Applikation
        SDL_QUITEV :
        begin
          Done := -1;
        end;
 
        // Taste wurde gedrückt
        SDL_KEYDOWN :
        begin
          glHandleKeyPress( @event.key.keysym );
        end;
 
        // Fenster-Größe hat sich verändert
        SDL_VIDEORESIZE :
        begin
          surface := SDL_SetVideoMode( event.resize.w, event.resize.h, SCREEN_BPP, videoflags );
 
          if ( surface = nil ) then
          begin
            Log.LogError('Surface bei Größenänderung verloren: '+SDL_GetError,'EVENT_RESIZE' );
            Quit_App;
          end;
 
          glResizeWindow( event.resize.w, event.resize.h );
        end;
      end;
    end;
end;
 
(******************************************************************************)
(******************************************************************************)
//  Initalisierung
(******************************************************************************)
(******************************************************************************)
 
//----------------------------------------------------------------------------
// Die Daten eines Objektes.
//----------------------------------------------------------------------------
procedure Init_OpenGL;
begin;
    // Laden und Initalisieren von OpenGL
//    LoadOpenGL;
 
 
    InitOpenGL;
 
 //   ActivateRenderingContext(
    ReadExtensions;
 
    // Ausganswerte für die State-Machine setzen
    glEnable(GL_TEXTURE_2D);                    // Aktiviert Texture Mapping
    glShadeModel(GL_SMOOTH);                    // Aktiviert weiches Shading
    glClearColor(0.0, 0.0, 0.0, 0.5);         // Bildschirm löschen (schwarz)
    glClearDepth(1.0);                          // Depth Buffer Setup
    glEnable(GL_DEPTH_TEST);                    // Aktiviert Depth Testing
    glDepthFunc(GL_LEQUAL);                   // Bestimmt den Typ des Depth Testing
    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
                                              // Qualitativ bessere Koordinaten Interpolation
end;
 
//----------------------------------------------------------------------------
// Initialisierung von Simple DirectMedia Layer
//----------------------------------------------------------------------------
procedure Init_SDL;
begin;
  // Initalisieren vom Simple DirectMedia Layer
  if ( SDL_Init( SDL_INIT_VIDEO ) < 0 ) then
  begin
    Log.LogError('Initalisierung von SDL schlug fehl: '+SDL_GetError,'SDL_Init');
    Quit_App;
  end;
 
  // Information über Grafikkarte einholen
  videoInfo := SDL_GetVideoInfo;
  if ( videoInfo = nil ) then
  begin
    Log.LogError('Grafikkarte liess sich nicht abfragen: '+SDL_GetError,'SDL_Init' );
    Quit_App;
  end;
 
  // Flags für den SDL-Grafikmodus setzen
  videoFlags := SDL_OPENGL or                  // OpenGL-Unterstützung aktivieren
                SDL_DOUBLEBUF or               // Double Buffering aktivieren
                SDL_HWPALETTE;                 // Palette in Hardware speichern
 
  // Kann die Surface in den Speicher?
  if ( videoInfo.hw_available <> 0 ) then
    videoFlags := videoFlags or SDL_HWSURFACE
  else
    videoFlags := videoFlags or SDL_SWSURFACE;
 
  // Wird hardware blitting unterstützt?
  if ( videoInfo.blit_hw <> 0 ) then videoFlags := videoFlags or SDL_HWACCEL;
 
  // Setzen der OpenGL-Attribute
  SDL_GL_SetAttribute( SDL_GL_RED_SIZE, 5 );
  SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, 5 );
  SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, 5 );
  SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, 16 );
  SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
 
  // Fenstertitel festlegen
  SDL_WM_SetCaption( WINDOWS_CAPTION , nil);
  videoflags := videoFlags or SDL_RESIZABLE;    // Enable window resizing
 
  // Initalisierung der Surface
  surface := SDL_SetVideoMode( SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP,videoflags );
  if ( surface = nil ) then
  begin
    Log.LogError('Erzeugen einer OpenGL-Zeichenfläche schlug fehl: '+SDL_GetError,'SDL_Init' );
    Quit_App;
  end;
 
  // Initalisierung des Timers
SDL_Init(SDL_INIT_TIMER);
 
 
 
 
 
 
 
 
end;
 
(******************************************************************************)
(******************************************************************************)
//  Hauptprogramm
(******************************************************************************)
(******************************************************************************)
 
begin
  // Initalisierung
  Init_SDL;
  Init_OpenGL;
 
  // Setzen eines Timers für FPS-Berechnung
  SDL_AddTimer(1000,@glTimer,nil);
 
  // Anpassen der Fenstergröße
  glResizeWindow( SCREEN_WIDTH, SCREEN_HEIGHT );
 
          tex_surface := IMG_Load('Doc40000.tga');
if assigned(tex_surface) then
begin
  glGenTextures(1, @texture);
  glBindTexture(GL_TEXTURE_2D, texture);
  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, tex_surface^.w, tex_surface^.h,0, GL_RGB, GL_UNSIGNED_BYTE, tex_surface^.pixels);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  SDL_FreeSurface(tex_surface);
end;
 
 
  // Eintritt in Main-Loop
  while ( Done <> -1 ) do
  begin
    glHandleEvents;
    glDrawScene;
    Inc(FPSCount);
  end;
 
  Quit_App;
 
end.
 
 
 
 

Nach oben

The-Winner

Betreff des Beitrags:

Verfasst: Mi Jul 26, 2006 13:11

DGL Member

Registriert: Di Jun 06, 2006 09:59
Beiträge: 474

Ich würde dabei eher zu einer großen Textur tendieren und dann die Texturmatrix verändern. Dabei musst du dann aber möglicherweise um jedes Einzelbild einen 1-Pixel breiten Rahmen zeichnen, bei dem jeder pixel die farbe des benachbarten Pixels der noch im BIld ist hat. Diesen Rahmen dann aber nicht in den Auswahlrahmen des entsprechenden Einzelbilds integrieren.

Nach oben

Anubis

Betreff des Beitrags:

Verfasst: Mi Jul 26, 2006 14:36

DGL Member

Registriert: Mi Jul 26, 2006 12:35
Beiträge: 15

Eigentlich wollte ich nur wissen wie ich den obrigen Code umschreiben muss, trozdem danke!
kennt zufällig irgendwer ein Programm mit dennen ich meine 24 256 * 256 großen Einzeltexturen in eine , wie oben
beschriebene, große Textur bekomme?

Nach oben

Evil-Devil

Betreff des Beitrags:

Verfasst: Mi Jul 26, 2006 14:41

DGL Member

Registriert: Di Sep 03, 2002 15:08
Beiträge: 662
Wohnort: Hamburg
Programmiersprache: Java, C# (,PhP)

Kann man nicht eine 3D Texture nehmen die 24 Ebenen hat?

_________________
(\__/)
(='.'=)
(")_(")

Nach oben

i0n0s

Betreff des Beitrags:

Verfasst: Mi Jul 26, 2006 15:00

Ernährungsberater

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

Hier ist ein entsprechendes Beispiel aus dem DGLSDK:
Link
Nur wird alles aus einer Textur geladen, das sollte aber weniger das Problem sein.

Nach oben

Lossy eX

Betreff des Beitrags:

Verfasst: Mi Jul 26, 2006 15:32

DGL Member

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

Bei 3D Texturen müsstest du schon 32 Ebenen haben. Und 3D Texturen müssten von der Hardware auch unterstützt werden.

Alles in eine Textur halte ich bei einer Animation nicht für Sinnvoll, da normal nur ein Bild der Animation aktuell dargestellt werden müsste. Und bei solche krummen Bilderanzahlen (24) bekommt man leicht schwierigkeiten. Überdimensionaler Programmieraufwand oder unnötige Speicherverschwendung.

Für von deinen Texturen bräuchtest du 2 Texturen um keinen Speicher zu verbrauchen aber ich denke dieser zusätzlich Aufwand ist die Mühe nicht Wert. Vor allem wenn man bedenkt, dass diese 1 Texturlösung nur dafür da ist Texturswitches zu vermeiden. Was bei extremen gebrauch performance schluckt. Aber in dem falle einer Animation sieht man höchstwahrscheinlich eh nur ein Bild pro Frame.

Das Laden deiner Animation würde ich so gestalten, dass du dies in eine Methode auslagerst und ihr einen Dateinamen übergibst.

Code:

procedure LoadAniFrame(var Animation: array of gluInt; const filename: String);
var
  tex_surface : PSDL_Surface;
  Temp: gluInt;
begin
  // Bild laden
  tex_surface := IMG_Load('Doc40000.tga');
  if assigned(tex_surface) then begin
    glGenTextures(1, @Temp);
    glBindTexture(GL_TEXTURE_2D, Temp);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, tex_surface^.w, tex_surface^.h,0, GL_RGB, GL_UNSIGNED_BYTE, tex_surface^.pixels);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    SDL_FreeSurface(tex_surface);
 
    // In Animationsarray einfügen
    SetLength(Animation, Length(Animation) +1);
    Animation[High(Animation)] := Temp;
  end;
end;

Das Array wird dann definiert als dynamisches Array.

Code:

Ani: array of gluInt;

Und geladen wird dann so.

Code:

LoadAniFrame(Ani, 'Doc40000.tga');
LoadAniFrame(Ani, 'Doc40001.tga');
LoadAniFrame(Ani, 'Doc40002.tga');
LoadAniFrame(Ani, 'Doc40003.tga');

Wenn alles so klappt sollte er automatisch einzelne Einträge hinzufügen und das Array entsprechend erweitern. Aber um Ehrlich zu sein ist das alles andere als Sauber. Um ehrlich zu sein würde sich für eine Animation am Besten eine Klasse anbieten die sich dann auch automatisch um die Bildauswahl etc kümmert. Aber für den Anfang sollte das oben genug sein.

PS: Ich übernehme für den Code keine Garantie habe de4n nur mal eben so runter geschrieben.

Nach oben

Evil-Devil

Betreff des Beitrags:

Verfasst: Mi Jul 26, 2006 15:43

DGL Member

Registriert: Di Sep 03, 2002 15:08
Beiträge: 662
Wohnort: Hamburg
Programmiersprache: Java, C# (,PhP)

Wieso muss eine 3D Texture 32 Ebenen haben?

_________________
(\__/)
(='.'=)
(")_(")

Nach oben

Phobeus

Betreff des Beitrags:

Verfasst: Mi Jul 26, 2006 16:00

Fels i.d. Brandung

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

Die 2er-Potenz gilt auch noch in der dritten Dimension

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

Nach oben

Evil-Devil

Betreff des Beitrags:

Verfasst: Mi Jul 26, 2006 16:14

DGL Member

Registriert: Di Sep 03, 2002 15:08
Beiträge: 662
Wohnort: Hamburg
Programmiersprache: Java, C# (,PhP)

Phobeus hat geschrieben:

Die 2er-Potenz gilt auch noch in der dritten Dimension

Ah ok, verstehe. Und was ist dann die maximal Größe derzeit die UNterstützt wird. AUch 1024? Oder eher nicht?
(Wer würde überhaupt 1024 Lagen nutzen?)

_________________
(\__/)
(='.'=)
(")_(")

Nach oben

Lossy eX

Betreff des Beitrags:

Verfasst: Do Jul 27, 2006 08:10

DGL Member

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

Also laut delphi3d.net geht es bei ATI bis 2048³ und bei NVidia aktuell sogar nur bis 512³. Du musst auch bedenken, dass dabei eine ganze schöne Menge an Speicher belegt wird. Wenn ich gerade nicht zu blöd zum Rechnen bin wird bei einer 512x512x512x4 Bytes per Pixel großen Textur auch schon eben mal 512MB an Speicher an verbraten. Also wenn man diese vollständig ausnutzt. Und viel Karten haben nur 256 und dann müssen dort die ganzen Buffer etc noch mit rein. Bei 2048 wäre man eben bei 32GB. Also ich denke mal nicht, dass man das wirklich ausnutzen kann. Das ist nur das was die Geräte maximal verarbeiten können. Aber man wird nie die volle Auflösung benutzen können.

PS: Bei 1D Texturen besteht diese PowerOfTwo Beschränkung selbstverständlich auch. ;-)

Nach oben

Evil-Devil

Betreff des Beitrags:

Verfasst: Do Jul 27, 2006 08:39

DGL Member

Registriert: Di Sep 03, 2002 15:08
Beiträge: 662
Wohnort: Hamburg
Programmiersprache: Java, C# (,PhP)

Hehe, das man es nicht ausnützen würde war mir vorher klar. Intessierte mich nur wie viel man reinpacken könnte. Mehr als 4 oder 8 Lagen in einer 3D Texture sieht man selten. In den kommenden Spielen wird sich dies sicher auf bis zu 16 erhöhen oder aber die wenden irgendwelche Tricks an bei all den Texture Effekten. Bestes Beispiel die UE3 mit ihrem neuen Texture Layer System das ähnlich wie ein Scenegraph aufgebaut ist. Jedenfalls in der rein visuellen Darstellung. Wie die das intern lösen würd mich schon sehr interessieren.
http://www.unrealtechnology.com/screens ... Editor.jpg

_________________
(\__/)
(='.'=)
(")_(")

Nach oben

Lossy eX

Betreff des Beitrags:

Verfasst: Do Jul 27, 2006 09:22

DGL Member

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

3D Texturen sind noch zu viel mehr gut. Zum Beispiel machst du eine Textur die aussieht wie ein Material (Holz) und dein Mesh würde dann aussehen als sei es aus eben diesem Holz geschnitzt worden. Bzw beim Verändern wäre de Effekt dann richtig klasse. 3D Visualisierung von irgendwelchen medizinischen Scanns. Oder für 3D Lichteffekte kann man solche Texturen auch schon benutzen. Ursprünglich wurde diese Textur nicht dazu gebaut damit mal einzelne Layer in eine Textur verpacken kann. Sondern halt für echte 3D Texture. Aber das ist leider extrem Speicherintensiv.

Ich denke aber wir triften gerade ein bisschen vom Ursprungsthema ab. ;-)

Nach oben

Phobeus

Betreff des Beitrags:

Verfasst: Do Jul 27, 2006 10:16

Fels i.d. Brandung

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

Zumal wir ja auch erstmal bis zu 8 TU haben, die wir für die meisten dieser Effekte (insbesondere mit Shadern) ja wunderbar ausnutzen können, insbesondere dann auch, wenn man die Pow2 nicht ausnutzen kann. Nichtsdesto trotz will der Fragesteller ja eine 2D-Animation machen und da ist das nutzen von Texturkoordinaten die beste Lösung. Insbesondere, wenn die Sprites auch nicht der Pow2-Regel entsprechen.

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

Nach oben

Anubis

Betreff des Beitrags:

Verfasst: Do Jul 27, 2006 10:28

DGL Member

Registriert: Mi Jul 26, 2006 12:35
Beiträge: 15

Ich glaube ich als der Fragesteller sollte mich mal wieder zu Wort melden.

Eigentlich wollte ich nur meine 24 Frames die ich mit meinem 3D-Programm gerendert habe innerhalb einer Sekunde
ablaufen lassen und das in einer Endlosschleife. (24 Frames deswegen damit es nach einer flüssigen Animation
aussieht). Ich kann die Bilder natürlich nochmal rendern mit weniger Frames und. Gibt es eigentlich irgendein 2D Grafikprogramm mit dem ich die Bilder in eine Einzeltextur packen kann?
Was denn Code von Lossy eX angehet, danke aber ich hab warscheinlich irgendwas falsch gemacht, jedfalls gehts
nicht: Fehlermeldung Inkompatible Dateitypen.

Nach oben

Lossy eX

Betreff des Beitrags:

Verfasst: Do Jul 27, 2006 10:59

DGL Member

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

Zu dem Code. Das habe ich eben nur mal so hier im Forum getippt. Im Endeffekt kannst du es so gesatlten wie du möchtest. Ich wollte damit nur das prinzip verdeutlichen. Also eine Methode die automatisch ein Bild lädt und diese als Animationsframe in dein Array hinzufügt. So wie ich das da gemacht hatte ist das eine Möglichkeit von vielen. Du darfst natürlich das Array direkt ansprechen (also nicht mehr übergeben) oder was auch immer dein Herz begehrt. Und zu dem Fehler. Es wäre interessant zu erfahre wo der Fehler auftritt. Die Meldung alleine hilft uns nicht viel.

Als Grafikprogramm kann ich dir nur Gimp empfehlen. Es ist OpenSource und muss sich vor kostenplichtigen Produkten keineswegs verstecken.

Nach oben

Seite 1 von 2

[ 18 Beiträge ]

Gehe zu Seite 1, 2 Nächste

Foren-Übersicht » Programmierung » Einsteiger-Fragen

Wer ist online?

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