[FMX]3D Material Layer

[Union]

Ich krieg es einfach nicht hin: Ich will einen farbigen 3D-Würfel erstellen, und auf diesem eine zusätzliche Textur, evtl. sogar noch unterschiedlich für jede der 6 Seiten.

Ich bekomme nur eines von beiden hin Wäre für jeden Denkanstoß äußert dankbar.

[Darlo]

Ich hatte mal zum Test drei sich drehende 3D-Würfel gebaut die jeweils ein anderes Bild als Textur drauf hatten.
Habe den Code aus einem Tutorial, die Kommentare stehen auch noch drin. Leider kann ich den Urheber des urspünglichen Codes nicht nennen

Ist von mir aber wirklich quick and dirty umgebaut....

Delphi-Quellcode:

unit wuerfel3D;

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  Direct3D8, d3dx8, ExtCtrls, StdCtrls;

const

  CubeCount = 36;

type
// Unsere Struktur, in der wir die Dreiecke speichern
  TMyVertex = record
    x,y,z     : single;   // Position des Vertex
    color     : dword;    // Farbe des Vertex
    tu,tv     : single;   // Die Koordinaten der Textur
    end;

  // Vertexliste für Würfel
  TCube = array [0..CubeCount-1] of TMyVertex;

const
// Beschreibung des Vertextyps: Mit D3DFVF_DIFFUSE sagen wir DX, das unsere
// Struktur eine Farbe hat. D3DFVF_XYZ bedeutet, das es sich um ein untransformiertes
// Vertex handelt
  D3D8T_CUSTOMVERTEX =D3DFVF_XYZ or D3DFVF_DIFFUSE or D3DFVF_TEX1;

  NormCube : TCube = (
    (x :-1.0; y :-1.0; z :-1.0; color : $000000FF; tu : 0; tv : 1),  // Vorn
    (x :-1.0; y : 1.0; z :-1.0; color : $000000FF; tu : 0; tv : 0),
    (x : 1.0; y : 1.0; z :-1.0; color : $000000FF; tu : 1; tv : 0),
    (x : 1.0; y : 1.0; z :-1.0; color : $000000FF; tu : 1; tv : 0),
    (x : 1.0; y :-1.0; z :-1.0; color : $000000FF; tu : 1; tv : 1),
    (x :-1.0; y :-1.0; z :-1.0; color : $000000FF; tu : 0; tv : 1),

    (x :-1.0; y :-1.0; z : 1.0; color : $00FF00FF; tu : 0; tv : 1),  // Links
    (x :-1.0; y : 1.0; z : 1.0; color : $00FF00FF; tu : 0; tv : 0),
    (x :-1.0; y : 1.0; z :-1.0; color : $00FF00FF; tu : 1; tv : 0),
    (x :-1.0; y : 1.0; z :-1.0; color : $00FF00FF; tu : 1; tv : 0),
    (x :-1.0; y :-1.0; z :-1.0; color : $00FF00FF; tu : 1; tv : 1),
    (x :-1.0; y :-1.0; z : 1.0; color : $00FF00FF; tu : 0; tv : 1),

    (x : 1.0; y :-1.0; z : 1.0; color : $0000FF00; tu : 0; tv : 1),  // Hinten
    (x : 1.0; y : 1.0; z : 1.0; color : $0000FF00; tu : 0; tv : 0),
    (x :-1.0; y : 1.0; z : 1.0; color : $0000FF00; tu : 1; tv : 0),
    (x :-1.0; y : 1.0; z : 1.0; color : $0000FF00; tu : 1; tv : 0),
    (x :-1.0; y :-1.0; z : 1.0; color : $0000FF00; tu : 1; tv : 1),
    (x : 1.0; y :-1.0; z : 1.0; color : $0000FF00; tu : 0; tv : 1),

    (x : 1.0; y :-1.0; z :-1.0; color : $0000FFFF; tu : 0; tv : 1),  // Rechts
    (x : 1.0; y : 1.0; z :-1.0; color : $0000FFFF; tu : 0; tv : 0),
    (x : 1.0; y : 1.0; z : 1.0; color : $0000FFFF; tu : 1; tv : 0),
    (x : 1.0; y : 1.0; z : 1.0; color : $0000FFFF; tu : 1; tv : 0),
    (x : 1.0; y :-1.0; z : 1.0; color : $0000FFFF; tu : 1; tv : 1),
    (x : 1.0; y :-1.0; z :-1.0; color : $0000FFFF; tu : 0; tv : 1),

    (x :-1.0; y : 1.0; z :-1.0; color : $00FF0000; tu : 0; tv : 1),  // Oben
    (x :-1.0; y : 1.0; z : 1.0; color : $00FF0000; tu : 0; tv : 0),
    (x : 1.0; y : 1.0; z : 1.0; color : $00FF0000; tu : 1; tv : 0),
    (x : 1.0; y : 1.0; z : 1.0; color : $00FF0000; tu : 1; tv : 0),
    (x : 1.0; y : 1.0; z :-1.0; color : $00FF0000; tu : 1; tv : 1),
    (x :-1.0; y : 1.0; z :-1.0; color : $00FF0000; tu : 0; tv : 1),

    (x : 1.0; y :-1.0; z :-1.0; color : $00FFFF00; tu : 0; tv : 1),  // Unten
    (x : 1.0; y :-1.0; z : 1.0; color : $00FFFF00; tu : 0; tv : 0),
    (x :-1.0; y :-1.0; z : 1.0; color : $00FFFF00; tu : 1; tv : 0),
    (x :-1.0; y :-1.0; z : 1.0; color : $00FFFF00; tu : 1; tv : 0),
    (x :-1.0; y :-1.0; z :-1.0; color : $00FFFF00; tu : 1; tv : 1),
    (x : 1.0; y :-1.0; z :-1.0; color : $00FFFF00; tu : 0; tv : 1));

