Espectacular simulación realizada con OpenGL del movimiento de los electrones cuando atraviesan un campo eléctrico.
UNIT Unit1;
INTERFACE
USES
System.SysUtils, System.Types, System.UITypes, System.Classes,
System.Variants,
FMX.Types, FMX.Controls, FMX.Forms, FMX.Graphics, FMX.Dialogs,
System.Math.Vectors, FMX.Types3D, System.Sensors, System.Sensors.Components,
FMX.Controls.Presentation, FMX.StdCtrls, FMX.Layouts, FMX.MaterialSources,
FMX.Objects3D, FMX.Controls3D, FMX.Viewport3D;
TYPE
TForm1 = CLASS(TForm)
Viewport3D1: TViewport3D;
Dummy1: TDummy;
Camera1: TCamera;
Light1: TLight;
RoundCube1: TRoundCube;
Plane1: TPlane;
Disk1: TDisk;
LightMaterialSource1: TLightMaterialSource;
ColorMaterialSource1: TColorMaterialSource;
Disk2: TDisk;
Timer1: TTimer;
PROCEDURE Timer1Timer(Sender: TObject);
PRIVATE
{ Private declarations }
PUBLIC
{ Public declarations }
END;
VAR
Form1: TForm1;
IMPLEMENTATION
{$R *.fmx}
PROCEDURE TForm1.Timer1Timer(Sender: TObject);
BEGIN
WITH RoundCube1.RotationAngle DO
Point := Point + Point3D(2, 0, 0);
END;
END.
Esta aplicación genera un array de vértices utilizados para construir curvas de Bezier. Requiere que la tarjeta gráfica sea compatible con OpenGL.
Posteriormente se puede hacer clic mantenido sobre una partícula cualquiera para moverla.
Autor:
Paul TOTH
http://tothpaul.free.fr
Codigo fuente
procedure TForm1.FormCreate(Sender: TObject);
var mesh : TMesh;
begin
for mesh in Model3D1.MeshCollection do
mesh.MaterialSource := LightMaterialSource1;
end;
procedure TForm1.FormGesture(Sender: TObject;
const EventInfo: TGestureEventInfo; var Handled: Boolean);
var delta: integer;
begin
if EventInfo.GestureID = igiZoom then
begin
if (not (TInteractiveGestureFlag.gfBegin in EventInfo.Flags))
and (not (TInteractiveGestureFlag.gfEnd in EventInfo.Flags)) then
begin
delta := EventInfo.Distance - UltimaDistancia;
DoZoom(delta > 0);
end;
UltimaDistancia := EventInfo.Distance;
end;
end;
procedure TForm1.MouseDown(Sender: TObject;
Button: TMouseButton; Shift: TShiftState; X, Y: Single);
begin
Punto := PointF(X, Y);
end;
procedure TForm1.MouseMove(Sender: TObject;
Shift: TShiftState; X, Y: Single);
begin
if (ssLeft in Shift) then
begin
DummyCamera.RotationAngle.X := DummyCamera.RotationAngle.X - ((Y - Punto.Y) * ROTATION_STEP);
DummyCamera.RotationAngle.Y := DummyCamera.RotationAngle.Y + ((X - Punto.X) * ROTATION_STEP);
Punto := PointF(X, Y);
end;
end;
procedure TForm1.MouseWheel(Sender: TObject;
Shift: TShiftState; WheelDelta: Integer; var Handled: Boolean);
begin
DoZoom(WheelDelta > 0);
end;
A continuación les muestro un ejemplo sobre cómo cargar el modelo de malla del rover Perseverance que actualmente está en Marte para obtener información del clima y del suelo de este planeta.
Este modelo lo ha puesto a disposición de todos la NASA y está en formato glb.
Si les interesa este tema y quieren ampliar más información sobre el programa de exploración de marte lo pueden consultar aquí
Los archivos glb contienen un modelo de un objeto 3D guardado en el formato de transmisión GL (glTF).
Almacena información sobre un modelo 3D, como la jerarquía de nodos, cámaras y materiales, animaciones y mallas en formato binario. Los archivos GLb son la versión binaria de los archivos GLTF.
Los archivos GLB pueden utilizarse para guardar y compartir activos digitales entre diferentes herramientas de modelado 3D, de forma similar a los archivos .DAE. Sin embargo, también están optimizados para la velocidad de descarga y el tiempo de carga en tiempo de ejecución, lo que hace que sean más fáciles de usar en programas de modelado 3D basados en móviles y en la web. También son un formato más racionalizado para cargar y descargar desde bases de datos de activos digitales en línea, como 3D Warehouse y Remix 3D.
Para descargar el modelo usa el componente tNetHTTPClient, ( también se podría utilizar tIdHTTP ), que lo que hace descargar el modelo desde la URL
https://mars.nasa.gov/system/resources/gltf_files/25042_Perseverance.glb
y almacenarlo en un tMemoryString.
Luego utiliza la clase TGLBModel para crear los nodos, el escalado, los materiales con el fin de crear la hoja de malla que visualizaremos en el tViewPort y que nos permitirá girar, rotar o escalar el modelo del rover.
Dentro del ViewPort se ha definido un componente tLight y un tDummy que contendrá toda la imagen del vehículo.
Lo bueno de utilizar Firemonkey es que de una forma transparente al usuario utiliza la capacidad de cálculo de la GPU del equipo para renderizar la imagen prácticamente en tiempo real.
El código es el siguiente:
unit Perseverance.FMX.Main;
interface
uses
System.SysUtils,
System.Types,
System.UITypes,
System.Classes,
System.Variants,
System.JSON,
FMX.Types,
FMX.Controls,
FMX.Forms,
FMX.Graphics,
FMX.Dialogs,
FMX.StdCtrls,
FMX.Controls.Presentation,
FMX.Edit,
FMX.Objects,
FMX.Layouts,
FMX.Types3D,
System.Net.URLClient,
System.Net.HttpClient,
System.Net.HttpClientComponent,
System.IOUtils,
System.Math.Vectors,
FMX.Controls3D,
FMX.Objects3D,
FMX.Viewport3D,
FMX.MaterialSources,
Execute.GLB.FMX, FMX.TreeView;
type
TMainForm = class(TForm)
Layout1: TLayout;
Text1: TText;
edURL: TEdit;
btGo: TButton;
NetHTTPClient: TNetHTTPClient;
Viewport3D1: TViewport3D;
Light1: TLight;
root: TDummy;
procedure btGoClick(Sender: TObject);
procedure Viewport3D1MouseDown(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Single);
procedure Viewport3D1MouseMove(Sender: TObject; Shift: TShiftState; X,
Y: Single);
procedure Viewport3D1MouseWheel(Sender: TObject; Shift: TShiftState;
WheelDelta: Integer; var Handled: Boolean);
procedure FormCreate(Sender: TObject);
private
{ Déclarations privées }
FDown: TPointF;
FModel: TGLBFMXModel;
FMesh: TMesh;
FMat: TMaterialSource;
public
{ Déclarations publiques }
end;
var
MainForm: TMainForm;
implementation
{$R *.fmx}
procedure TMainForm.FormCreate(Sender: TObject);
//var
// Stream: TFileStream;
begin
FModel := TGLBFMXModel.Create(Self);
FModel.Parent := root;
// Stream := TFileStream.Create('..\..\..\VCL\win32\debug\TEST.GLB', fmOpenRead);
// FModel.LoadFromStream(Stream);
// Stream.Free;
end;
procedure TMainForm.btGoClick(Sender: TObject);
var
GLB: TMemoryStream;
begin
GLB := TMemoryStream.Create;
try
{$IFDEF DEBUG}
if FileExists('Perseverance.glb') then
begin
GLB.LoadFromFile('Perseverance.glb');
end else begin
{$ENDIF}
NetHTTPClient.Get(edURL.Text, GLB);
{$IFDEF DEBUG}
GLB.SaveToFile('Perseverance.glb')
end;
{$ENDIF}
GLB.Position := 0;
FModel.LoadFromStream(GLB);
finally
GLB.Free;
end;
end;
procedure TMainForm.Viewport3D1MouseDown(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Single);
begin
FDown := PointF(X, Y);
end;
procedure TMainForm.Viewport3D1MouseMove(Sender: TObject; Shift: TShiftState; X,
Y: Single);
begin
if (ssLeft in Shift) then
begin
root.RotationAngle.X := root.RotationAngle.X + (Y - FDown.Y) * 0.3;
root.RotationAngle.Y := root.RotationAngle.Y + (X - FDown.X) * 0.3;
FDown.X := X;
FDown.Y := Y;
end;
if (ssRight in Shift) then
begin
root.Position.Z := root.Position.Z - (Y - FDown.Y) * 0.3;
FDown.Y := Y;
end;
end;
procedure TMainForm.Viewport3D1MouseWheel(Sender: TObject; Shift: TShiftState;
WheelDelta: Integer; var Handled: Boolean);
begin
root.Position.Z := root.Position.Z - ((WheelDelta / 120) * 0.3);
end;
end.
------------------
Este sería el diseño del form:
Estructura del programa:
Programa terminado en Firemonkey
El programa se ha realizado con Delphi 10.4.1
El autor del código es Paul Toth (MVP Embarcadero).
El programa (ejecutable y código fuente) está en el github de Paul Toth
Para descargarlo pulsar el botón CODE y en el menú emergente seleccionar "Download.zip"
Espectacular simulación realizada con OpenGL del movimiento de los electrones cuando atraviesan un campo eléctrico. Como muestra la image...