type
  TFrmwuerfel3d = class(TForm)
    timerWuerfel3D: TTimer;
    procedure FormCreate(Sender: TObject);
    procedure FormClose(Sender: TObject; var Action: TCloseAction);
    procedure FormKeyDown(Sender: TObject; var Key: Word;
      Shift: TShiftState);



    procedure D3DInit(myphwnd: hwnd; lpd3dD_Nr: Integer);
    procedure D3DShutdown(lpd3dD_Nr: Integer);
    procedure D3DInitScene(lpd3dD_Nr: Integer);
    procedure D3DKillScene(lpd3dD_Nr: Integer);
    procedure D3DRender(lpd3dD_Nr: Integer);
    procedure timerWuerfel3DTimer(Sender: TObject);

  private
    { Private-Deklarationen }
    // Das main Direct3D Interface, es wird zum initialisieren und schließen von D3D benötigt
    lpd3d             : IDIRECT3D8;
    lpd3d2            : IDIRECT3D8;
    lpd3d3            : IDIRECT3D8;
    lpd3d4            : IDIRECT3D8;

    // Das D3DDevice wird zum Rendern benutzt und spiegelt den Bildschirm mit allen
    // Funktionen wieder. Wenn wir das D3DRender Interface erstellen, verändern oder
    // das Bild rendern, so machen wir das über dieses Interface
    lpd3ddevice       : IDirect3DDevice8;
    lpd3ddevice2      : IDirect3DDevice8;
    lpd3ddevice3      : IDirect3DDevice8;
    lpd3ddevice4      : IDirect3DDevice8;

    // Buffer, der die Vertizes des Würfels enthält
    CubeVB : IDirect3DVertexBuffer8;
    CubeVB2 : IDirect3DVertexBuffer8;
    CubeVB3 : IDirect3DVertexBuffer8;
    CubeVB4 : IDirect3DVertexBuffer8;

    // Textur des Würfels
    CubeTexture   : IDIRECT3DTEXTURE8;
    CubeTexture2   : IDIRECT3DTEXTURE8;
    CubeTexture3   : IDIRECT3DTEXTURE8;
    CubeTexture4   : IDIRECT3DTEXTURE8;

    RotX,RotY,RotZ   : single  ;  //Rotation des Würfels um die drei Achsen

    procedure FatalError(hr : HResult; FehlerMsg : string);

  public
    { Public-Deklarationen }

  end;

var
  frmwuerfel3d: TFrmwuerfel3d;
    texture_picture: PChar;
    texture_picture2: PChar;
    texture_picture3: PChar;
    texture_picture4: PChar;

    Animate          : boolean;
    Animate2          : boolean;
    Animate3          : boolean;
    Animate4          : boolean;

implementation

uses Unit1, Unit2;


{$R *.DFM}

// Initialisieren aller Variablen
procedure TFrmwuerfel3d.FormCreate(Sender: TObject);
begin
  texture_picture := PCHAR(#34+ExtractFileDir(Application.Exename)+'./images/0.bmp'+#34);
  texture_picture2 := PCHAR(#34+ExtractFileDir(Application.Exename)+'./images/0.bmp'+#34);
  texture_picture3 := PCHAR(#34+ExtractFileDir(Application.Exename)+'./images/0.bmp'+#34);
  texture_picture4 := './images/urlaub.bmp';
  lpd3d:=nil;
  lpd3ddevice:=nil;
  lpd3ddevice2:=nil;
  lpd3ddevice3:=nil;
  lpd3ddevice4:=nil;
  CubeVB:=nil;
  CubeVB2:=nil;
  CubeVB3:=nil;
  CubeVB4:=nil;
  CubeTexture:=nil;
  //Initialisiere die Rotation
  RotX:=0;
  RotY:=0;
  RotZ:=0;
  Animate:=false;
  Animate2:=false;
  Animate3:=false;
  Animate4:=false;
  end;

// Fataler Fehler. Meldung und Programmende
procedure TFrmwuerfel3d.FatalError(hr : HResult; FehlerMsg : string);
var
  s : string;
begin
  if hr<>0 then s:=D3DXErrorString(hr)+#13+FehlerMsg else s:=FehlerMsg;
  D3DKillScene(1);
  D3DShutdown(1);
  MessageDlg(s,mtError,[mbOK],0);
  close;
  end;



procedure TFrmwuerfel3d.D3DInit(myphwnd: hwnd; lpd3dD_Nr: Integer);
var
  hr    : HRESULT;
  d3dpp : TD3DPRESENTPARAMETERS;
  mylpd3ddevice : IDirect3DDevice8;
begin

  //Erstelle Direct3D! Muß immer als erstes erstellt werden
  //Immer D3D_SDK_VERSION als Version setzen
  lpd3d:=Direct3DCreate8(D3D_SDK_VERSION);
  lpd3d2:=Direct3DCreate8(D3D_SDK_VERSION);
  lpd3d3:=Direct3DCreate8(D3D_SDK_VERSION);
  lpd3d4:=Direct3DCreate8(D3D_SDK_VERSION);
  if(lpd3d=nil) then FatalError(0,'Fehler beim Erstellen von Direct3D!');

  // Setze D3DPRESENT_PARAMETERS auf 0, sonst könnten wir probleme mit älteren
  // Eintragungen bzw. unkontrollierbaren Ergebnissen bekommen!
  // Sollten wir bei allen DirectX Strukturen machen
  ZeroMemory(@d3dpp,sizeof(d3dpp));

  // Hiermit werden alte Frames gelöscht, denn wir brauchen sie nicht
  with d3dpp do begin
    SwapEffect:=D3DSWAPEFFECT_DISCARD;
    hDeviceWindow:=myphwnd;      // Dies ist unser HWND von TForm
    BackBufferCount:=1;         // 1 Backbuffer

    // Wir brauche einen Z-Buffer also schalten wir ihn ein
    EnableAutoDepthStencil := TRUE;
    AutoDepthStencilFormat := D3DFMT_D16;

    Windowed          := true;
    BackBufferWidth   := 1280;
    BackBufferHeight  := 1024;
    BackBufferFormat  := D3DFMT_X8R8G8B8;
    end;

  //Nachdem wir die D3DPRESENT_PARAMETERS Struktur ausgefüllt haben, sind wir
  // endlich so weit unser D3D Device zu erstellen
   case lpd3dD_Nr of
    1: hr:=lpd3d.CreateDevice(D3DADAPTER_DEFAULT,
                         D3DDEVTYPE_HAL,
                         myphwnd,
                         D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                         d3dpp,
                         lpd3ddevice);
    2: hr:=lpd3d2.CreateDevice(D3DADAPTER_DEFAULT,
                         D3DDEVTYPE_HAL,
                         myphwnd,
                         D3DCREATE_SOFTWARE_VERTEXPROCESSING,
//                         D3DCREATE_HARDWARE_VERTEXPROCESSING,
                         d3dpp,
                         lpd3ddevice2);
    3: hr:=lpd3d3.CreateDevice(D3DADAPTER_DEFAULT,
                         D3DDEVTYPE_HAL,
                         myphwnd,
                         D3DCREATE_SOFTWARE_VERTEXPROCESSING,
//                         D3DCREATE_HARDWARE_VERTEXPROCESSING,
                         d3dpp,
                         lpd3ddevice3);
    4: hr:=lpd3d3.CreateDevice(D3DADAPTER_DEFAULT,
                         D3DDEVTYPE_HAL,
                         myphwnd,
                         D3DCREATE_SOFTWARE_VERTEXPROCESSING,
//                         D3DCREATE_HARDWARE_VERTEXPROCESSING,
                         d3dpp,
                         lpd3ddevice4);
   end;

  if FAILED(hr) then FatalError(hr,'Fehler beim Erzeugen des 3D-Device');
  end;

// *** D3DShutdown hier werden die Resourcen von D3D wieder freigegeben
procedure TFrmwuerfel3d.D3DShutdown(lpd3dD_Nr: Integer);
var
  mylpd3ddevice : IDirect3DDevice8;
begin
  case lpd3dD_Nr of
    1: mylpd3ddevice := lpd3ddevice;
    2: mylpd3ddevice := lpd3ddevice2;
    3: mylpd3ddevice := lpd3ddevice3;
    4: mylpd3ddevice := lpd3ddevice4;
  end;

  if assigned(mylpd3ddevice) then mylpd3ddevice:=nil;
  if assigned(lpd3d) then lpd3d:=nil;
  end;

procedure TFrmwuerfel3d.D3DInitScene(lpd3dD_Nr: Integer);
var
  hr         : HRESULT;
  vbVertices : pByte;
  ViewMatrix,
  matProj    : TD3DXMATRIX;
  mylpd3ddevice: IDirect3DDevice8;
  myCubeTexture: IDIRECT3DTEXTURE8;
  myCubeVB: IDirect3DVertexBuffer8;
begin
  // Hier wird der Vertex Buffer erstellt, der groß genug ist um alle Vertizes zu enthalten.
  case lpd3dD_Nr of
    1: begin
        mylpd3ddevice := lpd3ddevice;
        myCubeTexture := CubeTexture;
        myCubeVB := cubeVB;
       end;
    2: begin
        mylpd3ddevice := lpd3ddevice2;
        myCubeTexture := CubeTexture2;
        myCubeVB := cubeVB2;
       end;
    3: begin
        mylpd3ddevice := lpd3ddevice3;
        myCubeTexture := CubeTexture3;
        myCubeVB := cubeVB3;
       end;
    4: begin
        mylpd3ddevice := lpd3ddevice4;
        myCubeTexture := CubeTexture4;
        myCubeVB := cubeVB4;
       end;
  end;

  if assigned(mylpd3ddevice) then with mylpd3ddevice do begin
    case lpd3dD_Nr of
      1: begin
          hr:=CreateVertexBuffer (sizeof(TCube),
                            D3DUSAGE_WRITEONLY, // Nur Schreibzugriffe
                            D3D8T_CUSTOMVERTEX, // Unser Vertex
                            D3DPOOL_MANAGED,
                            CubeVB);

          if FAILED(hr) then FatalError(0,'Fehler beim Erstellen des Vertex Buffers');

          // Nun kopieren wir unsere Vertizes in den Buffer
          // Wir müssen es zuvor mit Lock festhalten, um es bearbeiten zu können
          with CubeVB do begin
            hr:=Lock(0, // Offset, an dem wir beginnen
                     0, // Größe des locks ( 0 für alles )
                     vbVertices, // Wenn erfolgreich dann hier ablegen
                     0); // sonstige Flags
            if FAILED(hr) then FatalError(0,'Fehler beim Locken des Vertex-Buffers');
            // Hier wird der Vertexbuffer kopiert.
            Move(NormCube,vbVertices^,SizeOf(TCube));
            // Und wieder loslassen
            Unlock;
            end;
          end;
                                         // Pointer zu unserem Buffer
      2: begin
          hr:=CreateVertexBuffer (sizeof(TCube),
                            D3DUSAGE_WRITEONLY, // Nur Schreibzugriffe
                            D3D8T_CUSTOMVERTEX, // Unser Vertex
                            D3DPOOL_MANAGED,
                            CubeVB2);

          if FAILED(hr) then FatalError(0,'Fehler beim Erstellen des Vertex Buffers');

          // Nun kopieren wir unsere Vertizes in den Buffer
          // Wir müssen es zuvor mit Lock festhalten, um es bearbeiten zu können
          with CubeVB2 do begin
            hr:=Lock(0, // Offset, an dem wir beginnen
                     0, // Größe des locks ( 0 für alles )
                     vbVertices, // Wenn erfolgreich dann hier ablegen
                     0); // sonstige Flags
            if FAILED(hr) then FatalError(0,'Fehler beim Locken des Vertex-Buffers');
            // Hier wird der Vertexbuffer kopiert.
            Move(NormCube,vbVertices^,SizeOf(TCube));
            // Und wieder loslassen
            Unlock;
            end;
          end;
                                          // Pointer zu unserem Buffer
      3: begin
          hr:=CreateVertexBuffer (sizeof(TCube),
                            D3DUSAGE_WRITEONLY, // Nur Schreibzugriffe
                            D3D8T_CUSTOMVERTEX, // Unser Vertex
                            D3DPOOL_MANAGED,
                            CubeVB3);

          if FAILED(hr) then FatalError(0,'Fehler beim Erstellen des Vertex Buffers');

          // Nun kopieren wir unsere Vertizes in den Buffer
          // Wir müssen es zuvor mit Lock festhalten, um es bearbeiten zu können
          with CubeVB3 do begin
            hr:=Lock(0, // Offset, an dem wir beginnen
                     0, // Größe des locks ( 0 für alles )
                     vbVertices, // Wenn erfolgreich dann hier ablegen
                     0); // sonstige Flags
            if FAILED(hr) then FatalError(0,'Fehler beim Locken des Vertex-Buffers');
            // Hier wird der Vertexbuffer kopiert.
            Move(NormCube,vbVertices^,SizeOf(TCube));
            // Und wieder loslassen
            Unlock;
            end;
         end;          // Pointer zu unserem Buffer
                                          // Pointer zu unserem Buffer
      4: begin
          hr:=CreateVertexBuffer (sizeof(TCube),
                            D3DUSAGE_WRITEONLY, // Nur Schreibzugriffe
                            D3D8T_CUSTOMVERTEX, // Unser Vertex
                            D3DPOOL_MANAGED,
                            CubeVB4);

          if FAILED(hr) then FatalError(0,'Fehler beim Erstellen des Vertex Buffers');

          // Nun kopieren wir unsere Vertizes in den Buffer
          // Wir müssen es zuvor mit Lock festhalten, um es bearbeiten zu können
          with CubeVB4 do begin
            hr:=Lock(0, // Offset, an dem wir beginnen
                     0, // Größe des locks ( 0 für alles )
                     vbVertices, // Wenn erfolgreich dann hier ablegen
                     0); // sonstige Flags
            if FAILED(hr) then FatalError(0,'Fehler beim Locken des Vertex-Buffers');
            // Hier wird der Vertexbuffer kopiert.
            Move(NormCube,vbVertices^,SizeOf(TCube));
            // Und wieder loslassen
            Unlock;
            end;
         end;          // Pointer zu unserem Buffer
    end;

    SetRenderState(D3DRS_CULLMODE,D3DCULL_CCW);
    SetRenderState(D3DRS_LIGHTING,0);
    SetRenderState(D3DRS_ZENABLE,0);

    // Hier erstellen wir unseren SichtMatrix. Denkt einfach es ist
    // eure Kamera, von der aus wir sehen. Als erstes setzen wir die Kamera
    // um 8 Einheiten zurück auf der Z-Achse.
    D3DXMatrixLookAtLH (ViewMatrix,D3DXVECTOR3(0.0,0.0,-8.0),
                                   D3DXVECTOR3(0.0,0.0,0.0),
                                   D3DXVECTOR3(0.0,1.0,0.0));

    // Da sich unsere Camera nicht bewegt legen wir sie einfach fest
    SetTransform(D3DTS_VIEW,ViewMatrix);

    D3DXMatrixPerspectiveFovLH(matProj, //Resultierende Matrix
                               D3DX_PI/4,//Radius der Ansicht
                               640/480,
                               1.0,     // Mindeste Nähe
                               100.0);  // Maximal sichtbare Entfernung

    // Unsere Projektion wird sich niemals bewegen, also setzen wir sie fest
    SetTransform(D3DTS_PROJECTION,matProj );

    // Mit D3DTSS_COLLORP wird festgelegt, wie die Farbe jedes einzelnen Pixels
    // verarbeitet wird. D3DTOP_SELECTARG1 verweist auf D3DTSS_COLORARG1
    SetTextureStageState(0,D3DTSS_COLOROP, D3DTOP_SELECTARG1);
    // Mit D3DTSS_COLORARG1 wird festgelegt, daß die Farbe nur von der Textur
    // genommen wird und von nichts anderem.
    SetTextureStageState(0,D3DTSS_COLORARG1, D3DTA_TEXTURE);
    // Wir benutzen kein Alpha blending, also schalten wir es ab. Dadurch wird
    // der Code etwas schneller
    SetTextureStageState(0,D3DTSS_ALPHAOP,   D3DTOP_DISABLE);
    // MAGFILTER ist dafür, wenn es kleiner ist als unser Objekt.
    // MINFILTER ist genau das umgekehrte
    // Standard ist D3DTEXF_LINEAR. Dieses ist zwar langsamer als D3DTEXF_POINT,
    // sieht aber besser aus.
    SetTextureStageState(0,D3DTSS_MAGFILTER, D3DTEXF_LINEAR);
    SetTextureStageState(0,D3DTSS_MINFILTER, D3DTEXF_LINEAR);

    // Ich glaube diese Funktion bräuchte ich nicht zu beschreiben, aber hier
    // wird die Textur geladen.

    case lpd3dD_Nr of
      1: hr:=D3DXCreateTextureFromFile(lpd3ddevice,texture_picture, CubeTexture);
      2: hr:=D3DXCreateTextureFromFile(lpd3ddevice2,texture_picture2, CubeTexture2);
      3: hr:=D3DXCreateTextureFromFile(lpd3ddevice3,texture_picture3, CubeTexture3);
      4: hr:=D3DXCreateTextureFromFile(lpd3ddevice4,texture_picture4, CubeTexture4);
    end;

    if(FAILED(hr)) then FatalError(0,'Fehler beim Laden der Textur');
    end;
  case lpd3dD_Nr of
    1: Animate:=true;
    2: Animate2:=true;
    3: Animate3:=true;
    4: Animate4:=true;
  end;

  end;

procedure TFrmwuerfel3d.D3DKillScene(lpd3dD_Nr: Integer);
begin

    case lpd3dD_Nr of
      1: CubeVB:=nil;
      2: CubeVB2:=nil;
      3: CubeVB3:=nil;
      4: CubeVB4:=nil;
    end;

end;

procedure TFrmwuerfel3d.D3DRender(lpd3dD_Nr: Integer);
var
  WorldMatrix,TempMatrix  : TD3DXMATRIX;
  mylpd3ddevice: IDirect3DDevice8;
  myCubeTexture: IDIRECT3DTEXTURE8;
  myCubeVB: IDirect3DVertexBuffer8;
  myColor: TColor;
begin
  RotY:=RotY+0.0065;
  RotX:=RotX+0.007;
  RotZ:=RotZ+0.006;

  myColor := unit1.colorBG;
  if frmPanelStock.AdvSmoothSlider2.State = ssOn then
    myColor := D3DCOLOR_XRGB(255, 255, 255)
  else
    myColor := D3DCOLOR_XRGB(68, 128, 176);

  //form1.Color := myColor;
  case lpd3dD_Nr of
    1: begin
        mylpd3ddevice := lpd3ddevice;
        myCubeTexture := CubeTexture;
        myCubeVB := cubeVB;

        if assigned(lpd3ddevice) then with lpd3ddevice do
        begin
          Clear(0,           // Wieviel Rechtecke löschen? 0 Löscht alle
                nil,         // Pointer zu den Rechtecken. nil = Ganzer Bildschirm
                D3DCLEAR_TARGET,
                //D3DCOLOR_ARGB(255,70,125,176), //Hintergrundfarbe schwarz
                myColor,
                1,           // Lösche ZBuffer ( Wir haben momentan noch keinen )
                0 );

         SetRenderState(D3DRS_ALPHABLENDENABLE, 1);
         {SetRenderState(D3DRS_SRCBLEND, Integer(D3DBLEND_srcalpha));
         SetRenderState(D3DRS_DESTBLEND, Integer(D3DBLEND_invsrccolor));
         SetRenderState(D3DRS_CULLMODE, Ord(D3DCULL_none));

         SetRenderState(D3DRS_ZWRITEENABLE, Ord(false));     }

          if SUCCEEDED(BeginScene) then
          begin
            // Hier wird unsere Textur geladen
            SetTexture(0, CubeTexture);

            // Vertex Shader sind wirklich komplex, aber es lassen sich damit gute Effekte
            // erzielen. Genauere Beschreibungen in der SDK, denn alles hier niederschreiben
            // sprengt den Rahmen eines Tutorials
            SetVertexShader(D3D8T_CUSTOMVERTEX);

            // Die D3D Renderfunktionen lesen aus Streams. Hier sagen wir DX welchen Stream
            // es verwenden soll
            SetStreamSource(0,CubeVB,sizeof(TMyVertex));

            // Die Rotation um alle Achsen.
            D3DXMatrixRotationYawPitchRoll(TempMatrix,RotY,RotX,RotZ);
            // Verschiebe den Würfel etwas nach vorn
            D3DXMatrixTranslation(WorldMatrix,0.0,0.0,-2.0);
            // Berechne die Welt-Matrix für die Transformation
            D3DXMatrixMultiply(WorldMatrix,TempMatrix,WorldMatrix);
            SetTransform(D3DTS_WORLD,WorldMatrix);

            // Zeichnen des Würfels
            DrawPrimitive(D3DPT_TRIANGLELIST,0,12);

            EndScene;
          end;

        // Zeige Resultate auf dem Bildschirm
        Present(nil,nil,0,nil);
      end;
       end;
    2: begin
        mylpd3ddevice := lpd3ddevice2;
        myCubeTexture := CubeTexture2;
        myCubeVB := cubeVB2;

        if assigned(lpd3ddevice2) then with lpd3ddevice2 do
        begin
          Clear(0,           // Wieviel Rechtecke löschen? 0 Löscht alle
                nil,         // Pointer zu den Rechtecken. nil = Ganzer Bildschirm
                D3DCLEAR_TARGET,
                myColor,//D3DCOLOR_ARGB(255,65,123,170), //Hintergrundfarbe schwarz
                1,           // Lösche ZBuffer ( Wir haben momentan noch keinen )
                0 );

          if SUCCEEDED(BeginScene) then
          begin
            // Hier wird unsere Textur geladen
            SetTexture(0, CubeTexture2);

            // Vertex Shader sind wirklich komplex, aber es lassen sich damit gute Effekte
            // erzielen. Genauere Beschreibungen in der SDK, denn alles hier niederschreiben
            // sprengt den Rahmen eines Tutorials
            SetVertexShader(D3D8T_CUSTOMVERTEX);

            // Die D3D Renderfunktionen lesen aus Streams. Hier sagen wir DX welchen Stream
            // es verwenden soll
            SetStreamSource(0,CubeVB2,sizeof(TMyVertex));

            // Die Rotation um alle Achsen.
            D3DXMatrixRotationYawPitchRoll(TempMatrix,RotY,RotX,RotZ);
            // Verschiebe den Würfel etwas nach vorn
            D3DXMatrixTranslation(WorldMatrix,0.0,0.0,-2.0);
            // Berechne die Welt-Matrix für die Transformation
            D3DXMatrixMultiply(WorldMatrix,TempMatrix,WorldMatrix);
            SetTransform(D3DTS_WORLD,WorldMatrix);

            // Zeichnen des Würfels
            DrawPrimitive(D3DPT_TRIANGLELIST,0,12);

            EndScene;
          end;
        // Zeige Resultate auf dem Bildschirm
        Present(nil,nil,0,nil);
      end;
       end;
    3: begin
        mylpd3ddevice := lpd3ddevice3;
        myCubeTexture := CubeTexture3;
        myCubeVB := cubeVB3;

        if assigned(lpd3ddevice3) then with lpd3ddevice3 do
        begin
          Clear(0,           // Wieviel Rechtecke löschen? 0 Löscht alle
                nil,         // Pointer zu den Rechtecken. nil = Ganzer Bildschirm
                D3DCLEAR_TARGET,
                myColor,
                1,           // Lösche ZBuffer ( Wir haben momentan noch keinen )
                0 );

          if SUCCEEDED(BeginScene) then
          begin
            // Hier wird unsere Textur geladen
            SetTexture(0, CubeTexture3);

            // Vertex Shader sind wirklich komplex, aber es lassen sich damit gute Effekte
            // erzielen. Genauere Beschreibungen in der SDK, denn alles hier niederschreiben
            // sprengt den Rahmen eines Tutorials
            SetVertexShader(D3D8T_CUSTOMVERTEX);

            // Die D3D Renderfunktionen lesen aus Streams. Hier sagen wir DX welchen Stream
            // es verwenden soll
            SetStreamSource(0,CubeVB3,sizeof(TMyVertex));

            // Die Rotation um alle Achsen.
            D3DXMatrixRotationYawPitchRoll(TempMatrix,RotY,RotX,RotZ);
            // Verschiebe den Würfel etwas nach vorn
            D3DXMatrixTranslation(WorldMatrix,0.0,0.0,-2.0);
            // Berechne die Welt-Matrix für die Transformation
            D3DXMatrixMultiply(WorldMatrix,TempMatrix,WorldMatrix);
            SetTransform(D3DTS_WORLD,WorldMatrix);

            // Zeichnen des Würfels
            DrawPrimitive(D3DPT_TRIANGLELIST,0,12);

            EndScene;
          end;
        // Zeige Resultate auf dem Bildschirm
        Present(nil,nil,0,nil);
      end;
    end;
    4: begin
        mylpd3ddevice := lpd3ddevice4;
        myCubeTexture := CubeTexture4;
        myCubeVB := cubeVB4;

        if assigned(lpd3ddevice4) then with lpd3ddevice4 do
        begin
          Clear(0,           // Wieviel Rechtecke löschen? 0 Löscht alle
                nil,         // Pointer zu den Rechtecken. nil = Ganzer Bildschirm
                D3DCLEAR_TARGET,
                D3DCOLOR_XRGB(220,234,249), //Hintergrundfarbe schwarz
                1,           // Lösche ZBuffer ( Wir haben momentan noch keinen )
                0 );

          if SUCCEEDED(BeginScene) then
          begin
            // Hier wird unsere Textur geladen
            SetTexture(0, CubeTexture4);

            // Vertex Shader sind wirklich komplex, aber es lassen sich damit gute Effekte
            // erzielen. Genauere Beschreibungen in der SDK, denn alles hier niederschreiben
            // sprengt den Rahmen eines Tutorials
            SetVertexShader(D3D8T_CUSTOMVERTEX);

            // Die D3D Renderfunktionen lesen aus Streams. Hier sagen wir DX welchen Stream
            // es verwenden soll
            SetStreamSource(0,CubeVB4,sizeof(TMyVertex));

            // Die Rotation um alle Achsen.
            D3DXMatrixRotationYawPitchRoll(TempMatrix,RotY,RotX,RotZ);
            // Verschiebe den Würfel etwas nach vorn
            D3DXMatrixTranslation(WorldMatrix,0.0,0.0,-2.0);
            // Berechne die Welt-Matrix für die Transformation
            D3DXMatrixMultiply(WorldMatrix,TempMatrix,WorldMatrix);
            SetTransform(D3DTS_WORLD,WorldMatrix);

            // Zeichnen des Würfels
            DrawPrimitive(D3DPT_TRIANGLELIST,0,12);

            EndScene;
          end;
        // Zeige Resultate auf dem Bildschirm
        Present(nil,nil,0,nil);
      end;
    end;

  end;



  end;



procedure TFrmwuerfel3d.FormClose(Sender: TObject;
  var Action: TCloseAction);
begin
  // Lösche die D3D Scene bevor wir D3D beenden
  D3DKillScene(1);
  // Lösche D3D
  D3DShutdown(1);
  end;

procedure TFrmwuerfel3d.FormKeyDown(Sender: TObject; var Key: Word;
  Shift: TShiftState);
begin
  if Key=VK_ESCAPE then close;
  if Key=VK_SPACE then Animate:=not Animate;
  end;



procedure TFrmwuerfel3d.timerWuerfel3DTimer(Sender: TObject);
begin
  if wuerfel3D.Animate then
    frmWuerfel3D.D3DRender(1);

  if wuerfel3D.Animate2 then
    frmWuerfel3D.D3DRender(2);

  if wuerfel3D.Animate3 then
    frmWuerfel3D.D3DRender(3);
end;

end.

[mkinzler]

Wobei der D3D-Code wohl nicht portierbar ist

[Darlo]

Ach Mist das [Fmx] nicht beachtet.

Gibt es unter Fmx nicht ein Rectangle3d? Sitze gerade nicht mehr am Rechner glaube aber da gesehen zu haben dass man dir Ränder separat ansprechen kann und auch verschiedene Bitmaps zuweisen kann.

[Union]

Danke erstmal. Mit dem Direct3D wird das wiklich schwer portierbar Unter FMX gibt es einen TCube3D. Aber der hat nur EINE Material-Eigenschaft.

Ich hab auch schon versucht, mit verschiedenen Layern als Childs des TCube zu arbeiten (im Grunde genommen 6 Layer, für jede Seite des Würfels, die sich durch entsprechende Rotationsachen und -Winkel auf die Fläche legen).

Erstens bin ich dafür zu faul - was mach ich dann bei einem Dodekaeder, da müsst ich ja diverse Polygone ausrichten

Und zweitens sah das Ergebnis dann bescheiden aus. Je nach Position war dann

- Entweder das Bitmap zu sehen
- ODER der Layer
- oder beides, aber bei gleichem Z flimmert das erbärmlich.

[Darlo]

Da ich für so einen Würfel jetzt auch Verwendung finden kann setze ich mich mal dran. Vlt. Finden wir ja zusammen eine Lösung dafür.
Arbeitet eigentlich außer uns sonst noch wer mit Firemonkey? Also rein Firemonkey ohne Vcl...

[Union]

Ich hab jetzt eine doofe Lösung: Der Würfel hat ein Material bzw eine Farbe. Und die Images lege ich auf die Seiten rauf. Ich dachte ich kann mir Arbeit ersparen, indem ich nur eines erzeuge und im FormCreate dann 5x dupliziere und nur die Position und Rotation anpasse. Klarer Fall von Denkste, weil in FMX die meisten Objekte kein Assign unterstützen. Hiesse also alle Properties manuell bzw. per Code setzen.

Zitat:

Arbeitet eigentlich außer uns sonst noch wer mit Firemonkey?

Scheint sonst fast kaum einer so mutig oder dämlich zu sein. Wenn ich die Anzahl der Posts und Tutorials die über Google zu FM auffindbar sind mal hochrechne, gehören wir beide wohl zu einem erlauchten Kreis von ca. 20 Personen weltweit

[mkinzler]

Handelt sich um den ed-"Teil" von FMX:
http://delphitools.info/2011/10/06/a...of-firemonkey/

Zitat:

Zitat:

Arbeitet eigentlich außer uns sonst noch wer mit Firemonkey?

Scheint sonst fast kaum einer so mutig oder dämlich zu sein. Wenn ich die Anzahl der Posts und Tutorials die über Google zu FM auffindbar sind mal hochrechne, gehören wir beide wohl zu einem erlauchten Kreis von ca. 20 Personen weltweit

Das werden schon mehr sein un sicherlich mehr werden.

[Union]

Der Artikel bestätigt die meisten meiner Beobachtungen. Auch die Beleuchtung is unvollständig und arbeitet auf einem "echten" IDevice nicht korrekt.

Rotierende Körper werden nicht graduell winkelabhängig heller und dunkler, sondern wechseln ziemlich abrupt von unbeleuchtet zu beleuchtet.

Antialiasing ist nicht vorhanden, die erste Reaktion unseres 13-Jährigen Sohnes auf meinen rotiernden 3D-Würfel war nicht "Wow, Du hast eine IPhone App gemacht" sondern "Die Kanten von dem Würfel sehen ja Scheiße aus, da sieht man ja die Pixel".

Fontfarben funktionieren nicht richtig, unter Windows rot auf dem IPhone dann doch weiß und pixelig.

Allgemein kann man sagen, dass der Eindruck unter Windows nur eine ganz grobe Preview des Endergebnisses darstellt. Das bedingt dann dauernde Korrekturen mit kompletten Zyklus XCode, Provisioning auf IPhone usw.

Dann kommt noch das Fehlen einer Abstraktionsschicht hinzu. Man ist gezwungen sich diese selber zu schreiben oder damit zu leben, dass 50% des Source aus {$ifdef} besteht. Fördert nicht wirklich die Wartbarkeit und Übersichtlichkeit.

Dazu dann noch die Performanceprobleme (verursacht durch schlechte / ineffektive Programmierung der emulierten Controls) und der monströse Resourcenhunger (u.a. verursacht durch fehlendes Textursharing).

Nebenkriegsschauplatz ist der FPC, dessen RTL uns dann auch noch weitere Fehlerquellen beschert. Aber dafür kann ja Embarcadero nichts, denn der wird ja einfach "as is" mitgeliefert.

FMX braucht aus meiner Sicht ein komplettes Rewrite, ansonsten wird sich das - wie fast alle bisher in Delphi zugekauften Pakete - nach ein oder zwei Versionen erledigt haben. Jetzt zu Beginn ist die Chance noch gut, das zu schaffen da die Auswirkungen von "breaking changes" noch überschaubar sind.

[mkinzler]

Da die aktuelle Unterstützung sehr rudimentär ist, ist die Gefahr recht gering, dass eine Änderung "breaking" ist :wink
Ich frage mich aber, warum man sich entschieden hat, abzuspecken, anstatt sich mit den Machern von GLScene zu einigen, was realistisch gewesen wäre und dann eine bessere Unterstützung für manche Dinge zu haben.