3764 lines
169 KiB
ObjectPascal
3764 lines
169 KiB
ObjectPascal
// Copyright (©) Ivan Bondarev, Stanislav Mihalkovich (for details please see \doc\copyright.txt)
|
||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
||
/// Модуль трёхмерной графики
|
||
unit Graph3D;
|
||
|
||
{$reference System.Xml.dll}
|
||
{$reference HelixToolkit.Wpf.dll}
|
||
|
||
interface
|
||
|
||
uses GraphWPFBase;
|
||
|
||
uses System.Windows;
|
||
uses System.Windows.Controls;
|
||
uses System.Windows.Shapes;
|
||
uses System.Windows.Media;
|
||
uses System.Windows.Media.Animation;
|
||
uses System.Windows.Media.Media3D;
|
||
|
||
uses System.Windows.Markup;
|
||
uses System.XML;
|
||
uses System.IO;
|
||
uses System.Threading;
|
||
uses System.Windows.Input;
|
||
|
||
uses HelixToolkit.Wpf;
|
||
//uses Petzold.Media3D;
|
||
|
||
//{{{doc: Начало секции 1 }}}
|
||
type
|
||
// -----------------------------------------------------
|
||
//>> Типы модуля Graph3D # Graph3D types
|
||
// -----------------------------------------------------
|
||
/// Тип клавиши
|
||
Key = System.Windows.Input.Key;
|
||
/// Цветовые константы
|
||
Colors = System.Windows.Media.Colors;
|
||
/// Тип цвета
|
||
GColor = System.Windows.Media.Color;
|
||
/// Тип материала
|
||
GMaterial = System.Windows.Media.Media3D.Material;
|
||
/// Тип диффузного материала
|
||
GDiffuseMaterial = System.Windows.Media.Media3D.DiffuseMaterial;
|
||
/// Тип материала свечения
|
||
GEmissiveMaterial = System.Windows.Media.Media3D.EmissiveMaterial;
|
||
/// Тип камеры
|
||
GCamera = System.Windows.Media.Media3D.ProjectionCamera;
|
||
/// Тип прямоугольника
|
||
GRect = System.Windows.Rect;
|
||
/// Тип режима камеры
|
||
CameraMode = HelixToolkit.Wpf.CameraMode;
|
||
/// Тип предопределенных материалов
|
||
GMaterials=Helixtoolkit.Wpf.Materials;
|
||
/// Тип точки
|
||
Point = System.Windows.Point;
|
||
/// Тип 3D-точки
|
||
Point3D = System.Windows.Media.Media3D.Point3D;
|
||
/// Тип 3D-вектора
|
||
Vector3D = System.Windows.Media.Media3D.Vector3D;
|
||
/// Тип 3D-луча
|
||
Ray3D = HelixToolkit.Wpf.Ray3D;
|
||
/// Тип 3D-прямой
|
||
Line3D = class(Ray3D) end;
|
||
/// Тип плоскости
|
||
Plane3D = HelixToolkit.Wpf.Plane3D;
|
||
/// Тип 3D-матрицы
|
||
Matrix3D = System.Windows.Media.Media3D.Matrix3D;
|
||
|
||
var
|
||
hvp: HelixViewport3D;
|
||
LightsGroup: Model3DGroup;
|
||
gvl: GridLinesVisual3D;
|
||
|
||
// -----------------------------------------------------
|
||
//>> Короткие функции модуля Graph3D # Graph3D short functions
|
||
// -----------------------------------------------------
|
||
|
||
/// Возвращает цвет по красной, зеленой и синей составляющей (в диапазоне 0..255)
|
||
function RGB(r, g, b: byte): Color;
|
||
/// Возвращает цвет по красной, зеленой и синей составляющей и параметру прозрачности (в диапазоне 0..255)
|
||
function ARGB(a, r, g, b: byte): Color;
|
||
/// Возвращает серый цвет с интенсивностью b
|
||
function GrayColor(b: byte): Color;
|
||
/// Возвращает случайный цвет
|
||
function RandomColor: Color;
|
||
/// Возвращает полностью прозрачный цвет
|
||
function EmptyColor: Color;
|
||
/// Возвращает точку с координатами (x,y)
|
||
function Pnt(x, y: real): Point;
|
||
/// Возвращает прямоугольник с координатами угла (x,y), шириной w и высотой h
|
||
function Rect(x, y, w, h: real): GRect;
|
||
/// Возвращает 3D-точку с координатами (x,y,z)
|
||
function P3D(x, y, z: real): Point3D;
|
||
/// Возвращает 3D-вектор с координатами (x,y,z)
|
||
function V3D(x, y, z: real): Vector3D;
|
||
/// Возвращает 3D-размер с координатами (x,y,z)
|
||
function Sz3D(x, y, z: real): Size3D;
|
||
|
||
// -----------------------------------------------------
|
||
//>> Graph3D: функции для создания материалов Materials # Graph3D Materials functions
|
||
// -----------------------------------------------------
|
||
/// Диффузный материал
|
||
function DiffuseMaterial(c: Color): Material;
|
||
/// Зеркальный материал
|
||
function SpecularMaterial(specularBrightness: byte; specularpower: real := 100): Material;
|
||
/// Зеркальный материал
|
||
function SpecularMaterial(c: Color; specularpower: real := 100): Material;
|
||
/// Светящийся материал
|
||
function EmissiveMaterial(c: Color): Material;
|
||
/// Материал, формируемый на основе изображения. M,N - количество повторений изображения по ширине и высоте
|
||
function ImageMaterial(fname: string; M: real := 1; N: real := 1): Material;
|
||
/// Радужный материал
|
||
function RainbowMaterial: Material;
|
||
|
||
type
|
||
// -----------------------------------------------------
|
||
//>> Graph3D: класс Materials # Graph3D Materials class
|
||
// -----------------------------------------------------
|
||
///!#
|
||
/// Класс для создания материалов
|
||
Materials = class
|
||
/// Диффузный материал
|
||
class function Diffuse(c: Color) := DiffuseMaterial(c);
|
||
/// Зеркальный материал
|
||
class function Specular(specularBrightness: byte := 255; specularpower: real := 100) := SpecularMaterial(specularBrightness, specularpower);
|
||
/// Зеркальный материал
|
||
class function Specular(c: Color; specularpower: real := 100) := SpecularMaterial(c, specularpower);
|
||
/// Светящийся материал
|
||
class function Emissive(c: Color) := EmissiveMaterial(c);
|
||
/// Материал, формируемый на основе изображения. M,N - количество повторений изображения по ширине и высоте
|
||
class function Image(fname: string; M: real := 1; N: real := 1) := ImageMaterial(fname,M,N);
|
||
/// Радужный материал
|
||
class function Rainbow := RainbowMaterial;
|
||
end;
|
||
|
||
type
|
||
// -----------------------------------------------------
|
||
//>> Graph3D: класс View3DType # Graph3D View3DType class
|
||
// -----------------------------------------------------
|
||
///!#
|
||
/// Класс пространства отображения
|
||
View3DType = class
|
||
private
|
||
procedure SetSGLP(v: boolean) := gvl.Visible := v;
|
||
procedure SetSGL(v: boolean) := Invoke(SetSGLP, v);
|
||
function GetSGL: boolean := InvokeBoolean(()->gvl.Visible);
|
||
|
||
procedure SetSCIP(v: boolean) := hvp.ShowCameraInfo := v;
|
||
procedure SetSCI(v: boolean) := Invoke(SetSCIP, v);
|
||
function GetSCI: boolean := InvokeBoolean(()->hvp.ShowCameraInfo);
|
||
|
||
procedure SetSVCP(v: boolean) := hvp.ShowViewCube := v;
|
||
procedure SetSVC(v: boolean) := Invoke(SetSVCP, v);
|
||
function GetSVC: boolean := InvokeBoolean(()->hvp.ShowViewCube);
|
||
|
||
procedure SetTP(v: string) := hvp.Title := v;
|
||
procedure SetT(v: string) := Invoke(SetTP, v);
|
||
function GetT: string := InvokeString(()->hvp.Title);
|
||
|
||
procedure SetSTP(v: string) := hvp.SubTitle := v;
|
||
procedure SetST(v: string) := Invoke(SetSTP, v);
|
||
function GetST: string := InvokeString(()->hvp.SubTitle);
|
||
|
||
procedure SetCMP(v: HelixToolkit.Wpf.CameraMode) := hvp.CameraMode := v;
|
||
procedure SetCM(v: HelixToolkit.Wpf.CameraMode) := Invoke(SetCMP, v);
|
||
function GetCM: HelixToolkit.Wpf.CameraMode := Invoke&<HelixToolkit.Wpf.CameraMode>(()->hvp.CameraMode);
|
||
|
||
procedure SetBCP(v: GColor) := hvp.Background := new SolidColorBrush(v);
|
||
procedure SetBC(v: GColor) := Invoke(SetBCP, v);
|
||
function GetBC: GColor := Invoke&<GColor>(()->(hvp.Background as SolidColorBrush).Color);
|
||
procedure ExportP(fname: string) := hvp.Viewport.Export(fname, hvp.Background);
|
||
public
|
||
/// Отображать ли координатную систему
|
||
property ShowCoordinateSystem: boolean
|
||
read InvokeBoolean(()->hvp.ShowCoordinateSystem)
|
||
write Invoke(procedure(v: boolean)->hvp.ShowCoordinateSystem := v, value);
|
||
/// Отображать ли координатную сетку
|
||
property ShowGridLines: boolean read GetSGL write SetSGL;
|
||
/// Отображать ли информацию о камере
|
||
property ShowCameraInfo: boolean read GetSCI write SetSCI;
|
||
/// Отображать ли ViewCube
|
||
property ShowViewCube: boolean read GetSVC write SetSVC;
|
||
/// Заголовок пространства отображения
|
||
property Title: string read GetT write SetT;
|
||
/// Подзаголовок пространства отображения
|
||
property SubTitle: string read GetST write SetST;
|
||
/// Режим камеры
|
||
property CameraMode: HelixToolkit.Wpf.CameraMode read GetCM write SetCM;
|
||
/// Цвет фона
|
||
property BackgroundColor: GColor read GetBC write SetBC;
|
||
/// Сохраняет содержимое 3d-окна в файл
|
||
procedure Save(fname: string) := Invoke(ExportP, fname);
|
||
end;
|
||
|
||
// -----------------------------------------------------
|
||
//>> Graph3D: класс CameraType # Graph3D CameraType class
|
||
// -----------------------------------------------------
|
||
///!#
|
||
/// Класс камеры
|
||
CameraType = class
|
||
private
|
||
function Cam: GCamera := hvp.Camera;
|
||
procedure SetPP(p: Point3D);
|
||
begin
|
||
Cam.Position := p;
|
||
end;
|
||
|
||
procedure SetP(p: Point3D) := Invoke(SetPP, p);
|
||
function GetP: Point3D := Invoke&<Point3D>(()->Cam.Position);
|
||
procedure SetLDP(v: Vector3D) := Cam.LookDirection := v;
|
||
procedure SetLD(v: Vector3D) := Invoke(SetLDP, v);
|
||
function GetLD: Vector3D := Invoke&<Vector3D>(()->Cam.LookDirection);
|
||
procedure SetUDP(v: Vector3D) := Cam.UpDirection := v;
|
||
procedure SetUD(v: Vector3D) := Invoke(SetUDP, v);
|
||
function GetUD: Vector3D := Invoke&<Vector3D>(()->Cam.UpDirection);
|
||
procedure SetDP(d: real);
|
||
begin
|
||
var dist := Cam.Position.DistanceTo(P3D(0, 0, 0));
|
||
Cam.Position := Cam.Position.Multiply(d / dist);
|
||
end;
|
||
|
||
procedure SetD(d: real) := Invoke(SetDP, d);
|
||
function GetD: real := InvokeReal(()->Cam.Position.DistanceTo(P3D(0, 0, 0)));
|
||
procedure MoveOnP(x,y,z: real);
|
||
begin
|
||
Cam.Position += V3D(x,y,z)//:= P3D(Cam.Position.
|
||
end;
|
||
procedure MoveOnPV(v: Vector3D);
|
||
begin
|
||
Cam.Position += v;
|
||
end;
|
||
procedure AddMoveForceP(x,y,z: real);
|
||
begin
|
||
hvp.CameraController.ShowCameraTarget := True;
|
||
hvp.CameraController.AddMoveForce(x,y,z);
|
||
end;
|
||
procedure AddRotateForceP(x,y: real);
|
||
begin
|
||
hvp.CameraController.AddRotateForce(x,y);
|
||
end;
|
||
procedure RotateP(axis: Vector3D; angle: real);
|
||
begin
|
||
var look := Cam.LookDirection;
|
||
var q := new Quaternion(axis, angle);
|
||
var qConjugate := q;
|
||
qConjugate.Conjugate();
|
||
|
||
var p := new Quaternion(look.X, look.Y, look.Z, 0);
|
||
var qRotatedPoint := q * p * qConjugate;
|
||
Cam.LookDirection := V3D(qRotatedPoint.X, qRotatedPoint.Y, qRotatedPoint.Z);
|
||
end;
|
||
|
||
public
|
||
/// Позиция камеры
|
||
property Position: Point3D read GetP write SetP;
|
||
/// Направление взгляда камеры
|
||
property LookDirection: Vector3D read GetLD write SetLD;
|
||
/// Направление "вверх" камеры
|
||
property UpDirection: Vector3D read GetUD write SetUD;
|
||
/// Расстояние камеры до начала координат
|
||
property Distanse: real read GetD write SetD;
|
||
|
||
/// Перемещает камеру на вектор (dx,dy,dz)
|
||
procedure MoveOn(dx,dy,dz: real) := Invoke(MoveOnP,dx,dy,dz);
|
||
/// Перемещает камеру на вектор v
|
||
procedure MoveOn(v: Vector3D) := Invoke(MoveOnPV,v);
|
||
/// Обеспечивает плавное движение камеры
|
||
procedure AddMoveForce(ForwardForce,RightForce,UpForce: real) := Invoke(AddMoveForceP,RightForce,UpForce,ForwardForce);
|
||
/// Обеспечивает плавное движение камеры вперед с некоторой силой
|
||
procedure AddForwardForce(Force: real := 0.2) := AddMoveForce(Force,0,0);
|
||
/// Обеспечивает плавное движение камеры назад с некоторой силой
|
||
procedure AddBackwardForce(Force: real := 0.2) := AddMoveForce(-Force,0,0);
|
||
/// Обеспечивает плавное движение камеры вправо
|
||
procedure AddRightForce(Force: real := 0.2) := AddMoveForce(0,Force,0);
|
||
/// Обеспечивает плавное движение камеры влево
|
||
procedure AddLeftForce(Force: real := 0.2) := AddMoveForce(0,-Force,0);
|
||
/// Обеспечивает плавное движение камеры вверх
|
||
procedure AddUpForce(Force: real := 0.2) := AddMoveForce(0,0,Force);
|
||
/// Обеспечивает плавное движение камеры вниз
|
||
procedure AddDownForce(Force: real := 0.2) := AddMoveForce(0,0,-Force);
|
||
/// Обеспечивает плавный поворот камеры
|
||
procedure AddRotateForce(RightForce,UpForce: real) := Invoke(AddRotateForceP,RightForce,UpForce);
|
||
/// Поворачивает камеру на данный угол относительно данной оси
|
||
procedure Rotate(axis: Vector3D; angle: real) := Invoke(RotateP,axis,angle);
|
||
end;
|
||
|
||
///!#
|
||
/// Класс источника света
|
||
LightsType = class
|
||
public
|
||
/// Количество источников света
|
||
property Count: integer read Invoke&<integer>(()->LightsGroup.Children.Count);
|
||
/// Добавляет направленный источник света
|
||
procedure AddDirectionalLight(c: Color; v: Vector3D) := Invoke(()->LightsGroup.Children.Add(new DirectionalLight(c, v)));
|
||
/// Добавляет конусообразный источник света
|
||
procedure AddSpotLight(c: Color; p: Point3D; v: Vector3D; outerconeangle, innerconeangle: real) := Invoke(()->LightsGroup.Children.Add(new SpotLight(c, p, v, outerconeangle, innerconeangle)));
|
||
/// Добавляет точечный источник света
|
||
procedure AddPointLight(c: Color; p: Point3D) := Invoke(()->LightsGroup.Children.Add(new PointLight(c, p)));
|
||
/// Удаляет источник света
|
||
procedure RemoveLight(i: integer) := Invoke(()->LightsGroup.Children.RemoveAt(i));
|
||
{procedure Proba();
|
||
begin
|
||
var p := new PointLight(Colors.Gray, P3D(2, 2, 2));
|
||
p.Color := Colors.Gray;
|
||
p.Position := P3D(3, 3, 3);
|
||
end;}
|
||
end;
|
||
|
||
// -----------------------------------------------------
|
||
//>> Graph3D: класс GridLinesType # Graph3D GridLinesType class
|
||
// -----------------------------------------------------
|
||
///!#
|
||
/// Класс координатной сетки
|
||
GridLinesType = class
|
||
private
|
||
procedure SetW(r: real) := Invoke(procedure(r: real)->gvl.Width := r, r);
|
||
function GetW: real := InvokeReal(()->gvl.Width);
|
||
procedure SetL(r: real) := Invoke(procedure(r: real)->gvl.Length := r, r);
|
||
function GetL: real := InvokeReal(()->gvl.Length);
|
||
procedure SetMj(r: real) := Invoke(procedure(r: real)->gvl.MajorDistance := r, r);
|
||
function GetMj: real := InvokeReal(()->gvl.MajorDistance);
|
||
procedure SetMn(r: real) := Invoke(procedure(r: real)->gvl.MinorDistance := r, r);
|
||
function GetMn: real := InvokeReal(()->gvl.MinorDistance);
|
||
procedure SetN(r: Vector3D) := Invoke(procedure(r: Vector3D)->gvl.Normal := r, r);
|
||
function GetN: Vector3D := Inv(()->gvl.Normal);
|
||
public
|
||
/// Ширина координаной сетки (размер по оси OY)
|
||
property Width: real read GetW write SetW;
|
||
/// Длина координаной сетки (размер по оси OX)
|
||
property Length: real read GetL write SetL;
|
||
/// Вектор нормали координаной сетки
|
||
property Normal: Vector3D read GetN write SetN;
|
||
/// Большое расстояние между линиями координаной сетки
|
||
property MajorDistance: real read GetMj write SetMj;
|
||
/// Маленькое расстояние между линиями координаной сетки
|
||
property MinorDistance: real read GetMn write SetMn;
|
||
end;
|
||
|
||
type
|
||
AnimationBase = class;
|
||
ObjectWithChildren3D = class;
|
||
|
||
// -----------------------------------------------------
|
||
//>> Graph3D: класс Object3D # Graph3D Object3D class
|
||
// -----------------------------------------------------
|
||
///!#
|
||
/// Базовый класс трехмерных объектов
|
||
Object3D = class
|
||
(DependencyObject) // для генерации документации
|
||
private
|
||
model: Visual3D;
|
||
Parent: ObjectWithChildren3D;
|
||
transfgroup := new Transform3DGroup;
|
||
|
||
rotatetransform := new MatrixTransform3D;
|
||
scaletransform := new ScaleTransform3D;
|
||
transltransform: TranslateTransform3D;
|
||
|
||
procedure AddToObject3DList;
|
||
procedure DeleteFromObject3DList;
|
||
|
||
procedure CreateBase0(m: Visual3D; x, y, z: real);
|
||
begin
|
||
model := m;
|
||
transltransform := new TranslateTransform3D(x, y, z);
|
||
//transfgroup.Children.Add(new MatrixTransform3D); // ответственен за поворот. Не храним в отдельной переменной т.к. при повороте меняется сам объект, а не поля объекта!!!
|
||
|
||
transfgroup.Children.Add(rotatetransform);
|
||
transfgroup.Children.Add(scaletransform);
|
||
transfgroup.Children.Add(transltransform);
|
||
|
||
model.Transform := transfgroup;
|
||
hvp.Children.Add(model);
|
||
AddToObject3DList;
|
||
end;
|
||
|
||
procedure SetX(xx: real) := Invoke(()->begin transltransform.OffsetX += xx - Self.X; end);
|
||
function GetX: real := InvokeReal(()->transfgroup.Value.OffsetX);
|
||
procedure SetY(yy: real) := Invoke(()->begin transltransform.OffsetY += yy - Self.Y; end);
|
||
function GetY: real := InvokeReal(()->transfgroup.Value.OffsetY);
|
||
procedure SetZ(zz: real) := Invoke(()->begin transltransform.OffsetZ += zz - Self.Z; end);
|
||
function GetZ: real := InvokeReal(()->transfgroup.Value.OffsetZ);
|
||
function GetPos: Point3D := Invoke&<Point3D>(()->P3D(Self.X, Self.Y, Self.Z));
|
||
|
||
function FindVisual(v: Visual3D): Object3D; virtual;
|
||
begin
|
||
if model = v then
|
||
Result := Self
|
||
end;
|
||
|
||
function GetColor: GColor := EmptyColor;
|
||
procedure SetColor(c: GColor);
|
||
begin end;
|
||
|
||
protected
|
||
function CreateObject: Object3D; virtual;// нужно для клонирования
|
||
begin
|
||
Result := nil;
|
||
end;
|
||
|
||
procedure CloneChildren(from: Object3D); virtual;
|
||
begin
|
||
end;
|
||
|
||
function CloneT: Object3D; virtual;
|
||
begin
|
||
Result := CreateObject;
|
||
Result.CloneChildren(Self);
|
||
|
||
var ind := (model.Transform as Transform3DGroup).Children.IndexOf(rotatetransform);
|
||
(Result.model.Transform as Transform3DGroup).Children[ind] := (model.Transform as Transform3DGroup).Children[ind].Clone;
|
||
Result.rotatetransform := (Result.model.Transform as Transform3DGroup).Children[ind] as MatrixTransform3d;
|
||
//(Result.model.Transform as Transform3DGroup).Children[1] := (model.Transform as Transform3DGroup).Children[1].Clone;
|
||
//(Result.model.Transform as Transform3DGroup).Children[2] := (model.Transform as Transform3DGroup).Children[2].Clone;
|
||
//(Result.model.Transform as Transform3DGroup).Children[3] := (model.Transform as Transform3DGroup).Children[3].Clone; //- почему-то это не нужно!!! с ним не работает!
|
||
end;
|
||
|
||
public
|
||
constructor(model: Visual3D) := CreateBase0(model, 0, 0, 0);
|
||
|
||
/// Координата X
|
||
property X: real read GetX write SetX;
|
||
/// Координата Y
|
||
property Y: real read GetY write SetY;
|
||
/// Координата Z
|
||
property Z: real read GetZ write SetZ;
|
||
/// Перемещает 3D-объект к точке (xx,yy,zz)
|
||
function MoveTo(xx, yy, zz: real): Object3D :=
|
||
Invoke&<Object3D>(()->begin
|
||
transltransform.OffsetX += xx - Self.X;
|
||
transltransform.OffsetY += yy - Self.Y;
|
||
transltransform.OffsetZ += zz - Self.Z;
|
||
Result := Self;
|
||
end);
|
||
/// Перемещает 3D-объект к точке p
|
||
function MoveTo(p: Point3D): Object3D := MoveTo(p.X, p.y, p.z);
|
||
/// Перемещает 3D-объект на вектор (dx,dy,dz)
|
||
function MoveOn(dx, dy, dz: real): Object3D := MoveTo(x + dx, y + dy, z + dz);
|
||
/// Перемещает 3D-объект на вектор v
|
||
function MoveOn(v: Vector3D): Object3D := MoveOn(v.X, v.Y, v.Z);
|
||
/// Перемещает x-координату 3D-объекта на dx
|
||
function MoveOnX(dx: real): Object3D := MoveOn(dx, 0, 0);
|
||
/// Перемещает y-координату 3D-объекта на dy
|
||
function MoveOnY(dy: real): Object3D := MoveOn(0, dy, 0);
|
||
/// Перемещает z-координату 3D-объекта на dz
|
||
function MoveOnZ(dz: real): Object3D := MoveOn(0, 0, dz);
|
||
/// Цвет 3D-объекта
|
||
property Color: GColor read GetColor write SetColor; virtual;
|
||
private
|
||
procedure MoveToProp(p: Point3D) := MoveTo(p);
|
||
|
||
public
|
||
/// Позиция 3D-объекта
|
||
property Position: Point3D read GetPos write MoveToProp;
|
||
|
||
/// Масштабирует 3D-объект в f раз
|
||
function Scale(f: real): Object3D :=
|
||
Invoke&<Object3D>(()->begin
|
||
scaletransform.ScaleX *= f;
|
||
scaletransform.ScaleY *= f;
|
||
scaletransform.ScaleZ *= f;
|
||
Result := Self;
|
||
end);
|
||
/// Масштабирует 3D-объект в f раз по оси OX
|
||
function ScaleX(f: real): Object3D :=
|
||
Invoke&<Object3D>(()->begin
|
||
scaletransform.ScaleX *= f;
|
||
Result := Self;
|
||
end);
|
||
/// Масштабирует 3D-объект в f раз по оси OY
|
||
function ScaleY(f: real): Object3D :=
|
||
Invoke&<Object3D>(()->begin
|
||
scaletransform.ScaleY *= f;
|
||
Result := Self;
|
||
end);
|
||
/// Масштабирует 3D-объект в f раз по оси OZ
|
||
function ScaleZ(f: real): Object3D :=
|
||
Invoke&<Object3D>(()->begin
|
||
scaletransform.ScaleZ *= f;
|
||
Result := Self;
|
||
end);
|
||
/// Поворачивает объект на угол angle вокруг оси axis
|
||
function Rotate(axis: Vector3D; angle: real): Object3D :=
|
||
Invoke&<Object3D>(()->begin
|
||
var m := Matrix3D.Identity;
|
||
m.Rotate(new Quaternion(axis, angle));
|
||
var ind := transfgroup.Children.IndexOf(rotatetransform);
|
||
rotatetransform := new MatrixTransform3D(m * rotatetransform.Value);
|
||
transfgroup.Children[ind] := rotatetransform;
|
||
Result := Self;
|
||
end);
|
||
/// Поворачивает объект на угол angle вокруг оси axis относительно точки center
|
||
function RotateAt(axis: Vector3D; angle: real; center: Point3D): Object3D :=
|
||
Invoke&<Object3D>(()->begin
|
||
var m := Matrix3D.Identity;
|
||
m.RotateAt(new Quaternion(axis, angle), center);
|
||
var ind := transfgroup.Children.IndexOf(rotatetransform);
|
||
rotatetransform := new MatrixTransform3D(m * rotatetransform.Value);
|
||
transfgroup.Children[ind] := rotatetransform;
|
||
Result := Self;
|
||
end);
|
||
/// Возвращает анимацию перемещения объекта к точке (x, y, z) за seconds секунд. В конце анимации выполняется процедура Completed
|
||
function AnimMoveTo(x, y, z: real; seconds: real; Completed: procedure): AnimationBase;
|
||
/// Возвращает анимацию перемещения объекта к точке (x, y, z) за seconds секунд
|
||
function AnimMoveTo(x, y, z: real; seconds: real := 1): AnimationBase := AnimMoveTo(x,y,z,seconds,nil);
|
||
/// Возвращает анимацию перемещения объекта к точке p за seconds секунд. В конце анимации выполняется процедура Completed
|
||
function AnimMoveTo(p: Point3D; seconds: real; Completed: procedure) := AnimMoveTo(p.x, p.y, p.z, seconds, Completed);
|
||
/// Возвращает анимацию перемещения объекта к точке p за seconds секунд
|
||
function AnimMoveTo(p: Point3D; seconds: real := 1) := AnimMoveTo(p.x, p.y, p.z, seconds, nil);
|
||
/// Возвращает анимацию перемещения объекта по траектории, заданной последовательностью точек trajectory за seconds секунд. В конце анимации выполняется процедура Completed
|
||
function AnimMoveTrajectory(trajectory: sequence of Point3D; seconds: real; Completed: procedure): AnimationBase;
|
||
/// Возвращает анимацию перемещения объекта по траектории, заданной последовательностью точек trajectory за seconds секунд
|
||
function AnimMoveTrajectory(trajectory: sequence of Point3D; seconds: real := 1): AnimationBase := AnimMoveTrajectory(trajectory,seconds,nil);
|
||
|
||
/// Возвращает анимацию перемещения объекта на вектор (dx, dy, dz) за seconds секунд. В конце анимации выполняется процедура Completed
|
||
function AnimMoveOn(dx, dy, dz: real; seconds: real; Completed: procedure): AnimationBase;
|
||
/// Возвращает анимацию перемещения объекта на вектор (dx, dy, dz) за seconds секунд
|
||
function AnimMoveOn(dx, dy, dz: real; seconds: real := 1): AnimationBase := AnimMoveOn(dx,dy,dz,seconds,nil);
|
||
|
||
/// Возвращает анимацию перемещения объекта на вектор v за seconds секунд. В конце анимации выполняется процедура Completed
|
||
function AnimMoveOn(v: Vector3D; seconds: real; Completed: procedure) := AnimMoveOn(v.x, v.y, v.z, seconds, Completed);
|
||
/// Возвращает анимацию перемещения объекта на вектор v за seconds секунд
|
||
function AnimMoveOn(v: Vector3D; seconds: real := 1) := AnimMoveOn(v.x, v.y, v.z, seconds, nil);
|
||
|
||
/// Возвращает анимацию перемещения объекта по оси OX на величину dx за seconds секунд. В конце анимации выполняется процедура Completed
|
||
function AnimMoveOnX(dx: real; seconds: real; Completed: procedure) := AnimMoveOn(dx, 0, 0, seconds, Completed);
|
||
/// Возвращает анимацию перемещения объекта по оси OX на величину dx за seconds секунд
|
||
function AnimMoveOnX(dx: real; seconds: real) := AnimMoveOnX(dx, seconds, nil);
|
||
/// Возвращает анимацию перемещения объекта по оси OX на величину dx за 1 секунду
|
||
function AnimMoveOnX(dx: real) := AnimMoveOnX(dx, 1, nil);
|
||
|
||
/// Возвращает анимацию перемещения объекта по оси OY на величину dy за seconds секунд. В конце анимации выполняется процедура Completed
|
||
function AnimMoveOnY(dy: real; seconds: real; Completed: procedure) := AnimMoveOn(0, dy, 0, seconds, Completed);
|
||
/// Возвращает анимацию перемещения объекта по оси OY на величину dy за seconds секунд
|
||
function AnimMoveOnY(dy: real; seconds: real) := AnimMoveOnY(dy, seconds, nil);
|
||
/// Возвращает анимацию перемещения объекта по оси OZ на величину dz за 1 секунду
|
||
function AnimMoveOnY(dy: real) := AnimMoveOnY(dy, 1, nil);
|
||
|
||
/// Возвращает анимацию перемещения объекта по оси OZ на величину dz за seconds секунд. В конце анимации выполняется процедура Completed
|
||
function AnimMoveOnZ(dz: real; seconds: real; Completed: procedure) := AnimMoveOn(0, 0, dz, seconds, Completed);
|
||
/// Возвращает анимацию перемещения объекта по оси OZ на величину dz за seconds секунд
|
||
function AnimMoveOnZ(dz: real; seconds: real) := AnimMoveOnZ(dz, seconds, nil);
|
||
/// Возвращает анимацию перемещения объекта по оси OZ на величину dz за 1 секунду
|
||
function AnimMoveOnZ(dz: real) := AnimMoveOnZ(dz, 1, nil);
|
||
|
||
/// Возвращает анимацию масштабирования объекта на величину sc за seconds секунд. В конце анимации выполняется процедура Completed
|
||
function AnimScale(sc: real; seconds: real; Completed: procedure): AnimationBase;
|
||
/// Возвращает анимацию масштабирования объекта по оси OX на величину sc за seconds секунд. В конце анимации выполняется процедура Completed
|
||
function AnimScaleX(sc: real; seconds: real; Completed: procedure): AnimationBase;
|
||
/// Возвращает анимацию масштабирования объекта по оси OY на величину sc за seconds секунд. В конце анимации выполняется процедура Completed
|
||
function AnimScaleY(sc: real; seconds: real; Completed: procedure): AnimationBase;
|
||
/// Возвращает анимацию масштабирования объекта по оси OZ на величину sc за seconds секунд. В конце анимации выполняется процедура Completed
|
||
function AnimScaleZ(sc: real; seconds: real; Completed: procedure): AnimationBase;
|
||
|
||
/// Возвращает анимацию масштабирования объекта на величину sc за seconds секунд
|
||
function AnimScale(sc: real; seconds: real := 1): AnimationBase := AnimScale(sc,seconds,nil);
|
||
/// Возвращает анимацию масштабирования объекта по оси OX на величину sc за seconds секунд
|
||
function AnimScaleX(sc: real; seconds: real := 1): AnimationBase := AnimScale(sc,seconds,nil);
|
||
/// Возвращает анимацию масштабирования объекта по оси OY на величину sc за seconds секунд
|
||
function AnimScaleY(sc: real; seconds: real := 1): AnimationBase := AnimScale(sc,seconds,nil);
|
||
/// Возвращает анимацию масштабирования объекта по оси OZ на величину sc за seconds секунд
|
||
function AnimScaleZ(sc: real; seconds: real := 1): AnimationBase := AnimScale(sc,seconds,nil);
|
||
|
||
/// Возвращает анимацию поворота объекта вокруг вектора (vx,vy,vz) на величину angle за seconds секунд. В конце анимации выполняется процедура Completed
|
||
function AnimRotate(vx, vy, vz, angle: real; seconds: real; Completed: procedure): AnimationBase;
|
||
/// Возвращает анимацию поворота объекта вокруг вектора (vx,vy,vz) на величину angle за seconds секунд
|
||
function AnimRotate(vx, vy, vz, angle: real; seconds: real := 1): AnimationBase := AnimRotate(vx,vy,vz,angle,seconds,nil);
|
||
|
||
/// Возвращает анимацию поворота объекта вокруг вектора v, направленного из центра объекта, на величину angle за seconds секунд. В конце анимации выполняется процедура Completed
|
||
function AnimRotate(v: Vector3D; angle: real; seconds: real; Completed: procedure) := AnimRotate(v.x, v.y, v.z, angle, seconds, Completed);
|
||
/// Возвращает анимацию поворота объекта вокруг вектора v, направленного из центра объекта, на величину angle за seconds секунд
|
||
function AnimRotate(v: Vector3D; angle: real; seconds: real := 1) := AnimRotate(v.x, v.y, v.z, angle, seconds, nil);
|
||
|
||
/// Возвращает анимацию поворота объекта вокруг вектора axis, направленного из точки center, на величину angle за seconds секунд. В конце анимации выполняется процедура Completed
|
||
function AnimRotateAt(axis: Vector3D; angle: real; center: Point3D; seconds: real; Completed: procedure): AnimationBase;
|
||
/// Возвращает анимацию поворота объекта вокруг вектора axis, направленного из точки center, на величину angle за seconds секунд
|
||
function AnimRotateAt(axis: Vector3D; angle: real; center: Point3D; seconds: real := 1): AnimationBase := AnimRotateAt(axis,angle,center,seconds,nil);
|
||
|
||
/// Клонирует 3D-объект
|
||
function Clone: Object3D := Invoke&<Object3D>(CloneT);
|
||
private
|
||
procedure SaveP(fname: string);
|
||
begin
|
||
var f := new System.IO.StreamWriter(fname);
|
||
XamlWriter.Save(Model, f);
|
||
f.Close()
|
||
end;
|
||
public
|
||
/// Сохраняет 3D-объект в файл
|
||
procedure Save(fname: string); virtual := Invoke(SaveP, fname); // надо её сделать виртуальной!
|
||
class function Load(fname: string): Object3D := Invoke&<Object3D>(()->begin
|
||
var m := XamlReader.Load(new System.IO.FileStream(fname, System.IO.FileMode.Open)) as Visual3D;
|
||
Result := new Object3D(m);
|
||
end);
|
||
/// Удаляет 3D-объект
|
||
procedure Destroy(); virtual := DeleteFromObject3DList;
|
||
end;
|
||
|
||
// -----------------------------------------------------
|
||
//>> Graph3D: класс ObjectWithChildren3D # Graph3D ObjectWithChildren3D class
|
||
// -----------------------------------------------------
|
||
/// 3D-объект с дочерними подобъектами
|
||
ObjectWithChildren3D = class(Object3D) // model is ModelVisual3D
|
||
private
|
||
l := new List<Object3D>;
|
||
|
||
procedure DestroyT;
|
||
begin
|
||
end;
|
||
|
||
procedure AddT(obj: Object3D);
|
||
begin
|
||
var p := Self;
|
||
while p <> nil do
|
||
begin
|
||
if obj = p then
|
||
raise new System.ArgumentException('Group.Add: Нельзя в дочерние элементы группы добавить себя или своего предка');
|
||
p := p.Parent
|
||
end;
|
||
if obj.Parent = Self then
|
||
exit;
|
||
|
||
if obj.Parent = nil then
|
||
hvp.Children.Remove(obj.model)
|
||
else
|
||
begin
|
||
var q := obj.Parent.model as ModelVisual3D;
|
||
q.Children.Remove(obj.model);
|
||
obj.Parent.l.Remove(obj);
|
||
end;
|
||
|
||
(model as ModelVisual3D).Children.Add(obj.model);
|
||
l.Add(obj);
|
||
obj.Parent := Self;
|
||
end;
|
||
|
||
procedure RemoveT(obj: Object3D);
|
||
begin
|
||
var b := (model as ModelVisual3D).Children.Remove(obj.model);
|
||
if not b then exit;
|
||
l.Remove(obj);
|
||
hvp.Children.Add(obj.model);
|
||
obj.Parent := nil;
|
||
end;
|
||
|
||
function GetObj(i: integer): Object3D := l[i];
|
||
function CountT: integer := (model as ModelVisual3D).Children.Count;
|
||
function FindVisual(v: Visual3D): Object3D; override;
|
||
begin
|
||
Result := nil;
|
||
if model = v then
|
||
Result := Self
|
||
else
|
||
foreach var x in l do
|
||
begin
|
||
Result := x.FindVisual(v);
|
||
if Result <> nil then
|
||
exit;
|
||
end;
|
||
end;
|
||
|
||
protected
|
||
procedure CloneChildren(from: Object3D); override;
|
||
begin
|
||
var ll := (from as ObjectWithChildren3D).l;
|
||
if ll.Count = 0 then exit;
|
||
foreach var xx in ll do
|
||
AddChild(xx.Clone);
|
||
end;
|
||
|
||
public
|
||
/// Добавить дочерний подобъект
|
||
procedure AddChild(obj: Object3D) := Invoke(AddT, obj);
|
||
/// i-тый дочерний подобъект
|
||
property Items[i: integer]: Object3D read GetObj; default;
|
||
|
||
/// Количество дочерних подобъектов
|
||
function Count: integer := Invoke&<integer>(CountT);
|
||
|
||
private
|
||
procedure DestroyP;
|
||
begin
|
||
if Parent = nil then
|
||
hvp.Children.Remove(model)
|
||
else
|
||
begin
|
||
var q := Parent.model as ModelVisual3D;
|
||
q.Children.Remove(model);
|
||
Parent.l.Remove(Self);
|
||
end;
|
||
model := nil;
|
||
end;
|
||
|
||
public
|
||
/// Удалить дочерний подобъект
|
||
procedure Destroy; override;
|
||
begin
|
||
inherited Destroy;
|
||
Invoke(DestroyP);
|
||
end;
|
||
end;
|
||
|
||
// -----------------------------------------------------
|
||
//>> Graph3D: класс ObjectWithMaterial3D # Graph3D ObjectWithMaterial3D class
|
||
// -----------------------------------------------------
|
||
/// 3D-объект с материалом
|
||
ObjectWithMaterial3D = class(ObjectWithChildren3D) // model is MeshElement3D
|
||
private
|
||
procedure CreateBase(m: MeshElement3D; x, y, z: real; mat: GMaterial);
|
||
begin
|
||
CreateBase0(m, x, y, z);
|
||
m.Material := mat;
|
||
//MaterialHelper.ChangeOpacity(mat,0.1);
|
||
//MaterialHelper.ChangeOpacity(BackMaterial,0.1);
|
||
//m.BackMaterial := nil;
|
||
end;
|
||
|
||
function GetColorP: GColor;
|
||
begin
|
||
Result := EmptyColor;
|
||
var g := Material as System.Windows.Media.Media3D.MaterialGroup;
|
||
if g = nil then exit;
|
||
var t := g.Children[0] as System.Windows.Media.Media3D.DiffuseMaterial;
|
||
if t = nil then exit;
|
||
var v := t.Brush as System.Windows.Media.SolidColorBrush;
|
||
if v = nil then exit;
|
||
Result := v.Color;
|
||
end;
|
||
|
||
function GetColor: GColor := Invoke&<GColor>(GetColorP);
|
||
procedure SetColorP(c: GColor) := (model as MeshElement3D).Material := MaterialHelper.CreateMaterial(c);
|
||
procedure SetColor(c: GColor) := Invoke(SetColorP, c);
|
||
procedure SetVP(v: boolean) := (model as MeshElement3D).Visible := v;
|
||
procedure SetV(v: boolean) := Invoke(SetVP, v);
|
||
function GetV: boolean := Invoke&<boolean>(()->(model as MeshElement3D).Visible);
|
||
|
||
procedure SetMP(mat: GMaterial) := (model as MeshElement3D).Material := mat;
|
||
procedure SetMaterial(mat: GMaterial) := Invoke(SetMP, mat);
|
||
function GetMaterial: GMaterial := Invoke&<GMaterial>(()->(model as MeshElement3D).Material);
|
||
procedure SetBMP(mat: GMaterial) := (model as MeshElement3D).BackMaterial := mat;
|
||
procedure SetBMaterial(mat: GMaterial) := Invoke(SetBMP, mat);
|
||
function GetBMaterial: GMaterial := Invoke&<GMaterial>(()->(model as MeshElement3D).BackMaterial);
|
||
public
|
||
/// Цвет объекта
|
||
property Color: GColor read GetColor write SetColor; override;
|
||
/// Материал объекта
|
||
property Material: GMaterial read GetMaterial write SetMaterial;
|
||
/// Материал задней поверхности объекта
|
||
property BackMaterial: GMaterial read GetBMaterial write SetBMaterial;
|
||
/// Видим ли объект
|
||
property Visible: boolean read GetV write SetV;
|
||
end;
|
||
|
||
/// Группа 3D-объектов
|
||
Group3D = class(ObjectWithChildren3D)
|
||
protected
|
||
function CreateObject: Object3D; override := new Group3D(X, Y, Z);
|
||
public
|
||
constructor(x, y, z: real) := CreateBase0(new ModelVisual3D, x, y, z);
|
||
|
||
constructor(x, y, z: real; lst: sequence of Object3D);
|
||
begin
|
||
CreateBase0(new ModelVisual3D, x, y, z);
|
||
foreach var xx in lst do
|
||
AddChild(xx);
|
||
end;
|
||
|
||
/// ВОзвращает клон группы 3D-объектов
|
||
function Clone := (inherited Clone) as Group3D;
|
||
end;
|
||
|
||
//------------------------------ Animations -----------------------------------
|
||
|
||
// -----------------------------------------------------
|
||
//>> Graph3D: класс AnimationBase # Graph3D AnimationBase class
|
||
// -----------------------------------------------------
|
||
/// Базовый класс анимации 3D-объектов
|
||
AnimationBase = class
|
||
private
|
||
Element: Object3D;
|
||
Seconds: real;
|
||
// Completed - действие при завершении элементарной (не составной) анимации (имеющей единую продолжительность).
|
||
// Не учитывается составными анимациями - у них есть AnimationCompleted. Работает точнее чем sb.Completed.
|
||
Completed: procedure;
|
||
// AnimationCompleted - фигурирует только в WhenCompleted. Неточна. После неё индивидуальные анимации делают ещё один шаг
|
||
AnimationCompleted: procedure;
|
||
ApplyDecorators := new List<Action0>;
|
||
procedure ApplyAllDecorators; virtual;
|
||
begin
|
||
foreach var d in ApplyDecorators do
|
||
d();
|
||
end;
|
||
|
||
procedure InitAnimWait; virtual;
|
||
begin
|
||
end;
|
||
|
||
private
|
||
class function AddDoubleAnimRemainderHelper(d: DoubleAnimationBase; sb: StoryBoard; seconds: real; ttname: string; prop: Object): DoubleAnimationBase;
|
||
begin
|
||
d.Duration := new System.Windows.Duration(System.TimeSpan.FromSeconds(seconds));
|
||
StoryBoard.SetTargetName(d, ttname);
|
||
StoryBoard.SetTargetProperty(d, new PropertyPath(prop));
|
||
sb.Children.Add(d);
|
||
Result := d;
|
||
end;
|
||
|
||
protected
|
||
sb: StoryBoard;
|
||
|
||
class function AddDoubleAnimByName(sb: StoryBoard; toValue, seconds: real; ttname: string; prop: Object): DoubleAnimationBase;
|
||
begin
|
||
var d := new DoubleAnimation();
|
||
d.To := toValue;
|
||
Result := AddDoubleAnimRemainderHelper(d, sb, seconds, ttname, prop);
|
||
end;
|
||
|
||
class function AddDoubleAnimOnByName(sb: StoryBoard; toValue, seconds: real; ttname: string; prop: Object): DoubleAnimationBase;
|
||
begin
|
||
var d := new DoubleAnimation();
|
||
d.By := toValue;
|
||
Result := AddDoubleAnimRemainderHelper(d, sb, seconds, ttname, prop);
|
||
end;
|
||
|
||
class function AddDoubleAnimByNameUsingKeyframes(sb: StoryBoard; a: sequence of real; seconds: real; ttname: string; prop: Object): DoubleAnimationBase;
|
||
begin
|
||
var d := new DoubleAnimationUsingKeyframes;
|
||
d.KeyFrames := new DoubleKeyFrameCollection;
|
||
foreach var x in a do
|
||
d.KeyFrames.Add(new LinearDoubleKeyFrame(x)); // не указываем keytime - надеемся, что по секунде
|
||
Result := AddDoubleAnimRemainderHelper(d, sb, seconds, ttname, prop);
|
||
end;
|
||
|
||
{class function AddDoubleAnimByNameUsingTrajectory(sb: StoryBoard; a: sequence of real; seconds: real; ttname: string; prop: Object; waittime: real := 0.0): DoubleAnimationBase;
|
||
begin
|
||
var d := new DoubleAnimationUsingKeyframes;
|
||
d.KeyFrames := new DoubleKeyFrameCollection;
|
||
foreach var x in a do
|
||
d.KeyFrames.Add(new LinearDoubleKeyFrame(x)); // не указываем keytime - надеемся, что по секунде
|
||
d.Duration := new System.Windows.Duration(System.TimeSpan.FromSeconds(seconds));
|
||
d.BeginTime := System.TimeSpan.FromSeconds(waittime);
|
||
StoryBoard.SetTargetName(d, ttname);
|
||
StoryBoard.SetTargetProperty(d, new PropertyPath(prop));
|
||
sb.Children.Add(d);
|
||
Result := d;
|
||
end;}
|
||
|
||
function RegisterName(sb: StoryBoard; element: Object; ttname: string): boolean;
|
||
begin
|
||
Result := False;
|
||
if MainWindow.FindName(ttname) = nil then
|
||
begin
|
||
MainWindow.RegisterName(ttname, element);
|
||
sb.Completed += (o, e) -> begin
|
||
if MainWindow.FindName(ttname) <> nil then
|
||
MainWindow.UnregisterName(ttname);
|
||
end;
|
||
Result := True;
|
||
end;
|
||
end;
|
||
|
||
procedure InitAnim; virtual := InitAnimWait;
|
||
private
|
||
function CreateStoryboard: StoryBoard;
|
||
begin
|
||
sb := new StoryBoard;
|
||
var storyboardName := 's' + sb.GetHashCode;
|
||
MainWindow.Resources.Add(storyboardName, sb);
|
||
var an := AnimationCompleted;
|
||
sb.Completed += (o, e) -> begin
|
||
MainWindow.Resources.Remove(storyboardName);
|
||
if an <> nil then
|
||
an;
|
||
end;
|
||
|
||
Result := sb;
|
||
end;
|
||
|
||
public
|
||
constructor(e: Object3D; sec: real; Completed: procedure := nil);
|
||
begin
|
||
Self.Completed := Completed;
|
||
(Element, Seconds) := (e, sec);
|
||
end;
|
||
|
||
/// Устанавливает действие по завершению анимации
|
||
function WhenCompleted(act: procedure): AnimationBase;
|
||
begin
|
||
Self.AnimationCompleted := act;
|
||
Result := Self;
|
||
end;
|
||
|
||
private
|
||
procedure BeginT;
|
||
begin
|
||
sb := CreateStoryboard;
|
||
InitAnim;
|
||
|
||
ApplyAllDecorators;
|
||
sb.Begin;
|
||
end;
|
||
|
||
procedure RemoveT := begin
|
||
sb.Pause;
|
||
sb.Remove;
|
||
sb := new Storyboard;
|
||
end;
|
||
procedure ChangeT(a: AnimationBase);
|
||
begin
|
||
sb := CreateStoryboard;
|
||
foreach var d in a.sb.Children do
|
||
sb.Children.Add(d);
|
||
end;
|
||
|
||
public
|
||
/// Начинает анимацию
|
||
procedure &Begin; virtual := Invoke(BeginT);
|
||
/// Удаляет анимацию
|
||
procedure Remove := Invoke(RemoveT);
|
||
/// Меняет анимацию на другую
|
||
procedure Change(a: AnimationBase) := Invoke(ChangeT, a);
|
||
/// Делает паузу анимации
|
||
procedure Pause := if sb <> nil then sb.Pause;
|
||
/// Возобновляет анимацию
|
||
procedure Resume := if sb <> nil then sb.Resume;
|
||
|
||
/// Возвращает продолжительность анимации
|
||
function Duration: real; virtual := seconds;
|
||
/// Указывает анимацию, выполняющуюся после данной
|
||
function &Then(second: AnimationBase): AnimationBase;
|
||
/// Модификатор анимации, выполняющий её бесконечно. Не может быть применен к группе анимаций
|
||
function Forever: AnimationBase; virtual := Self;
|
||
/// Модификатор анимации, возвращающий объект в исходное положение. Не может быть применен к группе анимаций
|
||
function AutoReverse: AnimationBase; virtual := Self;
|
||
/// Модификатор анимации, устанавливающий ускорение анимации в начале и замедление анимации в конце
|
||
function AccelerationRatio(acceleration: real; deceleration: real := 0): AnimationBase; virtual := Self;
|
||
end;
|
||
|
||
EmptyAnimation = class(AnimationBase)
|
||
public
|
||
constructor(wait: real) := Seconds := wait;
|
||
procedure InitAnim(); override := InitAnimWait;
|
||
end;
|
||
|
||
|
||
Double1AnimationBase = class(AnimationBase)
|
||
private
|
||
v: real;
|
||
da: DoubleAnimationBase;
|
||
public
|
||
constructor(e: Object3D; sec: real; value: real; Completed: procedure := nil);
|
||
begin
|
||
inherited Create(e, sec, Completed);
|
||
v := value;
|
||
end;
|
||
|
||
function AutoReverse: AnimationBase; override;
|
||
begin
|
||
ApplyDecorators.Add(()-> begin
|
||
da.AutoReverse := True;
|
||
end);
|
||
Result := Self;
|
||
end;
|
||
|
||
function Forever: AnimationBase; override;
|
||
begin
|
||
ApplyDecorators.Add(()-> begin
|
||
da.RepeatBehavior := RepeatBehavior.Forever;
|
||
end);
|
||
Result := Self;
|
||
end;
|
||
|
||
function AccelerationRatio(acceleration: real; deceleration: real := 0): AnimationBase; override;
|
||
begin
|
||
if acceleration < 0 then acceleration := 0;
|
||
if acceleration > 1 then acceleration := 1;
|
||
if deceleration < 0 then deceleration := 0;
|
||
if deceleration > 1 then deceleration := 1;
|
||
if acceleration + deceleration > 1 then
|
||
begin
|
||
acceleration /= acceleration + deceleration;
|
||
deceleration := 1 - acceleration;
|
||
end;
|
||
ApplyDecorators.Add(()-> begin
|
||
da.AccelerationRatio := acceleration;
|
||
da.DecelerationRatio := deceleration;
|
||
end);
|
||
Result := Self;
|
||
end;
|
||
end;
|
||
|
||
Double3AnimationBase = class(AnimationBase)
|
||
private
|
||
x, y, z: real;
|
||
dax, day, daz: DoubleAnimationBase;
|
||
public
|
||
constructor(e: Object3D; sec: real; xx, yy, zz: real; Completed: procedure := nil);
|
||
begin
|
||
inherited Create(e, sec, Completed);
|
||
(x, y, z) := (xx, yy, zz);
|
||
end;
|
||
|
||
function AutoReverse: AnimationBase; override;
|
||
begin
|
||
ApplyDecorators.Add(()-> begin
|
||
dax.AutoReverse := True;
|
||
day.AutoReverse := True;
|
||
daz.AutoReverse := True;
|
||
end);
|
||
Result := Self;
|
||
end;
|
||
|
||
function Forever: AnimationBase; override;
|
||
begin
|
||
ApplyDecorators.Add(()-> begin
|
||
dax.RepeatBehavior := RepeatBehavior.Forever;
|
||
day.RepeatBehavior := RepeatBehavior.Forever;
|
||
daz.RepeatBehavior := RepeatBehavior.Forever;
|
||
end);
|
||
Result := Self;
|
||
end;
|
||
|
||
function AccelerationRatio(acceleration: real; deceleration: real := 0): AnimationBase; override;
|
||
begin
|
||
if acceleration < 0 then acceleration := 0;
|
||
if acceleration > 1 then acceleration := 1;
|
||
if deceleration < 0 then deceleration := 0;
|
||
if deceleration > 1 then deceleration := 1;
|
||
if acceleration + deceleration > 1 then
|
||
begin
|
||
acceleration /= acceleration + deceleration;
|
||
deceleration := 1 - acceleration;
|
||
end;
|
||
ApplyDecorators.Add(()-> begin
|
||
dax.AccelerationRatio := acceleration;
|
||
day.AccelerationRatio := acceleration;
|
||
daz.AccelerationRatio := acceleration;
|
||
dax.DecelerationRatio := deceleration;
|
||
day.DecelerationRatio := deceleration;
|
||
daz.DecelerationRatio := deceleration;
|
||
end);
|
||
Result := Self;
|
||
end;
|
||
end;
|
||
|
||
OffsetAnimationOn = class(Double3AnimationBase)
|
||
private
|
||
el: TranslateTransform3D;
|
||
procedure Hand(o: object; e: System.EventArgs);
|
||
begin
|
||
var el0 := Element.transltransform;
|
||
el0.OffsetX += el.OffsetX;
|
||
el0.OffsetY += el.OffsetY;
|
||
el0.OffsetZ += el.OffsetZ;
|
||
Element.transfgroup.Children.Remove(el);
|
||
if Completed <> nil then
|
||
Completed();
|
||
end;
|
||
|
||
procedure InitAnimWait; override;
|
||
begin
|
||
el := new TranslateTransform3D();
|
||
Element.transfgroup.Children.Add(el);
|
||
var ttname := 't' + el.GetHashCode;
|
||
if not RegisterName(sb, el, ttname) then;
|
||
dax := AddDoubleAnimOnByName(sb, x, seconds, ttname, TranslateTransform3D.OffsetXProperty);
|
||
day := AddDoubleAnimOnByName(sb, y, seconds, ttname, TranslateTransform3D.OffsetYProperty);
|
||
daz := AddDoubleAnimOnByName(sb, z, seconds, ttname, TranslateTransform3D.OffsetZProperty);
|
||
daz.Completed += Hand;
|
||
end;
|
||
public
|
||
end;
|
||
|
||
OffsetAnimation = class(OffsetAnimationOn)
|
||
procedure InitAnimWait; override;
|
||
begin
|
||
el := new TranslateTransform3D();
|
||
Element.transfgroup.Children.Add(el);
|
||
var ttname := 't' + el.GetHashCode;
|
||
if not RegisterName(sb, el, ttname) then;
|
||
dax := AddDoubleAnimOnByName(sb, x-Element.x, seconds, ttname, TranslateTransform3D.OffsetXProperty);
|
||
day := AddDoubleAnimOnByName(sb, y-Element.y, seconds, ttname, TranslateTransform3D.OffsetYProperty);
|
||
daz := AddDoubleAnimOnByName(sb, z-Element.z, seconds, ttname, TranslateTransform3D.OffsetZProperty);
|
||
daz.Completed += Hand;
|
||
end;
|
||
public
|
||
end;
|
||
|
||
OffsetAnimationUsingKeyframes = class(Double3AnimationBase)
|
||
private
|
||
el: TranslateTransform3D;
|
||
a: sequence of Point3D;
|
||
procedure Hand(o: object; e: System.EventArgs);
|
||
begin
|
||
var el0 := Element.transltransform;
|
||
el0.OffsetX += el.OffsetX;
|
||
el0.OffsetY += el.OffsetY;
|
||
el0.OffsetZ += el.OffsetZ;
|
||
Element.transfgroup.Children.Remove(el);
|
||
if Completed <> nil then
|
||
Completed();
|
||
end;
|
||
procedure InitAnimWait; override;
|
||
begin
|
||
el := new TranslateTransform3D();
|
||
Element.transfgroup.Children.Add(el);
|
||
var ttname := 't' + el.GetHashCode;
|
||
if not RegisterName(sb, el, ttname) then;
|
||
var aa := a.ToArray;
|
||
dax := AddDoubleAnimByNameUsingKeyframes(sb, aa.Select(p -> p.x-Element.x), seconds, ttname, TranslateTransform3D.OffsetXProperty);
|
||
day := AddDoubleAnimByNameUsingKeyframes(sb, aa.Select(p -> p.y-Element.y), seconds, ttname, TranslateTransform3D.OffsetYProperty);
|
||
daz := AddDoubleAnimByNameUsingKeyframes(sb, aa.Select(p -> p.z-Element.z), seconds, ttname, TranslateTransform3D.OffsetZProperty);
|
||
daz.Completed += Hand;
|
||
end;
|
||
|
||
public
|
||
constructor(e: Object3D; sec: real; aa: sequence of Point3D; Completed: procedure := nil);
|
||
begin
|
||
inherited Create(e, sec, Completed);
|
||
a := aa;
|
||
end;
|
||
end;
|
||
|
||
ScaleAnimation = class(Double3AnimationBase)
|
||
private
|
||
scale: real;
|
||
el: ScaleTransform3D;
|
||
procedure Hand(o: object; e: System.EventArgs);
|
||
begin
|
||
var el0 := Element.scaletransform;
|
||
el0.ScaleX += el.ScaleX;
|
||
el0.ScaleY += el.ScaleY;
|
||
el0.ScaleZ += el.ScaleZ;
|
||
Element.transfgroup.Children.Remove(el);
|
||
if Completed <> nil then
|
||
Completed();
|
||
end;
|
||
procedure InitAnimWait; override;
|
||
begin
|
||
el := new ScaleTransform3D();
|
||
Element.transfgroup.Children.Add(el);
|
||
var sctransform := Element.scaletransform;
|
||
var ttname := 's' + sctransform.GetHashCode;
|
||
if not RegisterName(sb, sctransform, ttname) then;
|
||
dax := AddDoubleAnimByName(sb, scale, seconds, ttname, ScaleTransform3D.ScaleXProperty);
|
||
day := AddDoubleAnimByName(sb, scale, seconds, ttname, ScaleTransform3D.ScaleYProperty);
|
||
daz := AddDoubleAnimByName(sb, scale, seconds, ttname, ScaleTransform3D.ScaleZProperty);
|
||
daz.Completed += Hand;
|
||
end;
|
||
public
|
||
constructor(e: Object3D; sec: real; sc: real; Completed: procedure := nil);
|
||
begin
|
||
inherited Create(e, sec, Completed);
|
||
scale := sc;
|
||
end;
|
||
end;
|
||
|
||
ScaleXAnimation = class(Double1AnimationBase)
|
||
private
|
||
scale: real;
|
||
el: ScaleTransform3D;
|
||
procedure Hand(o: object; e: System.EventArgs);
|
||
begin
|
||
var el0 := Element.scaletransform;
|
||
el0.ScaleX += el.ScaleX;
|
||
Element.transfgroup.Children.Remove(el);
|
||
if Completed <> nil then
|
||
Completed();
|
||
end;
|
||
procedure InitAnimWait; override;
|
||
begin
|
||
el := new ScaleTransform3D();
|
||
Element.transfgroup.Children.Add(el);
|
||
var sctransform := Element.scaletransform;
|
||
var ttname := 's' + sctransform.GetHashCode;
|
||
if not RegisterName(sb, sctransform, ttname) then;
|
||
da := AddDoubleAnimByName(sb, scale, seconds, ttname, ScaleTransform3D.ScaleXProperty);
|
||
da.Completed += Hand;
|
||
end;
|
||
public
|
||
constructor(e: Object3D; sec: real; sc: real; Completed: procedure := nil);
|
||
begin
|
||
inherited Create(e, sec, Completed);
|
||
scale := sc;
|
||
end;
|
||
end;
|
||
|
||
ScaleYAnimation = class(ScaleXAnimation)
|
||
private
|
||
procedure Hand(o: object; e: System.EventArgs);
|
||
begin
|
||
var el0 := Element.scaletransform;
|
||
el0.ScaleY += el.ScaleY;
|
||
Element.transfgroup.Children.Remove(el);
|
||
if Completed <> nil then
|
||
Completed();
|
||
end;
|
||
procedure InitAnimWait; override;
|
||
begin
|
||
el := new ScaleTransform3D();
|
||
Element.transfgroup.Children.Add(el);
|
||
var sctransform := Element.scaletransform;
|
||
var ttname := 's' + sctransform.GetHashCode;
|
||
if not RegisterName(sb, sctransform, ttname) then;
|
||
da := AddDoubleAnimByName(sb, scale, seconds, ttname, ScaleTransform3D.ScaleYProperty);
|
||
da.Completed += Hand;
|
||
end;
|
||
end;
|
||
|
||
ScaleZAnimation = class(ScaleXAnimation)
|
||
private
|
||
procedure Hand(o: object; e: System.EventArgs);
|
||
begin
|
||
var el0 := Element.scaletransform;
|
||
el0.ScaleZ += el.ScaleZ;
|
||
Element.transfgroup.Children.Remove(el);
|
||
if Completed <> nil then
|
||
Completed();
|
||
end;
|
||
procedure InitAnimWait; override;
|
||
begin
|
||
el := new ScaleTransform3D();
|
||
Element.transfgroup.Children.Add(el);
|
||
var sctransform := Element.scaletransform;
|
||
var ttname := 's' + sctransform.GetHashCode;
|
||
if not RegisterName(sb, sctransform, ttname) then;
|
||
da := AddDoubleAnimByName(sb, scale, seconds, ttname, ScaleTransform3D.ScaleZProperty);
|
||
da.Completed += Hand;
|
||
end;
|
||
end;
|
||
|
||
RotateAtAnimation = class(Double1AnimationBase)
|
||
private
|
||
vx, vy, vz, angle: real;
|
||
center: Point3D;
|
||
el: RotateTransform3D;
|
||
procedure Hand(o: object; e: System.EventArgs);
|
||
begin
|
||
var rot := el.Rotation as AxisAngleRotation3D;
|
||
Element.RotateAt(rot.Axis, angle, center);
|
||
Element.transfgroup.Children.Remove(el);
|
||
if Completed <> nil then
|
||
Completed();
|
||
end;
|
||
|
||
procedure InitAnimWait; override;
|
||
begin
|
||
el := new RotateTransform3D();
|
||
el.Rotation := new AxisAngleRotation3D();
|
||
|
||
Element.transfgroup.Children.Insert(0,el); // До основной матрицы, связанной с поворотом
|
||
var rottransform := el;
|
||
rottransform.CenterX := center.x;
|
||
rottransform.CenterY := center.y;
|
||
rottransform.CenterZ := center.z;
|
||
var rot := rottransform.Rotation as AxisAngleRotation3D;
|
||
var ttname := 'r' + rot.GetHashCode;
|
||
if not RegisterName(sb, rot, ttname) then;
|
||
|
||
rot.Angle := 0; //?
|
||
rot.Axis := V3D(vx, vy, vz); //?
|
||
|
||
//var elem: Object3D := Element;
|
||
// Мб da.Completed
|
||
|
||
da := AddDoubleAnimByName(sb, angle, seconds, ttname, AxisAngleRotation3D.AngleProperty);
|
||
da.Completed += Hand;
|
||
end;
|
||
|
||
public
|
||
constructor(e: Object3D; sec: real; vvx, vvy, vvz, a: real; c: Point3D; Completed: procedure := nil);
|
||
begin
|
||
inherited Create(e, sec, Completed);
|
||
(vx, vy, vz, angle, center) := (vvx, vvy, vvz, a, c)
|
||
end;
|
||
end;
|
||
|
||
CompositeAnimation = class(AnimationBase)
|
||
private
|
||
ll: List<AnimationBase>;
|
||
public
|
||
constructor(params l: array of AnimationBase) := ll := Lst(l);
|
||
constructor(l: List<AnimationBase>) := ll := l;
|
||
end;
|
||
|
||
GroupAnimation = class(CompositeAnimation)
|
||
public
|
||
function Duration: real; override := ll.Select(l -> l.Duration).Max;
|
||
function Add(b: AnimationBase): GroupAnimation;
|
||
begin
|
||
ll += b;
|
||
Result := Self;
|
||
end;
|
||
class function operator +=(a: GroupAnimation; b: AnimationBase): GroupAnimation;
|
||
begin
|
||
a.ll += b;
|
||
Result := a;
|
||
end;
|
||
procedure BeginT;
|
||
begin
|
||
for var i:=0 to ll.Count-1 do
|
||
ll[i].Begin;
|
||
end;
|
||
procedure &Begin; override := Invoke(BeginT);
|
||
end;
|
||
|
||
SequenceAnimation = class(CompositeAnimation)
|
||
public
|
||
function Duration: real; override := ll.Select(l -> l.Duration).Sum;
|
||
function Add(b: AnimationBase): SequenceAnimation;
|
||
begin
|
||
ll += b;
|
||
Result := Self;
|
||
end;
|
||
class function operator +=(a: SequenceAnimation; b: AnimationBase): SequenceAnimation;
|
||
begin
|
||
a.ll += b;
|
||
Result := a;
|
||
end;
|
||
procedure BeginT;
|
||
begin
|
||
for var ii:=0 to ll.Count-2 do
|
||
begin
|
||
var i := ii; // параметр цикла неправильно захватывается лямбдой
|
||
var lll := ll; // поле предка - вообще не захватывается
|
||
|
||
// Если ll[i] - CompositeAnimation, то надо повесить Completed на самую правую не CompositeAnimation
|
||
var lf := ll[i];
|
||
while lf is CompositeAnimation do
|
||
begin
|
||
var ca := lf as CompositeAnimation;
|
||
lf := ca.ll[ca.ll.Count-1];
|
||
end;
|
||
|
||
lf.Completed += procedure ->
|
||
begin
|
||
lll[i+1].Begin;
|
||
end;
|
||
end;
|
||
ll[0].Begin;
|
||
end;
|
||
procedure &Begin; override := Invoke(BeginT);
|
||
end;
|
||
|
||
/// Класс, содержащий комбинации анимаций: группа и последовательность
|
||
Animate = class
|
||
public
|
||
/// Возвращает группу анимаций, выполняющихся параллельно
|
||
class function Group(params l: array of AnimationBase) := new GroupAnimation(Lst(l));
|
||
/// Возвращает последовательность анимаций, выполняющихся последовательно
|
||
class function &Sequence(params l: array of AnimationBase) := new SequenceAnimation(l);
|
||
end;
|
||
|
||
type
|
||
// -----------------------------------------------------
|
||
//>> Graph3D: класс SphereT # Graph3D SphereT class
|
||
// -----------------------------------------------------
|
||
/// Класс сферы
|
||
SphereT = class(ObjectWithMaterial3D)
|
||
private
|
||
function Model := inherited model as SphereVisual3D;
|
||
procedure SetRP(r: real) := Model.Radius := r;
|
||
procedure SetR(r: real) := Invoke(SetRP, r);
|
||
function GetR: real := InvokeReal(()->Model.Radius);
|
||
function NewVisualObject(r: real): SphereVisual3D;
|
||
begin
|
||
var sph := new SphereVisual3D;
|
||
sph.Center := P3D(0,0,0);
|
||
sph.Radius := r;
|
||
Result := sph;
|
||
end;
|
||
|
||
protected
|
||
function CreateObject: Object3D; override := new SphereT(X, Y, Z, Radius, Material.Clone);
|
||
constructor := CreateBase(NewVisualObject(1), 0, 0, 0, Materialhelper.CreateMaterial(Colors.Blue));
|
||
constructor(x, y, z, r: real; m: Gmaterial) := CreateBase(NewVisualObject(r), x, y, z, m);
|
||
public
|
||
/// Радиус сферы
|
||
property Radius: real read GetR write SetR;
|
||
/// Возвращает клон сферы
|
||
function Clone := (inherited Clone) as SphereT;
|
||
end;
|
||
|
||
// -----------------------------------------------------
|
||
//>> Graph3D: класс EllipsoidT # Graph3D EllipsoidT class
|
||
// -----------------------------------------------------
|
||
/// Класс эллипсоида
|
||
EllipsoidT = class(ObjectWithMaterial3D)
|
||
private
|
||
function Model := inherited model as EllipsoidVisual3D;
|
||
procedure SetRX(r: real) := Invoke(procedure(r: real)->Model.RadiusX := r, r);
|
||
function GetRX: real := InvokeReal(()->Model.RadiusX);
|
||
procedure SetRYP(r: real) := Model.RadiusY := r;
|
||
procedure SetRY(r: real) := Invoke(SetRYP, r);
|
||
function GetRY: real := InvokeReal(()->Model.RadiusY);
|
||
procedure SetRZP(r: real) := Model.RadiusZ := r;
|
||
procedure SetRZ(r: real) := Invoke(SetRZP, r);
|
||
function GetRZ: real := InvokeReal(()->Model.RadiusZ);
|
||
function NewVisualObject(rx, ry, rz: real): EllipsoidVisual3D;
|
||
begin
|
||
var ell := new EllipsoidVisual3D;
|
||
ell.Center := P3D(0,0,0);
|
||
ell.RadiusX := rx;
|
||
ell.RadiusY := ry;
|
||
ell.RadiusZ := rz;
|
||
Result := ell;
|
||
end;
|
||
|
||
protected
|
||
function CreateObject: Object3D; override := new EllipsoidT(X, Y, Z, RadiusX, RadiusY, RadiusZ, Material.Clone);
|
||
constructor(x, y, z, rx, ry, rz: real; m: GMaterial) := CreateBase(NewVisualObject(rx, ry, rz), x, y, z, m);
|
||
public
|
||
/// Радиус эллипсоида по оси X
|
||
property RadiusX: real read GetRX write SetRX;
|
||
/// Радиус эллипсоида по оси Y
|
||
property RadiusY: real read GetRY write SetRY;
|
||
/// Радиус эллипсоида по оси Z
|
||
property RadiusZ: real read GetRZ write SetRZ;
|
||
/// Возвращает клон эллипсоида
|
||
function Clone := (inherited Clone) as EllipsoidT;
|
||
end;
|
||
|
||
// -----------------------------------------------------
|
||
//>> Graph3D: класс CubeT # Graph3D CubeT class
|
||
// -----------------------------------------------------
|
||
/// Класс куба
|
||
CubeT = class(ObjectWithMaterial3D)
|
||
private
|
||
function model := inherited model as CubeVisual3D;
|
||
procedure SetWP(r: real) := model.SideLength := r;
|
||
procedure SetW(r: real) := Invoke(SetWP, r);
|
||
function GetW: real := InvokeReal(()->model.SideLength);
|
||
private
|
||
function NewVisualObject(w: real): CubeVisual3D;
|
||
begin
|
||
var bx := new CubeVisual3D;
|
||
bx.Center := P3D(0,0,0);
|
||
bx.SideLength := w;
|
||
Result := bx;
|
||
end;
|
||
|
||
protected
|
||
function CreateObject: Object3D; override := new CubeT(X, Y, Z, SideLength, Material.Clone);
|
||
constructor(x, y, z, w: real; m: GMaterial) := CreateBase(NewVisualObject(w), x, y, z, m);
|
||
|
||
public
|
||
/// Сторона куба
|
||
property SideLength: real read GetW write SetW;
|
||
/// Возвращает клон куба
|
||
function Clone := (inherited Clone) as CubeT;
|
||
end;
|
||
|
||
// -----------------------------------------------------
|
||
//>> Graph3D: класс BoxT # Graph3D BoxT class
|
||
// -----------------------------------------------------
|
||
/// Класс паралеллепипеда
|
||
BoxT = class(ObjectWithMaterial3D)
|
||
private
|
||
function model := inherited model as BoxVisual3D;
|
||
procedure SetWP(r: real) := model.Width := r;
|
||
procedure SetW(r: real) := Invoke(SetWP, r);
|
||
function GetW: real := InvokeReal(()->model.Width);
|
||
|
||
procedure SetHP(r: real) := model.Height := r;
|
||
procedure SetH(r: real) := Invoke(SetHP, r);
|
||
function GetH: real := InvokeReal(()->model.Height);
|
||
|
||
procedure SetLP(r: real) := model.Length := r;
|
||
procedure SetL(r: real) := Invoke(SetLP, r);
|
||
function GetL: real := InvokeReal(()->model.Length);
|
||
|
||
procedure SetSzP(r: Size3D) := (model.Length, model.Width, model.Height) := (r.X, r.Y, r.Z);
|
||
procedure SetSz(r: Size3D) := Invoke(SetSzP, r);
|
||
function GetSz: Size3D := Inv(()->Sz3D(model.Length, model.Width, model.Height));
|
||
private
|
||
function NewVisualObject(l, w, h: real): BoxVisual3D;
|
||
begin
|
||
var bx := new BoxVisual3D;
|
||
bx.Center := P3D(0,0,0);
|
||
(bx.Width, bx.Height, bx.Length) := (w, h, l);
|
||
Result := bx;
|
||
end;
|
||
|
||
protected
|
||
function CreateObject: Object3D; override := new BoxT(X, Y, Z, Length, Width, Height, Material.Clone);
|
||
constructor(x, y, z, l, w, h: real; m: GMaterial) := CreateBase(NewVisualObject(l, w, h), x, y, z, m);
|
||
|
||
public
|
||
/// Возвращает длину паралеллепипеда (по оси X)
|
||
property Length: real read GetL write SetL;
|
||
/// Возвращает ширину паралеллепипеда (по оси Y)
|
||
property Width: real read GetW write SetW;
|
||
/// Возвращает высоту паралеллепипеда (по оси Z)
|
||
property Height: real read GetH write SetH;
|
||
/// Возвращает размеры паралеллепипеда
|
||
property Size: Size3D read GetSz write SetSz;
|
||
/// Возвращает клон паралеллепипеда
|
||
function Clone := (inherited Clone) as BoxT;
|
||
end;
|
||
|
||
// -----------------------------------------------------
|
||
//>> Graph3D: класс ArrowT # Graph3D ArrowT class
|
||
// -----------------------------------------------------
|
||
/// Класс 3D-стрелки
|
||
ArrowT = class(ObjectWithMaterial3D)
|
||
private
|
||
function model := inherited model as ArrowVisual3D;
|
||
|
||
procedure SetDP(r: real) := model.Diameter := r;
|
||
procedure SetD(r: real) := Invoke(SetDP, r);
|
||
function GetD: real := InvokeReal(()->model.Diameter);
|
||
|
||
procedure SetLP(r: real) := model.HeadLength := r;
|
||
procedure SetL(r: real) := Invoke(SetLP, r);
|
||
function GetL: real := InvokeReal(()->model.HeadLength);
|
||
|
||
procedure SetDirP(r: Vector3D) := model.Direction := r;
|
||
procedure SetDir(r: Vector3D) := Invoke(SetDirP, r);
|
||
function GetDir: Vector3D := Invoke&<Vector3D>(()->model.Direction);
|
||
private
|
||
function NewVisualObject(dx, dy, dz, d, hl: real): ArrowVisual3D;
|
||
begin
|
||
var a := new ArrowVisual3D;
|
||
a.HeadLength := hl;
|
||
a.Diameter := d;
|
||
a.Origin := P3D(0,0,0);
|
||
Result := a;
|
||
end;
|
||
|
||
protected
|
||
function CreateObject: Object3D; override := new ArrowT(X, Y, Z, Direction.X, Direction.Y, Direction.Z, Diameter, HeadLength, Material.Clone);
|
||
constructor(x, y, z, dx, dy, dz, d, hl: real; m: GMaterial);
|
||
begin
|
||
var a := NewVisualObject(dx, dy, dz, d, hl);
|
||
CreateBase(a, x, y, z, m);
|
||
a.Direction := V3D(dx, dy, dz);
|
||
end;
|
||
|
||
public
|
||
/// Длина наконечника 3D-стрелки
|
||
property HeadLength: real read GetL write SetL;
|
||
/// Диаметр 3D-стрелки
|
||
property Diameter: real read GetD write SetD;
|
||
/// направление 3D-стрелки
|
||
property Direction: Vector3D read GetDir write SetDir;
|
||
/// Возвращает клон 3D-стрелки
|
||
function Clone := (inherited Clone) as ArrowT;
|
||
end;
|
||
|
||
// -----------------------------------------------------
|
||
//>> Graph3D: класс TruncatedConeT # Graph3D TruncatedConeT class
|
||
// -----------------------------------------------------
|
||
/// Класс усеченного конуса
|
||
TruncatedConeT = class(ObjectWithMaterial3D)
|
||
private
|
||
function model := inherited model as TruncatedConeVisual3D;
|
||
|
||
procedure SetH(r: real) := Invoke(procedure(r: real)->model.Height := r, r);
|
||
function GetH: real := InvokeReal(()->model.Height);
|
||
|
||
procedure SetBRP(r: real) := model.BaseRadius := r;
|
||
procedure SetBR(r: real) := Invoke(SetBRP, r);
|
||
function GetBR: real := InvokeReal(()->model.BaseRadius);
|
||
|
||
procedure SetTRP(r: real) := model.TopRadius := r;
|
||
procedure SetTR(r: real) := Invoke(SetTRP, r);
|
||
function GetTR: real := InvokeReal(()->model.TopRadius);
|
||
|
||
procedure SetTCP(r: boolean) := model.TopCap := r;
|
||
procedure SetTC(r: boolean) := Invoke(SetTCP, r);
|
||
function GetTC: boolean := Invoke&<boolean>(()->model.TopCap);
|
||
private
|
||
function NewVisualObject(h, baser, topr: real; sides: integer; topcap: boolean): TruncatedConeVisual3D;
|
||
begin
|
||
var a := new TruncatedConeVisual3D;
|
||
a.Origin := P3D(0,0,0);
|
||
a.BaseRadius := baser;
|
||
a.TopRadius := topr;
|
||
a.Height := h;
|
||
a.TopCap := topcap;
|
||
a.ThetaDiv := sides + 1;
|
||
a.BaseCap := True;
|
||
Result := a;
|
||
end;
|
||
|
||
protected
|
||
function CreateObject: Object3D; override := new TruncatedConeT(X, Y, Z, Height, BaseRadius, TopRadius, (model as TruncatedConeVisual3D).ThetaDiv - 1, Topcap, Material.Clone);
|
||
constructor(x, y, z, h, baser, topr: real; sides: integer; topcap: boolean; m: GMaterial);
|
||
begin
|
||
var a := NewVisualObject(h, baser, topr, sides, topcap);
|
||
CreateBase(a, x, y, z, m);
|
||
end;
|
||
|
||
public
|
||
/// Высота усеченного конуса
|
||
property Height: real read GetH write SetH;
|
||
/// Радиус основания усеченного конуса
|
||
property BaseRadius: real read GetBR write SetBR;
|
||
/// Верхний радиус усеченного конуса
|
||
property TopRadius: real read GetTR write SetTR;
|
||
/// Есть ли шапочка у усеченного конуса
|
||
property Topcap: boolean read GetTC write SetTC;
|
||
/// Возвращает клон усеченного конуса
|
||
function Clone := (inherited Clone) as TruncatedConeT;
|
||
end;
|
||
|
||
// -----------------------------------------------------
|
||
//>> Graph3D: класс CylinderT # Graph3D CylinderT class
|
||
// -----------------------------------------------------
|
||
/// Класс цилиндра
|
||
CylinderT = class(TruncatedConeT)
|
||
private
|
||
procedure SetR(r: real);
|
||
begin
|
||
BaseRadius := r;
|
||
TopRadius := r;
|
||
end;
|
||
|
||
function GetR: real := BaseRadius;
|
||
protected
|
||
function CreateObject: Object3D; override := new CylinderT(X, Y, Z, Height, Radius, (model as TruncatedConeVisual3D).ThetaDiv - 1, Topcap, Material.Clone);
|
||
constructor(x, y, z, h, r: real; ThetaDiv: integer; topcap: boolean; m: GMaterial);
|
||
begin
|
||
var a := NewVisualObject(h, r, r, ThetaDiv, topcap);
|
||
CreateBase(a, x, y, z, m);
|
||
end;
|
||
|
||
public
|
||
/// Радиус цилиндра
|
||
property Radius: real read GetR write SetR;
|
||
/// Возвращает клон цилиндра
|
||
function Clone := (inherited Clone) as CylinderT;
|
||
end;
|
||
|
||
// -----------------------------------------------------
|
||
//>> Graph3D: класс TeapotT # Graph3D TeapotT class
|
||
// -----------------------------------------------------
|
||
/// Класс чайника
|
||
TeapotT = class(ObjectWithMaterial3D)
|
||
private
|
||
procedure SetVP(v: boolean) := (model as MeshElement3D).Visible := v;
|
||
procedure SetV(v: boolean) := Invoke(SetVP, v);
|
||
function GetV: boolean := Invoke&<boolean>(()->(model as MeshElement3D).Visible);
|
||
protected
|
||
function CreateObject: Object3D; override := new TeapotT(X, Y, Z, Material.Clone);
|
||
constructor(x, y, z: real; m: GMaterial);
|
||
begin
|
||
var a := new Teapot;
|
||
CreateBase(a, x, y, z, m);
|
||
Rotate(V3D(1,0,0), 90);
|
||
end;
|
||
public
|
||
/// Видим ли чайник
|
||
property Visible: boolean read GetV write SetV;
|
||
/// Возвращает клон чайника
|
||
function Clone := (inherited Clone) as TeapotT;
|
||
end;
|
||
|
||
// -----------------------------------------------------
|
||
//>> Graph3D: класс CoordinateSystemT # Graph3D CoordinateSystemT class
|
||
// -----------------------------------------------------
|
||
/// Класс системы координат
|
||
CoordinateSystemT = class(ObjectWithChildren3D)
|
||
private
|
||
procedure SetALP(r: real) := (model as CoordinateSystemVisual3D).ArrowLengths := r;
|
||
procedure SetAL(r: real) := Invoke(SetALP, r);
|
||
function GetAL: real := InvokeReal(()->(model as CoordinateSystemVisual3D).ArrowLengths);
|
||
function GetD: real := InvokeReal(()->((model as CoordinateSystemVisual3D).Children[0] as ArrowVisual3D).Diameter);
|
||
protected
|
||
function CreateObject: Object3D; override := new CoordinateSystemT(X, Y, Z, ArrowLengths, Diameter);
|
||
constructor(x, y, z, arrlength, diameter: real);
|
||
begin
|
||
var a := new CoordinateSystemVisual3D;
|
||
CreateBase0(a, x, y, z);
|
||
a.ArrowLengths := arrlength;
|
||
(a.Children[0] as ArrowVisual3D).Diameter := diameter;
|
||
(a.Children[1] as ArrowVisual3D).Diameter := diameter;
|
||
(a.Children[2] as ArrowVisual3D).Diameter := diameter;
|
||
(a.Children[3] as CubeVisual3D).SideLength := diameter;
|
||
end;
|
||
|
||
public
|
||
/// Длина стрелок системы координат
|
||
property ArrowLengths: real read GetAL write SetAL;
|
||
/// Диаметр стрелок системы координат
|
||
property Diameter: real read GetD;
|
||
/// Возвращает клон системы координат
|
||
function Clone := (inherited Clone) as CoordinateSystemT;
|
||
end;
|
||
|
||
// -----------------------------------------------------
|
||
//>> Graph3D: класс BillboardTextT # Graph3D BillboardTextT class
|
||
// -----------------------------------------------------
|
||
/// Класс текста на билборде (всегда направлен к камере)
|
||
BillboardTextT = class(ObjectWithChildren3D)
|
||
private
|
||
function model := inherited model as BillboardTextVisual3D;
|
||
|
||
procedure SetTP(r: string) := model.Text := r;
|
||
procedure SetT(r: string) := Invoke(SetTP, r);
|
||
function GetT: string := InvokeString(()->model.Text);
|
||
|
||
procedure SetFSP(r: real) := model.FontSize := r;
|
||
procedure SetFS(r: real) := Invoke(SetFSP, r);
|
||
function GetFS: real := InvokeReal(()->model.FontSize);
|
||
protected
|
||
function CreateObject: Object3D; override := new BillboardTextT(X, Y, Z, Text, FontSize);
|
||
constructor(x, y, z: real; text: string; fontsize: real);
|
||
begin
|
||
var a := new BillboardTextVisual3D;
|
||
CreateBase0(a, x, y, z);
|
||
a.Position := p3D(0, 0, 0);
|
||
a.Text := text;
|
||
a.FontSize := fontsize;
|
||
end;
|
||
|
||
public
|
||
/// Текст на билборде
|
||
property Text: string read GetT write SetT;
|
||
/// Размер шрифта на билборде
|
||
property FontSize: real read GetFS write SetFS;
|
||
/// Возвращает клон билборда
|
||
function Clone := (inherited Clone) as BillboardTextT;
|
||
end;
|
||
|
||
// -----------------------------------------------------
|
||
//>> Graph3D: класс TextT # Graph3D TextT class
|
||
// -----------------------------------------------------
|
||
/// Класс 3D-текстового объекта
|
||
TextT = class(ObjectWithChildren3D)
|
||
private
|
||
_fontname: string;
|
||
function model := inherited model as TextVisual3D;
|
||
|
||
procedure SetTP(r: string) := model.Text := r;
|
||
procedure SetT(r: string) := Invoke(SetTP, r);
|
||
function GetT: string := InvokeString(()->model.Text);
|
||
|
||
procedure SetFSP(r: real) := model.Height := r;
|
||
procedure SetFS(r: real) := Invoke(SetFS, r);
|
||
function GetFS: real := InvokeReal(()->model.Height);
|
||
|
||
procedure SetUP(v: Vector3D) := model.UpDirection := v;
|
||
procedure SetU(v: Vector3D) := Invoke(SetUP, v);
|
||
function GetU: Vector3D := Invoke&<Vector3D>(()->model.UpDirection);
|
||
|
||
procedure SetNP(fontname: string) := model.FontFamily := new FontFamily(fontname);
|
||
procedure SetN(fontname: string) := Invoke(SetTP, fontname);
|
||
function GetN: string := InvokeString(()->_fontname);
|
||
|
||
procedure SetColorP(c: GColor) := model.Foreground := new SolidColorBrush(c);
|
||
procedure SetColor(c: GColor) := Invoke(SetColorP, c);
|
||
function GetColor: GColor := Invoke&<GColor>(()->(model.Foreground as SolidColorBrush).Color);
|
||
protected
|
||
function CreateObject: Object3D; override := new TextT(X, Y, Z, Text, Height, FontName, Color);
|
||
constructor(x, y, z: real; text: string; height: real; fontname: string; c: GColor);
|
||
begin
|
||
var a := new TextVisual3D;
|
||
a.Position := p3D(0, 0, 0);
|
||
a.Text := text;
|
||
a.Height := height;
|
||
//a.HorizontalAlignment := HorizontalAlignment.Left;
|
||
Self._fontname := fontname;
|
||
a.FontFamily := new FontFamily(fontname);
|
||
a.Foreground := new SolidColorBrush(c);
|
||
CreateBase0(a, x, y, z);
|
||
end;
|
||
|
||
public
|
||
/// Текст на 3D-текстовом объекте
|
||
property Text: string read GetT write SetT;
|
||
/// Высота 3D-текстового объекта
|
||
property Height: real read GetFS write SetFS;
|
||
/// Имя шрифта 3D-текстового объекта
|
||
property FontName: string read GetN write SetN;
|
||
/// Направление "вверх" для 3D-текстового объекта
|
||
property UpDirection: Vector3D read GetU write SetU;
|
||
/// Цвет 3D-текстового объекта
|
||
property Color: GColor read GetColor write SetColor; override;
|
||
/// Возвращает клон 3D-текстового объекта
|
||
function Clone := (inherited Clone) as TextT;
|
||
end;
|
||
|
||
// -----------------------------------------------------
|
||
//>> Graph3D: класс RectangleT # Graph3D RectangleT class
|
||
// -----------------------------------------------------
|
||
/// Класс 3D-прямоугольника
|
||
RectangleT = class(ObjectWithMaterial3D)
|
||
private
|
||
function model := inherited model as RectangleVisual3D;
|
||
procedure SetWP(r: real) := model.Width := r;
|
||
procedure SetW(r: real) := Invoke(SetWP, r);
|
||
function GetW: real := InvokeReal(()->model.Width);
|
||
|
||
procedure SetLP(r: real) := model.Length := r;
|
||
procedure SetL(r: real) := Invoke(SetLP, r);
|
||
function GetL: real := InvokeReal(()->model.Length);
|
||
|
||
procedure SetLDP(r: Vector3D) := model.LengthDirection := r;
|
||
procedure SetLD(r: Vector3D) := Invoke(SetLDP, r);
|
||
function GetLD: Vector3D := Invoke&<Vector3D>(()->model.LengthDirection);
|
||
|
||
procedure SetNP(r: Vector3D) := model.Normal := r;
|
||
procedure SetN(r: Vector3D) := Invoke(SetNP, r);
|
||
function GetN: Vector3D := Invoke&<Vector3D>(()->model.Normal);
|
||
protected
|
||
function CreateObject: Object3D; override := new RectangleT(X, Y, Z, Length, Width, Normal, LengthDirection, Material);
|
||
constructor(x, y, z, Length, Width: real; Normal, LengthDirection: Vector3D; m: GMaterial);
|
||
begin
|
||
var a := new RectangleVisual3D;
|
||
a.Origin := P3D(0, 0, 0);
|
||
a.Width := Width;
|
||
a.Length := Length;
|
||
a.LengthDirection := lengthdirection;
|
||
a.Normal := normal;
|
||
CreateBase(a, x, y, z, m);
|
||
end;
|
||
|
||
public
|
||
/// Ширина 3D-прямоугольника
|
||
property Width: real read GetW write SetW;
|
||
/// Длина 3D-прямоугольника
|
||
property Length: real read GetL write SetL;
|
||
/// Направление длины 3D-прямоугольника
|
||
property LengthDirection: Vector3D read GetLD write SetLD;
|
||
/// Нормаль к 3D-прямоугольнику
|
||
property Normal: Vector3D read GetN write SetN;
|
||
/// Возвращает клон 3D-прямоугольника
|
||
function Clone := (inherited Clone) as RectangleT;
|
||
end;
|
||
|
||
// -----------------------------------------------------
|
||
//>> Graph3D: класс FileModelT # Graph3D FileModelT class
|
||
// -----------------------------------------------------
|
||
/// Класс 3D-модели
|
||
FileModelT = class(ObjectWithChildren3D)
|
||
private
|
||
fn: string;
|
||
procedure SetMP(mat: GMaterial) := (model as FileModelVisual3D).DefaultMaterial := mat;
|
||
procedure SetMaterial(mat: GMaterial) := Invoke(SetMP, mat);
|
||
function GetMaterial: GMaterial := Invoke&<GMaterial>(()->(model as FileModelVisual3D).DefaultMaterial);
|
||
public
|
||
//property Color: GColor write SetColor;
|
||
property Material: GMaterial read GetMaterial write SetMaterial;// не работает почему-то на запись
|
||
|
||
{procedure SetVP(v: boolean) := (model as FileModelVisual3D).Visibility := v;
|
||
procedure SetV(v: boolean) := Invoke(SetVP, v);
|
||
function GetV: boolean := Invoke&<boolean>(()->(model as FileModelVisual3D).Visibility);}
|
||
protected
|
||
function CreateObject: Object3D; override := new FileModelT(X, Y, Z, fn, Material.Clone);
|
||
constructor(x, y, z: real; fname: string; mat: GMaterial);
|
||
begin
|
||
{'.3ds': r := new studioreader(nil);
|
||
'.lwo': r := new lworeader(nil);
|
||
'.stl': r := new stlreader(nil);
|
||
'.obj','.objx': r := new objreader(nil);}
|
||
|
||
var a := new FileModelVisual3D;
|
||
a.DefaultMaterial := mat;
|
||
a.Source := fname;
|
||
CreateBase0(a, x, y, z);
|
||
end;
|
||
|
||
public
|
||
/// Возвращает клон 3D-модели
|
||
function Clone := (inherited Clone) as FileModelT;
|
||
end;
|
||
|
||
// -----------------------------------------------------
|
||
//>> Graph3D: класс PipeT # Graph3D PipeT class
|
||
// -----------------------------------------------------
|
||
/// Класс трубы
|
||
PipeT = class(ObjectWithMaterial3D)
|
||
private
|
||
function model := inherited model as PipeVisual3D;
|
||
procedure SetDP(r: real) := model.Diameter := r * 2;
|
||
procedure SetD(r: real) := Invoke(SetDP, r);
|
||
function GetD: real := InvokeReal(()->model.Diameter / 2);
|
||
|
||
procedure SetIDP(r: real) := model.InnerDiameter := r * 2;
|
||
procedure SetID(r: real) := Invoke(SetIDP, r);
|
||
function GetID: real := InvokeReal(()->model.InnerDiameter / 2);
|
||
|
||
procedure SetHP(r: real) := model.Point2 := P3D(0, 0, r);
|
||
procedure SetH(r: real) := Invoke(SetHP, r);
|
||
function GetH: real := InvokeReal(()->model.Point2.Z);
|
||
protected
|
||
function CreateObject: Object3D; override := new PipeT(X, Y, Z, Height, Radius, InnerRadius, Material);
|
||
constructor(x, y, z, h, r, ir: real; m: GMaterial);
|
||
begin
|
||
var a := new PipeVisual3D;
|
||
a.Diameter := r * 2;
|
||
a.InnerDiameter := ir * 2;
|
||
a.Point1 := P3D(0, 0, 0);
|
||
a.Point2 := P3D(0, 0, h);
|
||
CreateBase(a, x, y, z, m);
|
||
end;
|
||
|
||
public
|
||
/// Радиус трубы
|
||
property Radius: real read GetD write SetD;
|
||
/// Внутренний радиус трубы
|
||
property InnerRadius: real read GetID write SetID;
|
||
/// Высота трубы
|
||
property Height: real read GetH write SetH;
|
||
/// Возвращает клон трубы
|
||
function Clone := (inherited Clone) as PipeT;
|
||
end;
|
||
|
||
// -----------------------------------------------------
|
||
//>> Graph3D: класс LegoT # Graph3D LegoT class
|
||
// -----------------------------------------------------
|
||
/// Класс лего-детали
|
||
LegoT = class(ObjectWithMaterial3D)
|
||
private
|
||
//function model := inherited model as LegoVisual3D;
|
||
procedure SetWP(r: integer);
|
||
procedure SetW(r: integer);
|
||
function GetW: integer;
|
||
|
||
procedure SetHP(r: integer);
|
||
procedure SetH(r: integer);
|
||
function GetH: integer;
|
||
|
||
procedure SetLP(r: integer);
|
||
procedure SetL(r: integer);
|
||
function GetL: integer;
|
||
|
||
{procedure SetSzP(r: Size3D);
|
||
begin
|
||
var mmm := model as LegoVisual3D;
|
||
(mmm.Columns,mmm.Rows,mmm.Height) := (r.X,r.Y,r.Z);
|
||
end;
|
||
procedure SetSz(r: Size3D) := Invoke(SetSzP,r);
|
||
function GetSz: Size3D := Invoke&<Size3D>(()->begin var mmm := model as LegoVisual3D; Result := Sz3D(mmm.Length,mmm.Width,mmm.Height) end);}
|
||
protected
|
||
function CreateObject: Object3D; override := new LegoT(X, Y, Z, Columns, Rows, Height, Material);
|
||
public
|
||
constructor(x, y, z: real; Rows, Columns, Height: integer; m: GMaterial);
|
||
|
||
/// Количество кирпичиков лего-детали по оси X
|
||
property Columns: integer read GetL write SetL;
|
||
/// Количество кирпичиков лего-детали по оси Y
|
||
property Rows: integer read GetW write SetW;
|
||
/// Высота лего-детали, измеряемая в количестве деталей одинарной высоты
|
||
property Height: integer read GetH write SetH;
|
||
{property Size: Size3D read GetSz write SetSz;}
|
||
/// Возвращает клон лего-детали
|
||
function Clone := (inherited Clone) as LegoT;
|
||
end;
|
||
|
||
// -----------------------------------------------------
|
||
//>> Graph3D: класс PlatonicAbstractT # Graph3D PlatonicAbstractT class
|
||
// -----------------------------------------------------
|
||
/// Абстрактный класс платоновых тел
|
||
PlatonicAbstractT = class(ObjectWithMaterial3D)
|
||
private
|
||
function GetLength: real;
|
||
procedure SetLengthP(r: real);
|
||
public
|
||
/// Длина грани
|
||
property Length: real read GetLength write Invoke(SetLengthP, value);
|
||
end;
|
||
|
||
// -----------------------------------------------------
|
||
//>> Graph3D: класс IcosahedronT # Graph3D IcosahedronT class
|
||
// -----------------------------------------------------
|
||
/// Класс икосаэдра
|
||
IcosahedronT = class(PlatonicAbstractT)
|
||
protected
|
||
function CreateObject: Object3D; override := new IcosahedronT(X, Y, Z, Length, Material);
|
||
public
|
||
constructor(x, y, z, Length: real; m: GMaterial);
|
||
/// Возвращает клон икосаэдра
|
||
function Clone := (inherited Clone) as IcosahedronT;
|
||
end;
|
||
|
||
// -----------------------------------------------------
|
||
//>> Graph3D: класс DodecahedronT # Graph3D DodecahedronT class
|
||
// -----------------------------------------------------
|
||
/// Класс додекаэдра
|
||
DodecahedronT = class(PlatonicAbstractT)
|
||
protected
|
||
function CreateObject: Object3D; override := new DodecahedronT(X, Y, Z, Length, Material);
|
||
public
|
||
constructor(x, y, z, Length: real; m: GMaterial);
|
||
/// Возвращает клон додекаэдра
|
||
function Clone := (inherited Clone) as DodecahedronT;
|
||
end;
|
||
|
||
// -----------------------------------------------------
|
||
//>> Graph3D: класс TetrahedronT # Graph3D TetrahedronT class
|
||
// -----------------------------------------------------
|
||
/// Класс тетраэдра
|
||
TetrahedronT = class(PlatonicAbstractT)
|
||
protected
|
||
function CreateObject: Object3D; override := new TetrahedronT(X, Y, Z, Length, Material);
|
||
public
|
||
constructor(x, y, z, Length: real; m: GMaterial);
|
||
/// Возвращает клон тетраэдра
|
||
function Clone := (inherited Clone) as TetrahedronT;
|
||
end;
|
||
|
||
// -----------------------------------------------------
|
||
//>> Graph3D: класс OctahedronT # Graph3D OctahedronT class
|
||
// -----------------------------------------------------
|
||
/// Класс октаэдра
|
||
OctahedronT = class(PlatonicAbstractT)
|
||
protected
|
||
function CreateObject: Object3D; override := new OctahedronT(X, Y, Z, Length, Material);
|
||
public
|
||
constructor(x, y, z, Length: real; m: GMaterial);
|
||
/// Возвращает клон октаэдра
|
||
function Clone := (inherited Clone) as OctahedronT;
|
||
end;
|
||
|
||
// -----------------------------------------------------
|
||
//>> Graph3D: класс TriangleT # Graph3D TriangleT class
|
||
// -----------------------------------------------------
|
||
/// Класс 3D-треугольника
|
||
TriangleT = class(ObjectWithMaterial3D)
|
||
protected
|
||
procedure SetP1(p: Point3D);
|
||
function GetP1: Point3D;
|
||
procedure SetP2(p: Point3D);
|
||
function GetP2: Point3D;
|
||
procedure SetP3(p: Point3D);
|
||
function GetP3: Point3D;
|
||
|
||
function CreateObject: Object3D; override;
|
||
public
|
||
constructor(p1, p2, p3: Point3D; m: Gmaterial);
|
||
|
||
/// Первая точка 3D-треугольника
|
||
property P1: Point3D read GetP1 write SetP1;
|
||
/// Вторая точка 3D-треугольника
|
||
property P2: Point3D read GetP2 write SetP2;
|
||
/// Третья точка 3D-треугольника
|
||
property P3: Point3D read GetP3 write SetP3;
|
||
/// Устанавливает точки 3D-треугольника
|
||
procedure SetPoints(p1, p2, p3: Point3D);
|
||
end;
|
||
|
||
// -----------------------------------------------------
|
||
//>> Graph3D: класс PrismT # Graph3D PrismT class
|
||
// -----------------------------------------------------
|
||
/// Класс правильной призмы
|
||
PrismT = class(ObjectWithMaterial3D)
|
||
private
|
||
procedure SetR(r: real);
|
||
function GetR: real;
|
||
procedure SetH(r: real);
|
||
function GetH: real;
|
||
procedure SetN(n: integer);
|
||
function GetN: integer;
|
||
protected
|
||
function CreateObject: Object3D; override := new PrismT(X, Y, Z, N, Radius, Height, Material.Clone);
|
||
public
|
||
constructor(x, y, z: real; N: integer; r, h: real; m: Gmaterial);
|
||
/// Радиус правильной призмы
|
||
property Radius: real read GetR write SetR;
|
||
/// Высота правильной призмы
|
||
property Height: real read GetH write SetH;
|
||
/// Количество углов правильной призмы
|
||
property N: integer read GetN write SetN;
|
||
/// Возвращает клон правильной призмы
|
||
function Clone := (inherited Clone) as PrismT;
|
||
end;
|
||
|
||
// -----------------------------------------------------
|
||
//>> Graph3D: класс PyramidT # Graph3D PyramidT class
|
||
// -----------------------------------------------------
|
||
/// Класс правильной пирамиды
|
||
PyramidT = class(PrismT)
|
||
private
|
||
protected
|
||
function CreateObject: Object3D; override := new PyramidT(X, Y, Z, N, Radius, Height, Material.Clone);
|
||
public
|
||
constructor(x, y, z: real; N: integer; r, h: real; m: GMaterial);
|
||
/// Радиус правильной пирамиды
|
||
property Radius: real read GetR write SetR;
|
||
/// Высота правильной пирамиды
|
||
property Height: real read GetH write SetH;
|
||
/// Количество углов правильной пирамиды
|
||
property N: integer read GetN write SetN;
|
||
/// Возвращает клон правильной пирамиды
|
||
function Clone := (inherited Clone) as PyramidT;
|
||
end;
|
||
|
||
// -----------------------------------------------------
|
||
//>> Graph3D: класс PrismTWireframe # Graph3D PrismTWireframe class
|
||
// -----------------------------------------------------
|
||
/// Класс проволочной правильной призмы
|
||
PrismTWireframe = class(ObjectWithChildren3D)
|
||
private
|
||
fn: integer;
|
||
fh, fr: real;
|
||
function Model := inherited model as LinesVisual3D;
|
||
|
||
procedure SetCP(c: GColor) := (model as LinesVisual3D).Color := c;
|
||
procedure SetC(c: GColor) := Invoke(SetCP, c);
|
||
function GetC: GColor := Invoke&<GColor>(()->(model as LinesVisual3D).Color);
|
||
procedure SetTP(th: real) := (model as LinesVisual3D).Thickness := th;
|
||
procedure SetT(th: real) := Invoke(SetTP, th);
|
||
function GetT: real := InvokeReal(()->(model as LinesVisual3D).Thickness);
|
||
|
||
procedure SetRP(value: real);
|
||
begin
|
||
if fr = value then
|
||
exit;
|
||
fr := value;
|
||
(model as LinesVisual3D).Points := CreatePoints;
|
||
end;
|
||
|
||
procedure SetR(value: real) := Invoke(SetRP, value);
|
||
procedure SetHP(value: real);
|
||
begin
|
||
if fh = value then
|
||
exit;
|
||
fh := value;
|
||
(model as LinesVisual3D).Points := CreatePoints;
|
||
end;
|
||
|
||
procedure SetH(value: real) := Invoke(SetHP, value);
|
||
procedure SetNP(value: integer);
|
||
begin
|
||
if fN = value then
|
||
exit;
|
||
fN := value;
|
||
(model as LinesVisual3D).Points := CreatePoints;
|
||
end;
|
||
|
||
procedure SetN(value: integer) := Invoke(SetNP, value);
|
||
|
||
function CreatePoints: Point3DCollection; virtual;
|
||
begin
|
||
var pc := new Point3DCollection;
|
||
|
||
var a := Partition(0, 2 * Pi, N).Select(x -> P3D(fr * cos(x), fr * sin(x), 0)).ToArray;
|
||
var b := Partition(0, 2 * Pi, N).Select(x -> P3D(fr * cos(x), fr * sin(x), fh)).ToArray;
|
||
for var i := 0 to a.High - 1 do
|
||
begin
|
||
pc.Add(a[i]);
|
||
pc.Add(b[i]);
|
||
end;
|
||
for var i := 0 to a.High - 1 do
|
||
begin
|
||
pc.Add(a[i]);
|
||
pc.Add(a[i + 1]);
|
||
end;
|
||
for var i := 0 to a.High - 1 do
|
||
begin
|
||
pc.Add(b[i]);
|
||
pc.Add(b[i + 1]);
|
||
end;
|
||
|
||
Result := pc;
|
||
end;
|
||
|
||
function NewVisualObject(N: integer; Radius, Height: real; Thickness: real; c: GColor): LinesVisual3D;
|
||
begin
|
||
(fn, fr, fh) := (n, Radius, Height);
|
||
var ls := new LinesVisual3D;
|
||
ls.Thickness := Thickness;
|
||
ls.Color := c;
|
||
ls.Points := CreatePoints;
|
||
Result := ls;
|
||
end;
|
||
|
||
protected
|
||
function CreateObject: Object3D; override := new PrismTWireframe(X, Y, Z, N, Radius, Height, (model as LinesVisual3D).Thickness, (model as LinesVisual3D).Color);
|
||
public
|
||
function Points: Point3DCollection; virtual;
|
||
begin
|
||
var a := Partition(0, 2 * Pi, N).Select(x -> P3D(fr * cos(x), fr * sin(x), 0)).SkipLast;
|
||
var b := Partition(0, 2 * Pi, N).Select(x -> P3D(fr * cos(x), fr * sin(x), fh)).SkipLast;
|
||
var pc := new Point3DCollection(a + b);
|
||
|
||
Result := pc;
|
||
end;
|
||
|
||
constructor(x, y, z: real; N: integer; Radius, Height: real; Thickness: real; c: GColor) :=
|
||
CreateBase0(NewVisualObject(N, Radius, Height, Thickness, c), x, y, z);
|
||
|
||
/// Радиус проволочной правильной призмы
|
||
property Radius: real read fr write SetR;
|
||
/// Высота проволочной правильной призмы
|
||
property Height: real read fh write SetH;
|
||
/// Количество углов проволочной правильной призмы
|
||
property N: integer read fn write SetN;
|
||
/// Цвет проволоки правильной призмы
|
||
property Color: GColor read GetC write SetC; override;
|
||
/// Толщина проволоки правильной призмы
|
||
property Thickness: real read GetT write SetT;
|
||
end;
|
||
|
||
// -----------------------------------------------------
|
||
//>> Graph3D: класс PyramidTWireframe # Graph3D PyramidTWireframe class
|
||
// -----------------------------------------------------
|
||
/// Класс проволочной правильной пирамиды
|
||
PyramidTWireframe = class(PrismTWireframe)
|
||
protected
|
||
function CreateObject: Object3D; override := new PyramidTWireframe(X, Y, Z, N, Radius, Height, (model as LinesVisual3D).Thickness, (model as LinesVisual3D).Color);
|
||
private
|
||
function CreatePoints: Point3DCollection; override;
|
||
begin
|
||
var pc := new Point3DCollection;
|
||
|
||
var a := Partition(0, 2 * Pi, N).Select(x -> P3D(fr * cos(x), fr * sin(x), 0)).ToArray;
|
||
var b := P3D(0, 0, fh);
|
||
for var i := 0 to a.High - 1 do
|
||
begin
|
||
pc.Add(a[i]);
|
||
pc.Add(b);
|
||
end;
|
||
for var i := 0 to a.High - 1 do
|
||
begin
|
||
pc.Add(a[i]);
|
||
pc.Add(a[i + 1]);
|
||
end;
|
||
Result := pc;
|
||
end;
|
||
public
|
||
/// Радиус проволочной правильной пирамиды
|
||
property Radius: real read fr write SetR;
|
||
/// Высота проволочной правильной пирамиды
|
||
property Height: real read fh write SetH;
|
||
/// Количество углов проволочной правильной пирамиды
|
||
property N: integer read fn write SetN;
|
||
/// Цвет проволоки правильной пирамиды
|
||
property Color: GColor read GetC write SetC; override;
|
||
/// Толщина проволоки правильной пирамиды
|
||
property Thickness: real read GetT write SetT;
|
||
end;
|
||
|
||
P3DArray = array of Point3D;
|
||
//P3DList = List<Point3D>;
|
||
|
||
// -----------------------------------------------------
|
||
//>> Graph3D: класс SegmentsT # Graph3D SegmentsT class
|
||
// -----------------------------------------------------
|
||
/// Класс Набор 3D-отрезков
|
||
SegmentsT = class(ObjectWithChildren3D)
|
||
private
|
||
function Model := inherited model as LinesVisual3D;
|
||
function GetTP: real := Model.Thickness;
|
||
function GetT: real := InvokeReal(GetTP);
|
||
procedure SetT(t: real) := Invoke(procedure(t: real)->Model.Thickness := t, t);
|
||
function GetCP: GColor := Model.Color;
|
||
function GetC: GColor := Invoke&<GColor>(GetCP);
|
||
procedure SetC(t: GColor) := Invoke(procedure(t: GColor)->Model.Color := t, t);
|
||
function GetPP: array of Point3D := Model.Points.ToArray;
|
||
function GetP: array of Point3D; virtual := Invoke&<array of Point3D>(GetPP);
|
||
procedure SetPP(pp: array of Point3D) := Model.Points := new Point3DCollection(pp);
|
||
procedure SetP(pp: array of Point3D) := Invoke(SetPP, pp);
|
||
protected
|
||
function CreateObject: Object3D; override := new SegmentsT(Points, Thickness, Color);
|
||
public
|
||
constructor(points: sequence of Point3D; thickness: real; c: GColor);
|
||
begin
|
||
var l := new LinesVisual3D;
|
||
l.Thickness := thickness;
|
||
l.Color := c;
|
||
l.Points := new Point3DCollection(points);
|
||
CreateBase0(l, 0, 0, 0);
|
||
end;
|
||
|
||
/// Толщина 3D-отрезков
|
||
property Thickness: real read GetT write SetT;
|
||
/// Цвет 3D-отрезков
|
||
property Color: GColor read GetC write SetC; override;
|
||
/// Точки 3D-отрезков
|
||
property Points: array of Point3D read GetP write SetP;
|
||
/// Возвращает клон 3D-отрезков
|
||
function Clone := (inherited Clone) as SegmentsT;
|
||
end;
|
||
|
||
// -----------------------------------------------------
|
||
//>> Graph3D: класс TorusT # Graph3D TorusT class
|
||
// -----------------------------------------------------
|
||
/// Класс Тор (бублик)
|
||
TorusT = class(ObjectWithMaterial3D)
|
||
private
|
||
procedure SetD(d: real) := Invoke(procedure(d: real)->(model as TorusVisual3D).TorusDiameter := d, d);
|
||
function GetD: real := InvokeReal(()->(model as TorusVisual3D).TorusDiameter);
|
||
procedure SetTD(d: real) := Invoke(procedure(d: real)->(model as TorusVisual3D).TubeDiameter := d, d);
|
||
function GetTD: real := InvokeReal(()->(model as TorusVisual3D).TubeDiameter);
|
||
protected
|
||
function CreateObject: Object3D; override := new TorusT(X, Y, Z, Diameter, TubeDiameter, Material.Clone);
|
||
public
|
||
constructor(x, y, z: real; Diameter, TubeDiameter: real; m: Gmaterial);
|
||
begin
|
||
var t := new TorusVisual3D;
|
||
t.TorusDiameter := Diameter;
|
||
t.TubeDiameter := TubeDiameter;
|
||
CreateBase(t, x, y, z, m);
|
||
end;
|
||
|
||
/// Диаметр тора
|
||
property Diameter: real read GetD write SetD;
|
||
/// Диаметр трубы тора
|
||
property TubeDiameter: real read GetTD write SetTD;
|
||
/// Возвращает клон тора
|
||
function Clone := (inherited Clone) as PrismT;
|
||
end;
|
||
|
||
|
||
// -----------------------------------------------------
|
||
//>> Graph3D: сервисные функции # Graph3D service functions
|
||
// -----------------------------------------------------
|
||
/// Возвращает материал по умолчанию
|
||
function DefaultMaterial: Material;
|
||
/// Возвращает пустую группу объектов в точке (x, y, z)
|
||
function Group(x, y, z: integer): Group3D;
|
||
/// Возвращает пустую группу объектов в точке p
|
||
function Group(p: Point3D): Group3D;
|
||
/// Возвращает пустую группу объектов в точке (0, 0, 0)
|
||
function Group: Group3D;
|
||
/// Возвращает группу объектов, перечисленных как параметры
|
||
function Group(params lst: array of Object3D): Group3D;
|
||
/// Возвращает группу объектов из последовательности en
|
||
function Group(en: sequence of Object3D): Group3D;
|
||
|
||
// -----------------------------------------------------
|
||
//>> Graph3D: функции для создания 3D-объектов # Graph3D functions for creation 3D-objects
|
||
// -----------------------------------------------------
|
||
/// Возвращает сферу с центром в точке (x, y, z) радиуса Radius
|
||
function Sphere(x, y, z, Radius: real; m: Material := DefaultMaterial): SphereT;
|
||
/// Возвращает сферу с центром в точке center радиуса Radius
|
||
function Sphere(center: Point3D; Radius: real; m: Material := DefaultMaterial): SphereT;
|
||
/// Возвращает эллипсоид с центром в точке (x, y, z) и радиусами RadiusX, RadiusY, RadiusZ
|
||
function Ellipsoid(x, y, z, RadiusX, RadiusY, RadiusZ: real; m: Material := DefaultMaterial): EllipsoidT;
|
||
/// Возвращает эллипсоид с центром в точке center и радиусами RadiusX, RadiusY, RadiusZ
|
||
function Ellipsoid(center: Point3D; RadiusX, RadiusY, RadiusZ: real; m: Material := DefaultMaterial): EllipsoidT;
|
||
/// Возвращает эллипсоид с центром в точке (x, y, z) и длиной стороны SideLength
|
||
function Cube(x, y, z, SideLength: real; m: Material := DefaultMaterial): CubeT;
|
||
/// Возвращает эллипсоид с центром в точке center и длиной стороны SideLength
|
||
function Cube(center: Point3D; SideLength: real; m: Material := DefaultMaterial): CubeT;
|
||
/// Возвращает паралеллепипед с центром в точке (x, y, z) и размерами SizeX, SizeY, SizeZ
|
||
function Box(x, y, z, SizeX, SizeY, SizeZ: real; m: Material := DefaultMaterial): BoxT;
|
||
/// Возвращает паралеллепипед с центром в точке center и размерами SizeX, SizeY, SizeZ
|
||
function Box(center: Point3D; sz: Size3D; m: Material := DefaultMaterial): BoxT;
|
||
/// Возвращает 3D-стрелку с центром в точке (x, y, z), направлением (vx, vy, vz), диаметра Diameter и длиной наконечника HeadLength
|
||
function Arrow(x, y, z, vx, vy, vz, Diameter, HeadLength: real; m: Material := DefaultMaterial): ArrowT;
|
||
/// Возвращает 3D-стрелку с центром в точке (x, y, z), направлением (vx, vy, vz), диаметра Diameter
|
||
function Arrow(x, y, z, vx, vy, vz, Diameter: real; m: Material := DefaultMaterial): ArrowT;
|
||
/// Возвращает 3D-стрелку с центром в точке (x, y, z), направлением (vx, vy, vz)
|
||
function Arrow(x, y, z, vx, vy, vz: real; m: Material := DefaultMaterial): ArrowT;
|
||
/// Возвращает 3D-стрелку с центром в точке p, направлением p, диаметра Diameter и длиной наконечника HeadLength
|
||
function Arrow(p: Point3D; v: Vector3D; Diameter, HeadLength: real; m: Material := DefaultMaterial): ArrowT;
|
||
/// Возвращает 3D-стрелку с центром в точке p, направлением p, диаметра Diameter
|
||
function Arrow(p: Point3D; v: Vector3D; Diameter: real; m: Material := DefaultMaterial): ArrowT;
|
||
/// Возвращает 3D-стрелку с центром в точке p, направлением p
|
||
function Arrow(p: Point3D; v: Vector3D; m: Material := DefaultMaterial): ArrowT;
|
||
|
||
///--
|
||
function TruncatedCone(x, y, z, Height, Radius, TopRadius: real; topcap: boolean; m: Material := DefaultMaterial): TruncatedConeT;
|
||
/// Возвращает усеченный конус с центром основания в точке (x, y, z) высоты Height, радиуса основания Radius, верхнего радиуса TopRadius
|
||
function TruncatedCone(x, y, z, Height, Radius, TopRadius: real; m: Material := DefaultMaterial): TruncatedConeT;
|
||
///--
|
||
function TruncatedCone(p: Point3D; Height, Radius, TopRadius: real; topcap: boolean; m: Material := DefaultMaterial): TruncatedConeT;
|
||
/// Возвращает усеченный конус с центром основания в точке p высоты Height, радиуса основания Radius, верхнего радиуса TopRadius
|
||
function TruncatedCone(p: Point3D; Height, Radius, TopRadius: real; m: Material := DefaultMaterial): TruncatedConeT;
|
||
|
||
///--
|
||
function Cylinder(x, y, z, Height, Radius: real; topcap: boolean; m: Material := DefaultMaterial): CylinderT;
|
||
/// Возвращает цилиндр с центром основания в точке (x, y, z) высоты Height радиуса Radius
|
||
function Cylinder(x, y, z, Height, Radius: real; m: Material := DefaultMaterial): CylinderT;
|
||
///--
|
||
function Cylinder(p: Point3D; Height, Radius: real; topcap: boolean; m: Material := DefaultMaterial): CylinderT;
|
||
/// Возвращает цилиндр с центром основания в точке p высоты Height радиуса Radius
|
||
function Cylinder(p: Point3D; Height, Radius: real; m: Material := DefaultMaterial): CylinderT;
|
||
/// Возвращает трубу с центром основания в точке (x, y, z) высотой Height, радиусом Radius и внутренним радиусом InnerRadius
|
||
function Tube(x, y, z, Height, Radius, InnerRadius: real; m: Material := DefaultMaterial): PipeT;
|
||
/// Возвращает трубу с центром основания в точке p высотой Height, радиусом Radius и внутренним радиусом InnerRadius
|
||
function Tube(p: Point3D; Height, Radius, InnerRadius: real; m: Material := DefaultMaterial): PipeT;
|
||
/// Возвращает конус с центром основания в точке (x, y, z) высотой Height, радиусом Radius
|
||
function Cone(x, y, z, Height, Radius: real; m: Material := DefaultMaterial): TruncatedConeT;
|
||
/// Возвращает конус с центром основания в точке p высотой Height, радиусом Radius
|
||
function Cone(p: Point3D; Height, Radius: real; m: Material := DefaultMaterial): TruncatedConeT;
|
||
/// Возвращает чайник с центром в точке (x, y, z)
|
||
function Teapot(x, y, z: real; c: Material := DefaultMaterial): TeapotT;
|
||
/// Возвращает чайник с центром в точке p
|
||
function Teapot(p: Point3D; c: Material := DefaultMaterial): TeapotT;
|
||
/// Возвращает текст на билборде с центром в точке (x, y, z) с размером шрифта Fontsize
|
||
function BillboardText(x, y, z: real; Text: string; Fontsize: real := 12): BillboardTextT;
|
||
/// Возвращает текст на билборде с центром в точке p с размером шрифта Fontsize
|
||
function BillboardText(p: Point3D; Text: string; Fontsize: real := 12): BillboardTextT;
|
||
/// Возвращает координатную систему с длиной стрелок ArrowsLength и диаметром стрелок Diameter
|
||
function CoordinateSystem(ArrowsLength, Diameter: real): CoordinateSystemT;
|
||
/// Возвращает координатную систему с длиной стрелок ArrowsLength
|
||
function CoordinateSystem(ArrowsLength: real): CoordinateSystemT;
|
||
/// Возвращает 3D-текст с центром в точке (x, y, z) с высотой Height, именем шрифта FontName заданного цвета
|
||
function Text3D(x, y, z: real; Text: string; Height: real; FontName: string := 'Arial'; c: Color := Colors.Black): TextT;
|
||
/// Возвращает 3D-текст с центром в точке p с высотой Height, именем шрифта FontName заданного цвета
|
||
function Text3D(p: Point3D; Text: string; Height: real; FontName: string := 'Arial'; c: Color := Colors.Black): TextT;
|
||
/// Возвращает 3D-текст с центром в точке (x, y, z) с высотой Height заданного цвета
|
||
function Text3D(x, y, z: real; Text: string; Height: real; c: Color): TextT;
|
||
/// Возвращает 3D-текст с центром в точке p с высотой Height заданного цвета
|
||
function Text3D(p: Point3D; Text: string; Height: real; c: Color): TextT;
|
||
/// Возвращает 3D-прямоугольник с центром в точке (x, y, z) длины Length, ширины Width, нормалью Normal и направлением длины LengthDirection
|
||
function Rectangle3D(x, y, z, Length, Width: real; Normal, LengthDirection: Vector3D; m: Material := DefaultMaterial): RectangleT;
|
||
/// Возвращает 3D-прямоугольник с центром в точке p длины Length, ширины Width, нормалью Normal и направлением длины LengthDirection
|
||
function Rectangle3D(p: Point3D; Length, Width: real; Normal, LengthDirection: Vector3D; m: Material := DefaultMaterial): RectangleT;
|
||
/// Возвращает 3D-прямоугольник с центром в точке (x, y, z) длины Length, ширины Width, нормалью Normal
|
||
function Rectangle3D(x, y, z, Length, Width: real; Normal: Vector3D; m: Material := DefaultMaterial): RectangleT;
|
||
/// Возвращает 3D-прямоугольник с центром в точке (x, y, z) длины Length, ширины Width
|
||
function Rectangle3D(x, y, z, Length, Width: real; m: Material := DefaultMaterial): RectangleT;
|
||
/// Возвращает 3D-прямоугольник с центром в точке p длины Length, ширины Width, нормалью Normal
|
||
function Rectangle3D(p: Point3D; Length, Width: real; Normal: Vector3D; m: Material := DefaultMaterial): RectangleT;
|
||
/// Возвращает 3D-прямоугольник с центром в точке p длины Length, ширины Width
|
||
function Rectangle3D(p: Point3D; Length, Width: real; m: Material := DefaultMaterial): RectangleT;
|
||
|
||
/// Загружает модель из файла в форматах .obj, .3ds, .lwo, .objz, .stl, .off и отображает ее в точке (x, y, z)
|
||
function FileModel3D(x, y, z: real; fname: string; m: Material): FileModelT;
|
||
/// Загружает модель из файла в форматах .obj, .3ds, .lwo, .objz, .stl, .off и отображает ее в точке p
|
||
function FileModel3D(p: Point3D; fname: string; m: Material): FileModelT;
|
||
|
||
/// Возвращает правильную призму с центром основания в точке (x, y, z), количеством сторон Sides, высотой Height и радиусом Radius
|
||
function Prism(x, y, z: real; Sides: integer; Height, Radius: real; m: Material := DefaultMaterial): PrismT;
|
||
/// Возвращает правильную призму с центром основания в точке p, количеством сторон Sides, высотой Height и радиусом Radius
|
||
function Prism(p: Point3D; Sides: integer; Height, Radius: real; m: Material := DefaultMaterial): PrismT;
|
||
/// Возвращает проволочную правильную призму с центром основания в точке (x, y, z), количеством сторон Sides, высотой Height, радиусом Radius и толщиной проволоки Thickness
|
||
function PrismWireFrame(x, y, z: real; Sides: integer; Height, Radius: real; Thickness: real := 1.2; c: Color := GrayColor(64)): PrismTWireFrame;
|
||
/// Возвращает проволочную правильную призму с центром основания в точке p, количеством сторон Sides, высотой Height, радиусом Radius и толщиной проволоки Thickness
|
||
function PrismWireFrame(p: Point3D; Sides: integer; Height, Radius: real; Thickness: real := 1.2; c: Color := GrayColor(64)): PrismTWireFrame;
|
||
/// Возвращает правильную пирамиду с центром основания в точке (x, y, z), количеством сторон Sides, высотой Height и радиусом Radius
|
||
function Pyramid(x, y, z: real; Sides: integer; Height, Radius: real; m: Material := DefaultMaterial): PyramidT;
|
||
/// Возвращает правильную пирамиду с центром основания в точке p, количеством сторон Sides, высотой Height и радиусом Radius
|
||
function Pyramid(p: Point3D; Sides: integer; Height, Radius: real; m: Material := DefaultMaterial): PyramidT;
|
||
/// Возвращает проволочную правильную пирамиду с центром основания в точке (x, y, z), количеством сторон Sides, высотой Height и радиусом Radius
|
||
function PyramidWireFrame(x, y, z: real; Sides: integer; Height, Radius: real; Thickness: real := 1.2; c: Color := GrayColor(64)): PyramidTWireFrame;
|
||
/// Возвращает проволочную правильную пирамиду с центром основания в точке p, количеством сторон Sides, высотой Height и радиусом Radius
|
||
function PyramidWireFrame(p: Point3D; Sides: integer; Height, Radius: real; Thickness: real := 1.2; c: Color := GrayColor(64)): PyramidTWireFrame;
|
||
/// Возвращает лего-деталь с центром в точке (x, y, z), размера (Rows, Columns, Height), измеряемом в количестве кирпичиков по каждой размерности
|
||
function Lego(x, y, z: real; Rows, Columns, Height: integer; m: Material := DefaultMaterial): LegoT;
|
||
/// Возвращает икосаэдр с центром в точке (x, y, z) и радиусом описанной окружности Radius
|
||
function Icosahedron(x, y, z, Radius: real; m: Material := DefaultMaterial): IcosahedronT;
|
||
/// Возвращает додекаэдр с центром в точке (x, y, z) и радиусом описанной окружности Radius
|
||
function Dodecahedron(x, y, z, Radius: real; m: Material := DefaultMaterial): DodecahedronT;
|
||
/// Возвращает тетраэдр с центром в точке (x, y, z) и радиусом описанной окружности Radius
|
||
function Tetrahedron(x, y, z, Radius: real; m: Material := DefaultMaterial): TetrahedronT;
|
||
/// Возвращает октаэдр с центром в точке (x, y, z) и радиусом описанной окружности Radius
|
||
function Octahedron(x, y, z, Radius: real; m: Material := DefaultMaterial): OctahedronT;
|
||
/// Возвращает икосаэдр с центром в точке p и радиусом описанной окружности Radius
|
||
function Icosahedron(p: Point3D; Radius: real; m: Material := DefaultMaterial): IcosahedronT;
|
||
/// Возвращает додекаэдр с центром в точке p и радиусом описанной окружности Radius
|
||
function Dodecahedron(p: Point3D; Radius: real; m: Material := DefaultMaterial): DodecahedronT;
|
||
/// Возвращает тетраэдр с центром в точке p и радиусом описанной окружности Radius
|
||
function Tetrahedron(p: Point3D; Radius: real; m: Material := DefaultMaterial): TetrahedronT;
|
||
/// Возвращает октаэдр с центром в точке p и радиусом описанной окружности Radius
|
||
function Octahedron(p: Point3D; Radius: real; m: Material := DefaultMaterial): OctahedronT;
|
||
/// Возвращает набор отрезков, задаваемых последовательностью точек points, толщиной Thickness, заданного цвета. Количество точек должно быть четным
|
||
function Segments3D(points: sequence of Point3D; Thickness: real := 1.2; c: Color := GrayColor(64)): SegmentsT;
|
||
/// Возвращает ломаную, задаваемую последовательностью точек points, толщиной Thickness, заданного цвета
|
||
function Polyline3D(points: sequence of Point3D; Thickness: real := 1.2; c: Color := GrayColor(64)): SegmentsT;
|
||
/// Возвращает замкнутую ломаную, задаваемую последовательностью точек points, толщиной Thickness, заданного цвета
|
||
function Polygon3D(points: sequence of Point3D; Thickness: real := 1.2; c: Color := GrayColor(64)): SegmentsT;
|
||
/// Возвращает отрезок из точки p1 в точку p2 толщиной Thickness заданного цвета
|
||
function Segment3D(p1, p2: Point3D; Thickness: real := 1.2; c: Color := GrayColor(64)): SegmentsT;
|
||
/// Возвращает тор (бублик) с центром в точке (x, y, z), диаметром Diameter и диаметром трубы TubeDiameter
|
||
function Torus(x, y, z, Diameter, TubeDiameter: real; m: Material := DefaultMaterial): TorusT;
|
||
/// Возвращает тор (бублик) с центром в точке p, диаметром Diameter и диаметром трубы TubeDiameter
|
||
function Torus(p: Point3D; Diameter, TubeDiameter: real; m: Material := DefaultMaterial): TorusT;
|
||
/// Возвращает треугольник, соединяющий точки p1, p2, p3
|
||
function Triangle(p1, p2, p3: Point3D; m: Material := DefaultMaterial): TriangleT;
|
||
|
||
// Конец примитивов
|
||
//------------------------------------------------------------------------------------
|
||
|
||
// -----------------------------------------------------
|
||
//>> Graph3D: функции для создания невизуальных объектов # Graph3D functions for creation non-visual objects
|
||
// -----------------------------------------------------
|
||
/// Возвращает невизуальную плоскость, проходящую через точку p и имеющую нормаль Normal
|
||
function Plane(p: Point3D; Normal: Vector3D): Plane3D;
|
||
|
||
/// Возвращает невизуальный луч, проходящий через точку p в направлении вектора v
|
||
function Ray(p: Point3D; v: Vector3D): Ray3D;
|
||
|
||
/// Возвращает невизуальную прямую, проходящую через точку p в направлении вектора v
|
||
function Line(p: Point3D; v: Vector3D): Line3D;
|
||
|
||
/// Возвращает невизуальную прямую, проходящую через точки p1 и p2
|
||
function Line(p1, p2: Point3D): Line3D;
|
||
|
||
/// Возвращает невизуальный луч, выпущенный из камеры и проходящий через точку (x,y) экрана
|
||
function GetRay(x, y: real): Ray3D;
|
||
|
||
/// Создает пустую анимацию заданной длительности
|
||
function EmptyAnim(sec: real): EmptyAnimation;
|
||
|
||
// -----------------------------------------------------
|
||
//>> Graph3D: функции для определения ближайших точек и объектов # Graph3D functions for nearest points and objects
|
||
// -----------------------------------------------------
|
||
/// Возвращает ближайший 3D-объект, который пересекает луч, выпущенный из камеры и проходящий через точку (x,y) экрана
|
||
function FindNearestObject(x, y: real): Object3D;
|
||
|
||
/// Возвращает точку на ближайшем 3D-объекте, который пересекает луч, выпущенный из камеры и проходящий через точку (x,y) экрана. Если пересечения нет, возвращается точка BadPoint
|
||
function FindNearestObjectPoint(x, y: real): Point3D;
|
||
|
||
/// Возвращает точку на плоскости Plane, которую пересекает невизуальный луч, выпущенный из камеры и проходящий через точку (x,y) экрана
|
||
function PointOnPlane(Plane: Plane3D; x, y: real): Point3D;
|
||
|
||
/// Возвращает ближайшую точку на линии Line с лучом, выпущенным из камеры и проходящем через точку (x,y) экрана
|
||
function NearestPointOnLine(Line: Ray3D; x, y: real): Point3D;
|
||
|
||
var
|
||
// -----------------------------------------------------
|
||
//>> События модуля Graph3D # Graph3D events
|
||
// -----------------------------------------------------
|
||
/// Событие нажатия на кнопку мыши. (x,y) - координаты курсора мыши в момент наступления события, mousebutton = 1, если нажата левая кнопка мыши, и 2, если нажата правая кнопка мыши
|
||
OnMouseDown: procedure(x, y: real; mousebutton: integer);
|
||
/// Событие отжатия кнопки мыши. (x,y) - координаты курсора мыши в момент наступления события, mousebutton = 1, если отжата левая кнопка мыши, и 2, если отжата правая кнопка мыши
|
||
OnMouseUp: procedure(x, y: real; mousebutton: integer);
|
||
/// Событие перемещения мыши. (x,y) - координаты курсора мыши в момент наступления события, mousebutton = 0, если кнопка мыши не нажата, 1, если нажата левая кнопка мыши, и 2, если нажата правая кнопка мыши
|
||
OnMouseMove: procedure(x, y: real; mousebutton: integer);
|
||
/// Событие нажатия клавиши
|
||
OnKeyDown: procedure(k: Key);
|
||
/// Событие отжатия клавиши
|
||
OnKeyUp: procedure(k: Key);
|
||
|
||
var
|
||
// -----------------------------------------------------
|
||
//>> Переменные модуля Graph3D # Graph3D variables
|
||
// -----------------------------------------------------
|
||
/// Пространство отображения
|
||
View3D: View3DType;
|
||
/// Графическое окно
|
||
Window: WindowType;
|
||
/// Камера
|
||
Camera: CameraType;
|
||
/// Источники света
|
||
Lights: LightsType;
|
||
/// Координатная сетка
|
||
GridLines: GridLinesType;
|
||
/// Список 3D-объектов
|
||
Object3DList := new List<Object3D>;
|
||
/// Орт (единичный вектор) оси OX
|
||
OrtX: Vector3D := V3D(1, 0, 0);
|
||
/// Орт (единичный вектор) оси OY
|
||
OrtY: Vector3D := V3D(0, 1, 0);
|
||
/// Орт (единичный вектор) оси OZ
|
||
OrtZ: Vector3D := V3D(0, 0, 1);
|
||
/// Точка начала координат
|
||
Origin: Point3D := P3D(0, 0, 0);
|
||
/// Плоскость OXY
|
||
PlaneXY: Plane3D := Plane(Origin, OrtZ);
|
||
/// Плоскость OYZ
|
||
PlaneYZ: Plane3D := Plane(Origin, OrtX);
|
||
/// Плоскость OXZ
|
||
PlaneXZ: Plane3D := Plane(Origin, OrtY);
|
||
/// Ось OX
|
||
XAxis: Ray3D := Ray(Origin, OrtX);
|
||
/// Ось OY
|
||
YAxis: Ray3D := Ray(Origin, OrtY);
|
||
/// Ось OZ
|
||
ZAxis: Ray3D := Ray(Origin, OrtZ);
|
||
/// Плохая точка (возвращается в случае неуспеха функцией FindNearestObjectPoint)
|
||
BadPoint: Point3D := P3D(real.MaxValue, real.MaxValue, real.MaxValue);
|
||
|
||
//{{{--doc: Конец секции 1 }}}
|
||
|
||
///--
|
||
procedure __InitModule__;
|
||
///--
|
||
procedure __FinalizeModule__;
|
||
|
||
implementation
|
||
|
||
function RGB(r, g, b: byte) := Color.Fromrgb(r, g, b);
|
||
function ARGB(a, r, g, b: byte) := Color.FromArgb(a, r, g, b);
|
||
function P3D(x, y, z: real) := new Point3D(x, y, z);
|
||
function V3D(x, y, z: real) := new Vector3D(x, y, z);
|
||
function Sz3D(x, y, z: real) := new Size3D(x, y, z);
|
||
function Pnt(x, y: real) := new Point(x, y);
|
||
function Rect(x, y, w, h: real) := new System.Windows.Rect(x, y, w, h);
|
||
function RandomColor: Color := RGB(Random(256), Random(256), Random(256));
|
||
function EmptyColor: Color := ARGB(0,0,0,0);
|
||
function GrayColor(b: byte): Color := RGB(b, b, b);
|
||
function RandomSolidBrush: SolidColorBrush := new SolidColorBrush(RandomColor);
|
||
|
||
type
|
||
IMHelper = auto class
|
||
fname: string;
|
||
M, N: real;
|
||
function ImageMaterial: Material;
|
||
begin
|
||
//Result := MaterialHelper.CreateImageMaterial(fname)
|
||
var bi := new System.Windows.Media.Imaging.BitmapImage();
|
||
bi.BeginInit();
|
||
bi.UriSource := new System.Uri(fname, System.UriKind.Relative);
|
||
bi.EndInit();
|
||
var b := new ImageBrush(bi);
|
||
b.Viewport := Rect(0, 0, M, N);
|
||
if (M <> 1) or (N <> 1) then
|
||
b.TileMode := TileMode.Tile;
|
||
Result := new GDiffuseMaterial(b);
|
||
end;
|
||
end;
|
||
DEMHelper = auto class
|
||
c: Color;
|
||
function Diffuse := new GDiffuseMaterial(new SolidColorBrush(c));
|
||
function Emissive := new GEmissiveMaterial(new SolidColorBrush(c));
|
||
end;
|
||
SpMHelper = auto class
|
||
c: Color;
|
||
specularpower: real;
|
||
function SpecularMaterial := new System.Windows.Media.Media3D.SpecularMaterial(new SolidColorBrush(c), specularpower);
|
||
end;
|
||
|
||
function ImageMaterial(fname: string; M,N: real): Material := Invoke&<Material>(IMHelper.Create(fname, M, N).ImageMaterial);
|
||
function DiffuseMaterial(c: Color): Material := Invoke&<Material>(DEMHelper.Create(c).Diffuse);
|
||
function SpecularMaterial(specularBrightness: byte; specularpower: real): Material := Invoke&<Material>(SpMHelper.Create(RGB(specularBrightness, specularBrightness, specularBrightness), specularpower).SpecularMaterial);
|
||
function SpecularMaterial(c: Color; specularpower: real): Material := Invoke&<Material>(SpMHelper.Create(c, specularpower).SpecularMaterial);
|
||
function EmissiveMaterial(c: Color): Material := Invoke&<Material>(DEMHelper.Create(c).Emissive);
|
||
function RainbowMaterial: Material := GMaterials.Rainbow;
|
||
|
||
//function wplus: real := SystemParameters.WindowResizeBorderThickness.Left + SystemParameters.WindowResizeBorderThickness.Right;
|
||
|
||
//function hplus: real := SystemParameters.WindowCaptionHeight + SystemParameters.WindowResizeBorderThickness.Top + SystemParameters.WindowResizeBorderThickness.Bottom;
|
||
|
||
function Object3D.AnimMoveTo(x, y, z, seconds: real; Completed: procedure) := new OffsetAnimation(Self, seconds, x, y, z, Completed);
|
||
|
||
function Object3D.AnimMoveTrajectory(trajectory: sequence of Point3D; seconds: real; Completed: procedure) := new OffsetAnimationUsingKeyframes(Self, seconds, trajectory, Completed);
|
||
|
||
function Object3D.AnimMoveOn(dx, dy, dz, seconds: real; Completed: procedure) := new OffsetAnimationOn(Self, seconds, dx, dy, dz, Completed);
|
||
|
||
function Object3D.AnimScale(sc, seconds: real; Completed: procedure) := new ScaleAnimation(Self, seconds, sc, Completed);
|
||
|
||
function Object3D.AnimScaleX(sc, seconds: real; Completed: procedure) := new ScaleXAnimation(Self, seconds, sc, Completed);
|
||
|
||
function Object3D.AnimScaleY(sc, seconds: real; Completed: procedure) := new ScaleYAnimation(Self, seconds, sc, Completed);
|
||
|
||
function Object3D.AnimScaleZ(sc, seconds: real; Completed: procedure) := new ScaleZAnimation(Self, seconds, sc, Completed);
|
||
|
||
function Object3D.AnimRotate(vx, vy, vz, angle, seconds: real; Completed: procedure) := new RotateAtAnimation(Self, seconds, vx, vy, vz, angle, P3D(0, 0, 0), Completed);
|
||
|
||
function Object3D.AnimRotateAt(axis: Vector3D; angle: real; center: Point3D; seconds: real; Completed: procedure) := new RotateAtAnimation(Self, seconds, axis.X, axis.y, axis.z, angle, center, Completed);
|
||
|
||
procedure Object3D.AddToObject3DList := Object3DList.Add(Self);
|
||
|
||
procedure Object3D.DeleteFromObject3DList;
|
||
begin
|
||
var oc := Self as ObjectWithChildren3D;
|
||
foreach var c in oc.l do
|
||
c.DeleteFromObject3DList;
|
||
Object3DList.Remove(Self)
|
||
end;
|
||
|
||
function EmptyAnim(sec: real) := EmptyAnimation.Create(sec);
|
||
|
||
function AnimationBase.&Then(second: AnimationBase): AnimationBase := Animate.Sequence(Self, second);
|
||
|
||
//------------------------------ End Animation -------------------------------
|
||
|
||
type
|
||
LegoVisual3D = class(MeshElement3D)
|
||
private
|
||
public
|
||
class HeightProperty: DependencyProperty;
|
||
class RowsProperty: DependencyProperty;
|
||
class ColumnsProperty: DependencyProperty;
|
||
class DivisionsProperty: DependencyProperty;
|
||
private
|
||
procedure SetHeight(value: integer) := SetValue(HeightProperty, value);
|
||
function GetHeight := integer(GetValue(HeightProperty));
|
||
procedure SetRows(value: integer) := SetValue(RowsProperty, value);
|
||
function GetRows := integer(GetValue(RowsProperty));
|
||
procedure SetColumns(value: integer) := SetValue(ColumnsProperty, value);
|
||
function GetColumns := integer(GetValue(ColumnsProperty));
|
||
procedure SetDivisions(value: integer) := SetValue(DivisionsProperty, value);
|
||
function GetDivisions := integer(GetValue(DivisionsProperty));
|
||
|
||
class constructor;
|
||
begin
|
||
HeightProperty := DependencyProperty.Register('Height', typeof(integer), typeof(LegoVisual3D), new UIPropertyMetadata(3, GeometryChanged));
|
||
RowsProperty := DependencyProperty.Register('Raws', typeof(integer), typeof(LegoVisual3D), new UIPropertyMetadata(3, GeometryChanged));
|
||
ColumnsProperty := DependencyProperty.Register('Columns', typeof(integer), typeof(LegoVisual3D), new UIPropertyMetadata(3, GeometryChanged));
|
||
DivisionsProperty := DependencyProperty.Register('Divisions', typeof(integer), typeof(LegoVisual3D), new UIPropertyMetadata(48));
|
||
end;
|
||
|
||
public
|
||
property Height: integer read GetHeight write SetHeight;
|
||
property Rows: integer read GetRows write SetRows;
|
||
property Columns: integer read GetColumns write SetColumns;
|
||
property Divisions: integer read GetDivisions write SetDivisions;
|
||
public
|
||
function Tessellate(): MeshGeometry3D; override;
|
||
const
|
||
m = 1 / 0.008;
|
||
grid = 0.008 * m;
|
||
margin = 0.0001 * m;
|
||
wallThickness = 0.001 * m;
|
||
plateThickness = 0.0032 * m;
|
||
brickThickness = 0.0096 * m;
|
||
knobHeight = 0.0018 * m;
|
||
knobDiameter = 0.0048 * m;
|
||
outerDiameter = 0.00651 * m;
|
||
axleDiameter = 0.00475 * m;
|
||
holeDiameter = 0.00485 * m;
|
||
begin
|
||
var width := Columns * grid - margin * 2;
|
||
var length := Rows * grid - margin * 2;
|
||
var height1 := Height * plateThickness;
|
||
var builder := new MeshBuilder(true, true);
|
||
for var i := 0 to Columns - 1 do
|
||
for var j := 0 to Rows - 1 do
|
||
begin
|
||
var o := new Point3D((i + 0.5) * grid, (j + 0.5) * grid, height1);
|
||
builder.AddCone(o, new Vector3D(0, 0, 1), knobDiameter / 2, knobDiameter / 2, knobHeight, false, true, Divisions);
|
||
builder.AddPipe(new Point3D(o.X, o.Y, o.Z - wallThickness), new Point3D(o.X, o.Y, wallThickness),
|
||
knobDiameter, outerDiameter, Divisions);
|
||
end;
|
||
|
||
builder.AddBox(new Point3D(Columns * 0.5 * grid, Rows * 0.5 * grid, height1 - wallThickness / 2), width, length,
|
||
wallThickness,
|
||
BoxFaces.All);
|
||
builder.AddBox(new Point3D(margin + wallThickness / 2, Rows * 0.5 * grid, height1 / 2 - wallThickness / 2),
|
||
wallThickness, length, height1 - wallThickness,
|
||
BoxFaces.All xor BoxFaces.Top);
|
||
builder.AddBox(
|
||
new Point3D(Columns * grid - margin - wallThickness / 2, Rows * 0.5 * grid, height1 / 2 - wallThickness / 2),
|
||
wallThickness, length, height1 - wallThickness,
|
||
BoxFaces.All xor BoxFaces.Top);
|
||
builder.AddBox(new Point3D(Columns * 0.5 * grid, margin + wallThickness / 2, height1 / 2 - wallThickness / 2),
|
||
width, wallThickness, height1 - wallThickness,
|
||
BoxFaces.All xor BoxFaces.Top);
|
||
builder.AddBox(
|
||
new Point3D(Columns * 0.5 * grid, Rows * grid - margin - wallThickness / 2, height1 / 2 - wallThickness / 2),
|
||
width, wallThickness, height1 - wallThickness,
|
||
BoxFaces.All xor BoxFaces.Top);
|
||
Result := builder.ToMesh(false);
|
||
end;
|
||
end;
|
||
|
||
constructor LegoT.Create(x, y, z: real; Rows, Columns, Height: integer; m: GMaterial);
|
||
begin
|
||
var bx := new LegoVisual3D;
|
||
(bx.Rows, bx.Height, bx.Columns) := (Rows, Height, Columns);
|
||
CreateBase(bx, x, y, z, m);
|
||
end;
|
||
|
||
procedure LegoT.SetWP(r: integer) := (model as LegoVisual3D).Rows := r;
|
||
procedure LegoT.SetW(r: integer) := Invoke(SetWP, r);
|
||
function LegoT.GetW: integer := InvokeInteger(()->(model as LegoVisual3D).Rows);
|
||
|
||
procedure LegoT.SetHP(r: integer) := (model as LegoVisual3D).Height := r;
|
||
procedure LegoT.SetH(r: integer) := Invoke(SetHP, r);
|
||
function LegoT.GetH: integer := InvokeInteger(()->(model as LegoVisual3D).Height);
|
||
|
||
procedure LegoT.SetLP(r: integer) := (model as LegoVisual3D).Columns := r;
|
||
procedure LegoT.SetL(r: integer) := Invoke(SetLP, r);
|
||
function LegoT.GetL: integer := InvokeInteger(()->(model as LegoVisual3D).Columns);
|
||
|
||
type
|
||
Panel = class
|
||
Points: array of Point3D;
|
||
TriangleIndex: integer;
|
||
end;
|
||
|
||
ModelTypes = (TetrahedronType, OctahedronType, HexahedronType, IcosahedronType, DodecahedronType, StellatedOctahedronType, MyAny);
|
||
|
||
PanelModelBuilder = class
|
||
Panels: List<Panel> := new List<Panel>;
|
||
TriangleIndexToPanelIndex: List<integer>;
|
||
|
||
procedure AddPanel(params points: array of Point3D);
|
||
begin
|
||
var p := new Panel;
|
||
p.points := points;
|
||
Panels.Add(p);
|
||
end;
|
||
|
||
procedure AddPanel(params coords: array of real);
|
||
begin
|
||
var points := new Point3D[coords.Length div 3];
|
||
for var i := 0 to coords.Length div 3 - 1 do
|
||
points[i] := new Point3D(coords[i * 3], coords[i * 3 + 1], coords[i * 3 + 2]);
|
||
Reverse(points);
|
||
AddPanel(points);
|
||
end;
|
||
|
||
function ToMeshGeometry3D(): MeshGeometry3D;
|
||
begin
|
||
TriangleIndexToPanelIndex := new List<integer>;
|
||
|
||
var tm := new MeshBuilder(false, false);
|
||
var panelIndex := 0;
|
||
foreach var p in Panels do
|
||
begin
|
||
p.TriangleIndex := tm.Positions.Count;
|
||
tm.AddTriangleFan(p.Points, nil, nil);
|
||
for var i := 0 to p.Points.Length - 3 do
|
||
TriangleIndexToPanelIndex.Add(panelIndex);
|
||
|
||
panelIndex += 1;
|
||
end;
|
||
var panelsGeometry := tm.ToMesh(false);
|
||
|
||
Result := panelsGeometry;
|
||
end;
|
||
end;
|
||
|
||
function CreateModel(CurrentModelType: ModelTypes; a: real): MeshGeometry3D;
|
||
begin
|
||
var pmb := new PanelModelBuilder();
|
||
case CurrentModelType of
|
||
TetrahedronType:
|
||
begin
|
||
a /= Sqrt(8); // тогда длина ребра = 1
|
||
pmb.AddPanel(a, a, a, -a, a, -a, a, -a, -a);
|
||
pmb.AddPanel(-a, a, -a, -a, -a, a, a, -a, -a);
|
||
pmb.AddPanel(a, a, a, a, -a, -a, -a, -a, a);
|
||
pmb.AddPanel(a, a, a, -a, -a, a, -a, a, -a);
|
||
end;
|
||
OctahedronType:
|
||
begin
|
||
a /= 2;
|
||
var b := 0.5 * (2 * Sqrt(2)) * a;
|
||
pmb.AddPanel(-a, 0, a, -a, 0, -a, 0, b, 0);
|
||
pmb.AddPanel(-a, 0, -a, a, 0, -a, 0, b, 0);
|
||
pmb.AddPanel(a, 0, -a, a, 0, a, 0, b, 0);
|
||
pmb.AddPanel(a, 0, a, -a, 0, a, 0, b, 0);
|
||
pmb.AddPanel(a, 0, -a, -a, 0, -a, 0, -b, 0);
|
||
pmb.AddPanel(-a, 0, -a, -a, 0, a, 0, -b, 0);
|
||
pmb.AddPanel(a, 0, a, a, 0, -a, 0, -b, 0);
|
||
pmb.AddPanel(-a, 0, a, a, 0, a, 0, -b, 0);
|
||
end;
|
||
HexahedronType:
|
||
begin
|
||
a /= 2;
|
||
pmb.AddPanel(-a, -a, a, a, -a, a, a, -a, -a, -a, -a, -a);
|
||
pmb.AddPanel(-a, a, -a, -a, a, a, -a, -a, a, -a, -a, -a);
|
||
pmb.AddPanel(-a, a, a, a, a, a, a, -a, a, -a, -a, a);
|
||
pmb.AddPanel(a, a, -a, a, a, a, -a, a, a, -a, a, -a);
|
||
pmb.AddPanel(a, -a, a, a, a, a, a, a, -a, a, -a, -a);
|
||
pmb.AddPanel(a, -a, -a, a, a, -a, -a, a, -a, -a, -a, -a);
|
||
end;
|
||
IcosahedronType:
|
||
begin
|
||
a /= Sqrt(5) - 1;
|
||
var phi := (1 + Sqrt(5)) / 2;
|
||
var b := 1.0 / (2 * phi) * 2 * a;
|
||
pmb.AddPanel(0, b, -a, b, a, 0, -b, a, 0);
|
||
pmb.AddPanel(0, b, a, -b, a, 0, b, a, 0);
|
||
pmb.AddPanel(0, b, a, 0, -b, a, -a, 0, b);
|
||
pmb.AddPanel(0, b, a, a, 0, b, 0, -b, a);
|
||
pmb.AddPanel(0, b, -a, 0, -b, -a, a, 0, -b);
|
||
pmb.AddPanel(0, b, -a, -a, 0, -b, 0, -b, -a);
|
||
pmb.AddPanel(0, -b, a, b, -a, 0, -b, -a, 0);
|
||
pmb.AddPanel(0, -b, -a, -b, -a, 0, b, -a, 0);
|
||
pmb.AddPanel(-b, a, 0, -a, 0, b, -a, 0, -b);
|
||
pmb.AddPanel(-b, -a, 0, -a, 0, -b, -a, 0, b);
|
||
pmb.AddPanel(b, a, 0, a, 0, -b, a, 0, b);
|
||
pmb.AddPanel(b, -a, 0, a, 0, b, a, 0, -b);
|
||
pmb.AddPanel(0, b, a, -a, 0, b, -b, a, 0);
|
||
pmb.AddPanel(0, b, a, b, a, 0, a, 0, b);
|
||
pmb.AddPanel(0, b, -a, -b, a, 0, -a, 0, -b);
|
||
pmb.AddPanel(0, b, -a, a, 0, -b, b, a, 0);
|
||
pmb.AddPanel(0, -b, -a, -a, 0, -b, -b, -a, 0);
|
||
pmb.AddPanel(0, -b, -a, b, -a, 0, a, 0, -b);
|
||
pmb.AddPanel(0, -b, a, -b, -a, 0, -a, 0, b);
|
||
pmb.AddPanel(0, -b, a, a, 0, b, b, -a, 0);
|
||
end;
|
||
DodecahedronType:
|
||
begin
|
||
var phi := (1 + Sqrt(5)) / 2;
|
||
a /= 2 * (2 - phi);
|
||
var b := 1 / phi * a;
|
||
var c := (2 - phi) * a;
|
||
pmb.AddPanel(c, 0, a, -c, 0, a, -b, b, b, 0, a, c, b, b, b);
|
||
pmb.AddPanel(-c, 0, a, c, 0, a, b, -b, b, 0, -a, c, -b, -b, b);
|
||
pmb.AddPanel(c, 0, -a, -c, 0, -a, -b, -b, -b, 0, -a, -c, b, -b, -b);
|
||
pmb.AddPanel(-c, 0, -a, c, 0, -a, b, b, -b, 0, a, -c, -b, b, -b);
|
||
pmb.AddPanel(b, b, -b, a, c, 0, b, b, b, 0, a, c, 0, a, -c);
|
||
|
||
pmb.AddPanel(-b, b, b, -a, c, 0, -b, b, -b, 0, a, -c, 0, a, c);
|
||
pmb.AddPanel(-b, -b, -b, -a, -c, 0, -b, -b, b, 0, -a, c, 0, -a, -c);
|
||
|
||
pmb.AddPanel(b, -b, b, a, -c, 0, b, -b, -b, 0, -a, -c, 0, -a, c);
|
||
pmb.AddPanel(a, c, 0, a, -c, 0, b, -b, b, c, 0, a, b, b, b);
|
||
pmb.AddPanel(a, -c, 0, a, c, 0, b, b, -b, c, 0, -a, b, -b, -b);
|
||
pmb.AddPanel(-a, c, 0, -a, -c, 0, -b, -b, -b, -c, 0, -a, -b, b, -b);
|
||
pmb.AddPanel(-a, -c, 0, -a, c, 0, -b, b, b, -c, 0, a, -b, -b, b);
|
||
end;
|
||
StellatedOctahedronType:
|
||
begin
|
||
pmb.AddPanel(a, a, a, -a, a, -a, a, -a, -a);
|
||
pmb.AddPanel(-a, a, -a, -a, -a, a, a, -a, -a);
|
||
pmb.AddPanel(a, a, a, a, -a, -a, -a, -a, a);
|
||
pmb.AddPanel(a, a, a, -a, -a, a, -a, a, -a);
|
||
pmb.AddPanel(-a, a, a, a, a, -a, -a, -a, -a);
|
||
pmb.AddPanel(a, a, -a, a, -a, a, -a, -a, -a);
|
||
pmb.AddPanel(-a, a, a, -a, -a, -a, a, -a, a);
|
||
pmb.AddPanel(-a, a, a, a, -a, a, a, a, -a);
|
||
end;
|
||
MyAny:
|
||
begin
|
||
pmb.AddPanel(0, 0, 0, -a, 0, 0, -a, 0, a, 0, 0, a);
|
||
pmb.AddPanel(-a, 0, 0, 0, a, 0, 0, a, a, -a, 0, a);
|
||
pmb.AddPanel(0, a, 0, 0, 0, 0, 0, 0, a, 0, a, a);
|
||
pmb.AddPanel(0, 0, 0, 0, a, 0, -a, 0, 0);
|
||
pmb.AddPanel(0, 0, a, -a, 0, a, 0, a, a);
|
||
end;
|
||
end;
|
||
Result := pmb.ToMeshGeometry3D;
|
||
end;
|
||
|
||
type
|
||
PlatonicAbstractVisual3D = abstract class(MeshElement3D)
|
||
private
|
||
fa: real;
|
||
procedure SetA(value: real);begin fa := value; OnGeometryChanged; end;
|
||
|
||
public
|
||
constructor(Length: real);
|
||
begin
|
||
inherited Create;
|
||
Self.Length := Length;
|
||
end;
|
||
|
||
property Length: real read fa write SetA;
|
||
end;
|
||
IcosahedronVisual3D = class(PlatonicAbstractVisual3D)
|
||
public function Tessellate(): MeshGeometry3D; override := CreateModel(ModelTypes.IcosahedronType, Length);
|
||
end;
|
||
DodecahedronVisual3D = class(PlatonicAbstractVisual3D)
|
||
public function Tessellate(): MeshGeometry3D; override := CreateModel(ModelTypes.DodecahedronType, Length);
|
||
end;
|
||
TetrahedronVisual3D = class(PlatonicAbstractVisual3D)
|
||
public function Tessellate(): MeshGeometry3D; override := CreateModel(ModelTypes.TetrahedronType, Length);
|
||
end;
|
||
OctahedronVisual3D = class(PlatonicAbstractVisual3D)
|
||
public function Tessellate(): MeshGeometry3D; override := CreateModel(ModelTypes.OctahedronType, Length);
|
||
end;
|
||
MyAnyVisual3D = class(PlatonicAbstractVisual3D)
|
||
public function Tessellate(): MeshGeometry3D; override := CreateModel(ModelTypes.MyAny, Length);
|
||
end;
|
||
|
||
function PlatonicAbstractT.GetLength: real := InvokeReal(()->(model as PlatonicAbstractVisual3D).Length);
|
||
procedure PlatonicAbstractT.SetLengthP(r: real) := (model as PlatonicAbstractVisual3D).Length := r;
|
||
|
||
constructor IcosahedronT.Create(x, y, z, Length: real; m: GMaterial) := CreateBase(new IcosahedronVisual3D(Length), x, y, z, m);
|
||
|
||
constructor DodecahedronT.Create(x, y, z, Length: real; m: GMaterial) := CreateBase(new DodecahedronVisual3D(Length), x, y, z, m);
|
||
|
||
constructor TetrahedronT.Create(x, y, z, Length: real; m: GMaterial) := CreateBase(new TetrahedronVisual3D(Length), x, y, z, m);
|
||
|
||
constructor OctahedronT.Create(x, y, z, Length: real; m: GMaterial) := CreateBase(new OctahedronVisual3D(Length), x, y, z, m);
|
||
|
||
|
||
type
|
||
PrismVisual3D = class(MeshElement3D)
|
||
private
|
||
fn: integer;
|
||
fh, fr: real;
|
||
procedure SetR(value: real);begin fr := value; OnGeometryChanged; end;
|
||
|
||
procedure SetH(value: real);begin fh := value; OnGeometryChanged; end;
|
||
|
||
procedure SetN(value: integer);begin fn := value; OnGeometryChanged; end;
|
||
|
||
public
|
||
constructor(N: integer; Radius, Height: real);
|
||
begin
|
||
(fn, fr, fh) := (n, Radius, Height);
|
||
OnGeometryChanged;
|
||
end;
|
||
|
||
property Height: real read fh write SetH;
|
||
property Radius: real read fr write SetR;
|
||
property N: integer read fn write SetN;
|
||
protected
|
||
function Tessellate(): MeshGeometry3D; override;
|
||
begin
|
||
var pmb := new PanelModelBuilder();
|
||
if N > 0 then
|
||
begin
|
||
var a := Partition(0, 2 * Pi, N).Select(x -> P3D(fr * cos(x), fr * sin(x), 0)).ToArray;
|
||
var b := Partition(0, 2 * Pi, N).Select(x -> P3D(fr * cos(x), fr * sin(x), fh)).ToArray;
|
||
for var i := 0 to fn - 1 do
|
||
pmb.AddPanel(a[i + 1].X, a[i + 1].Y, a[i + 1].Z, a[i].X, a[i].Y, a[i].Z, b[i].X, b[i].Y, b[i].Z, b[i + 1].X, b[i + 1].Y, b[i + 1].Z);
|
||
pmb.AddPanel(a.Reverse.ToArray);
|
||
pmb.AddPanel(b);
|
||
end;
|
||
Result := pmb.ToMeshGeometry3D
|
||
end;
|
||
end;
|
||
|
||
PyramidVisual3D = class(PrismVisual3D)
|
||
protected
|
||
function Tessellate(): MeshGeometry3D; override;
|
||
begin
|
||
var pmb := new PanelModelBuilder();
|
||
if N > 0 then
|
||
begin
|
||
var a := Partition(0, 2 * Pi, N).Select(x -> P3D(fr * cos(x), fr * sin(x), 0)).ToArray;
|
||
var top := P3D(0, 0, fh);
|
||
for var i := 0 to fn - 1 do
|
||
pmb.AddPanel(a[i + 1].X, a[i + 1].Y, a[i + 1].Z, a[i].X, a[i].Y, a[i].Z, top.X, top.Y, top.Z);
|
||
pmb.AddPanel(a.Reverse.ToArray);
|
||
end;
|
||
Result := pmb.ToMeshGeometry3D
|
||
end;
|
||
end;
|
||
|
||
TriangleVisual3D = class(MeshElement3D)
|
||
private
|
||
pp1, pp2, pp3: Point3D;
|
||
protected
|
||
function Tessellate(): MeshGeometry3D; override;
|
||
begin
|
||
var m := new MeshBuilder(true);
|
||
m.AddTriangle(p1, p2, p3);
|
||
Result := m.ToMesh;
|
||
end;
|
||
|
||
procedure SetP1(p1: Point3D);
|
||
begin
|
||
pp1 := p1;
|
||
OnGeometryChanged;
|
||
end;
|
||
|
||
procedure SetP2(p1: Point3D);
|
||
begin
|
||
pp2 := p2;
|
||
OnGeometryChanged;
|
||
end;
|
||
|
||
procedure SetP3(p3: Point3D);
|
||
begin
|
||
pp3 := p3;
|
||
OnGeometryChanged;
|
||
end;
|
||
|
||
public
|
||
constructor(ppp1, ppp2, ppp3: Point3D);
|
||
begin
|
||
(pp1, pp2, pp3) := (ppp1, ppp2, ppp3);
|
||
Material := Materialhelper.CreateMaterial(Colors.Red);
|
||
OnGeometryChanged;
|
||
end;
|
||
|
||
property P1: Point3D read pp1 write SetP1;
|
||
property P2: Point3D read pp2 write SetP2;
|
||
property P3: Point3D read pp3 write SetP3;
|
||
procedure SetPoints(p1, p2, p3: Point3D);
|
||
begin
|
||
pp1 := p1;
|
||
pp2 := p2;
|
||
pp3 := p3;
|
||
OnGeometryChanged;
|
||
end;
|
||
end;
|
||
|
||
|
||
procedure TriangleT.SetP1(p: Point3D) := Invoke(procedure(p: Point3D)->(model as TriangleVisual3D).P1 := p, p);
|
||
function TriangleT.GetP1: Point3D := Invoke&<Point3D>(()->(model as TriangleVisual3D).P1);
|
||
procedure TriangleT.SetP2(p: Point3D) := Invoke(procedure(p: Point3D)->(model as TriangleVisual3D).P2 := p, p);
|
||
function TriangleT.GetP2: Point3D := Invoke&<Point3D>(()->(model as TriangleVisual3D).P2);
|
||
procedure TriangleT.SetP3(p: Point3D) := Invoke(procedure(p: Point3D)->(model as TriangleVisual3D).P3 := p, p);
|
||
function TriangleT.GetP3: Point3D := Invoke&<Point3D>(()->(model as TriangleVisual3D).P3);
|
||
procedure TriangleT.SetPoints(p1, p2, p3: Point3D) := Invoke(procedure(p1, p2, p3: Point3D)->begin (model as TriangleVisual3D).SetPoints(p1, p2, p3); end, p1, p2, p3);
|
||
|
||
function TriangleT.CreateObject: Object3D := new TriangleT((model as TriangleVisual3D).p1, (model as TriangleVisual3D).p2, (model as TriangleVisual3D).p3, Material.Clone);
|
||
|
||
constructor TriangleT.Create(p1, p2, p3: Point3D; m: Gmaterial);
|
||
begin
|
||
CreateBase(new TriangleVisual3D(p1, p2, p3), 0, 0, 0, m);
|
||
(model as TriangleVisual3D).BackMaterial := (model as TriangleVisual3D).Material;
|
||
end;
|
||
|
||
procedure PrismT.SetR(r: real) := Invoke(procedure(r: real)->(model as PrismVisual3D).Radius := r, r);
|
||
function PrismT.GetR: real := InvokeReal(()->(model as PrismVisual3D).Radius);
|
||
procedure PrismT.SetH(r: real) := Invoke(procedure(r: real)->(model as PrismVisual3D).Height := r, r);
|
||
function PrismT.GetH: real := InvokeReal(()->(model as PrismVisual3D).Height);
|
||
procedure PrismT.SetN(n: integer) := Invoke(procedure(n: integer)->(model as PrismVisual3D).N := n, n);
|
||
function PrismT.GetN: integer := InvokeInteger(()->(model as PrismVisual3D).N);
|
||
|
||
constructor PrismT.Create(x, y, z: real; N: integer; r, h: real; m: Gmaterial) := CreateBase(new PrismVisual3D(N, r, h), x, y, z, m);
|
||
|
||
constructor PyramidT.Create(x, y, z: real; N: integer; r, h: real; m: GMaterial) := CreateBase(new PyramidVisual3D(N, r, h), x, y, z, m);
|
||
|
||
|
||
|
||
|
||
function DefaultMaterialColor := RandomColor;
|
||
|
||
function DefaultMaterial: Material := MaterialHelper.CreateMaterial(DefaultMaterialColor);
|
||
|
||
function Group(x, y, z: integer): Group3D := Inv(()->Group3D.Create(x, y, z));
|
||
|
||
function Group(p: Point3D): Group3D := Inv(()->Group3D.Create(p.x, p.y, p.z));
|
||
|
||
function Group: Group3D := Inv(()->Group3D.Create(0, 0, 0));
|
||
|
||
function Group(params lst: array of Object3D): Group3D := Inv(()->Group3D.Create(0, 0, 0, lst));
|
||
|
||
function Group(en: sequence of Object3D): Group3D := Inv(()->Group3D.Create(0, 0, 0, en));
|
||
|
||
function Sphere(x, y, z, Radius: real; m: Material): SphereT := Inv(()->SphereT.Create(x, y, z, Radius, m));
|
||
|
||
function Sphere(center: Point3D; Radius: real; m: Material) := Sphere(center.x, center.y, center.z, Radius, m);
|
||
|
||
function Ellipsoid(x, y, z, RadiusX, RadiusY, RadiusZ: real; m: Material): EllipsoidT := Inv(()->EllipsoidT.Create(x, y, z, RadiusX, RadiusY, RadiusZ, m));
|
||
|
||
function Ellipsoid(center: Point3D; RadiusX, RadiusY, RadiusZ: real; m: Material) := Ellipsoid(center.x, center.y, center.z, RadiusX, RadiusY, RadiusZ, m);
|
||
|
||
function Cube(x, y, z, SideLength: real; m: Material): CubeT := Inv(()->CubeT.Create(x, y, z, SideLength, m));
|
||
|
||
function Cube(center: Point3D; SideLength: real; m: Material): CubeT := Cube(center.x, center.y, center.z, SideLength, m);
|
||
|
||
function Box(x, y, z, SizeX, SizeY, SizeZ: real; m: Material): BoxT := Inv(()->BoxT.Create(x, y, z, SizeX, SizeY, SizeZ, m));
|
||
|
||
function Box(center: Point3D; sz: Size3D; m: Material): BoxT := Inv(()->BoxT.Create(center.x, center.y, center.z, sz.X, sz.Y, sz.z, m));
|
||
|
||
const
|
||
arhl = 3; ard = 0.2;
|
||
|
||
function Arrow(x, y, z, vx, vy, vz, diameter, HeadLength: real; m: Material): ArrowT := Inv(()->ArrowT.Create(x, y, z, vx, vy, vz, diameter, HeadLength, m));
|
||
|
||
function Arrow(x, y, z, vx, vy, vz, diameter: real; m: Material) := Arrow(x, y, z, vx, vy, vz, diameter, arhl, m);
|
||
|
||
function Arrow(x, y, z, vx, vy, vz: real; m: Material) := Arrow(x, y, z, vx, vy, vz, ard, arhl, m);
|
||
|
||
function Arrow(p: Point3D; v: Vector3D; diameter, HeadLength: real; m: Material) := Arrow(p.x, p.y, p.z, v.X, v.Y, v.Z, diameter, HeadLength, m);
|
||
|
||
function Arrow(p: Point3D; v: Vector3D; diameter: real; m: Material) := Arrow(p.x, p.y, p.z, v.X, v.Y, v.Z, diameter, arhl, m);
|
||
|
||
function Arrow(p: Point3D; v: Vector3D; m: Material) := Arrow(p.x, p.y, p.z, v.X, v.Y, v.Z, ard, arhl, m);
|
||
|
||
function TruncatedConeAux(x, y, z, Height, Radius, TopRadius: real; sides: integer; topcap: boolean; c: Material) := Inv(()->TruncatedConeT.Create(x, y, z, Height, Radius, TopRadius, sides, topcap, c));
|
||
|
||
const
|
||
maxsides = 37;
|
||
|
||
///--
|
||
function TruncatedCone(x, y, z, Height, Radius, TopRadius: real; topcap: boolean; m: Material): TruncatedConeT := TruncatedConeAux(x, y, z, Height, Radius, TopRadius, maxsides, topcap, m);
|
||
|
||
function TruncatedCone(x, y, z, Height, Radius, TopRadius: real; m: Material) := TruncatedCone(x, y, z, Height, Radius, TopRadius, True, m);
|
||
///--
|
||
function TruncatedCone(p: Point3D; Height, Radius, TopRadius: real; topcap: boolean; m: Material) := TruncatedCone(p.x, p.y, p.z, Height, Radius, TopRadius, topcap, m);
|
||
|
||
function TruncatedCone(p: Point3D; Height, Radius, TopRadius: real; m: Material) := TruncatedCone(p.x, p.y, p.z, Height, Radius, TopRadius, True, m);
|
||
|
||
///--
|
||
function Cylinder(x, y, z, Height, Radius: real; topcap: boolean; m: Material): CylinderT := Inv(()->CylinderT.Create(x, y, z, Height, Radius, maxsides, topcap, m));
|
||
|
||
function Cylinder(x, y, z, Height, Radius: real; m: Material) := Cylinder(x, y, z, Height, Radius, True, m);
|
||
///--
|
||
function Cylinder(p: Point3D; Height, Radius: real; topcap: boolean; m: Material) := Cylinder(p.x, p.y, p.z, Height, Radius, topcap, m);
|
||
|
||
function Cylinder(p: Point3D; Height, Radius: real; m: Material) := Cylinder(p.x, p.y, p.z, Height, Radius, True, m);
|
||
|
||
function Tube(x, y, z, Height, Radius, InnerRadius: real; m: Material): PipeT := Inv(()->PipeT.Create(x, y, z, Height, Radius, InnerRadius, m));
|
||
|
||
function Tube(p: Point3D; Height, Radius, InnerRadius: real; m: Material) := Tube(p.x, p.y, p.z, Height, Radius, InnerRadius, m);
|
||
|
||
function Cone(x, y, z, Height, Radius: real; m: Material): TruncatedConeT := TruncatedCone(x, y, z, Height, Radius, 0, True, m);
|
||
|
||
function Cone(p: Point3D; Height, Radius: real; m: Material) := TruncatedCone(p.x, p.y, p.z, Height, Radius, 0, True, m);
|
||
|
||
function Teapot(x, y, z: real; c: Material): TeapotT := Inv(()->TeapotT.Create(x, y, z, c));
|
||
|
||
function Teapot(p: Point3D; c: Material) := Teapot(p.x, p.y, p.z, c);
|
||
|
||
function BillboardText(x, y, z: real; Text: string; Fontsize: real): BillboardTextT := Inv(()->BillboardTextT.Create(x, y, z, text, fontsize));
|
||
|
||
function BillboardText(p: Point3D; Text: string; Fontsize: real) := BillboardText(P.x, p.y, p.z, text, fontsize);
|
||
|
||
function CoordinateSystem(ArrowsLength, Diameter: real): CoordinateSystemT := Inv(()->CoordinateSystemT.Create(0, 0, 0, arrowslength, diameter));
|
||
|
||
function CoordinateSystem(ArrowsLength: real) := CoordinateSystem(arrowslength, arrowslength / 10);
|
||
|
||
function Text3D(x, y, z: real; Text: string; Height: real; fontname: string; c: Color): TextT := Inv(()->TextT.Create(x, y, z, text, height, fontname, c));
|
||
|
||
function Text3D(p: Point3D; Text: string; Height: real; fontname: string; c: Color) := Text3D(P.x, p.y, p.z, text, height, fontname, c);
|
||
|
||
function Text3D(x, y, z: real; Text: string; Height: real; c: Color) := Text3D(x, y, z, text, height, 'Arial', c);
|
||
|
||
function Text3D(p: Point3D; Text: string; Height: real; c: Color) := Text3D(p.x, p.y, p.z, text, height, 'Arial', c);
|
||
|
||
function Rectangle3D(x, y, z, Length, Width: real; Normal, LengthDirection: Vector3D; m: Material): RectangleT := Inv(()->RectangleT.Create(x, y, z, Length, Width, normal, LengthDirection, m));
|
||
|
||
function Rectangle3D(p: Point3D; Length, Width: real; Normal, LengthDirection: Vector3D; m: Material): RectangleT := Rectangle3D(p.x, p.y, p.z, Length, Width, Normal, LengthDirection, m);
|
||
|
||
function Rectangle3D(x, y, z, Length, Width: real; Normal: Vector3D; m: Material): RectangleT := Rectangle3D(x, y, z, Length, Width, Normal, OrtX, m);
|
||
|
||
function Rectangle3D(x, y, z, Length, Width: real; m: Material): RectangleT := Rectangle3D(x, y, z, Length, Width, OrtZ, OrtX, m);
|
||
|
||
function Rectangle3D(p: Point3D; Length, Width: real; Normal: Vector3D; m: Material): RectangleT := Rectangle3D(p.x, p.y, p.z, Length, Width, Normal, OrtX, m);
|
||
|
||
function Rectangle3D(p: Point3D; Length, Width: real; m: Material): RectangleT := Rectangle3D(p.x, p.y, p.z, Length, Width, OrtZ, OrtX, m);
|
||
|
||
/// Загружает модель из файла .obj, .3ds, .lwo, .objz, .stl, .off
|
||
function FileModel3D(x, y, z: real; fname: string; m: Material): FileModelT := Inv(()->FileModelT.Create(x, y, z, fname, m));
|
||
|
||
function FileModel3D(p: Point3D; fname: string; m: Material): FileModelT := FileModel3D(p.x, p.y, p.z, fname, m);
|
||
|
||
function Prism(x, y, z: real; Sides: integer; Height, Radius: real; m: Material): PrismT := Inv(()->PrismT.Create(x, y, z, Sides, Radius, Height, m));
|
||
|
||
function Prism(p: Point3D; Sides: integer; Height, Radius: real; m: Material): PrismT := Prism(p.X, p.Y, p.Z, Sides, Radius, Height, m);
|
||
|
||
function PrismWireFrame(x, y, z: real; Sides: integer; Height, Radius: real; Thickness: real; c: Color): PrismTWireFrame := Inv(()->PrismTWireFrame.Create(x, y, z, Sides, Radius, Height, thickness, c));
|
||
|
||
function PrismWireFrame(p: Point3D; Sides: integer; Height, Radius: real; Thickness: real; c: Color): PrismTWireFrame := PrismWireFrame(p.x, p.y, p.z, Sides, Radius, Height, thickness, c);
|
||
|
||
function Pyramid(x, y, z: real; Sides: integer; Height, Radius: real; m: Material): PyramidT := Inv(()->PyramidT.Create(x, y, z, Sides, Radius, Height, m));
|
||
|
||
function Pyramid(p: Point3D; Sides: integer; Height, Radius: real; m: Material): PyramidT := Pyramid(p.X, p.Y, p.Z, Sides, Radius, Height, m);
|
||
|
||
function PyramidWireFrame(x, y, z: real; Sides: integer; Height, Radius: real; Thickness: real; c: Color): PyramidTWireFrame := Inv(()->PyramidTWireFrame.Create(x, y, z, Sides, Radius, Height, thickness, c));
|
||
|
||
function PyramidWireFrame(p: Point3D; Sides: integer; Height, Radius: real; Thickness: real; c: Color): PyramidTWireFrame := PyramidWireFrame(p.x, p.y, p.z, Sides, Radius, Height, thickness, c);
|
||
|
||
function Lego(x, y, z: real; Rows, Columns, Height: integer; m: Material): LegoT := Inv(()->LegoT.Create(x, y, z, Rows, Columns, Height, m));
|
||
|
||
function Icosahedron(x, y, z, Radius: real; m: Material): IcosahedronT := Inv(()->IcosahedronT.Create(x, y, z, 4 * Radius / Sqrt(2) / Sqrt(5 + Sqrt(5)), m));
|
||
|
||
function Dodecahedron(x, y, z, Radius: real; m: Material): DodecahedronT := Inv(()->DodecahedronT.Create(x, y, z, Radius * 4 / Sqrt(3) / (1 + Sqrt(5)), m));
|
||
|
||
function Tetrahedron(x, y, z, Radius: real; m: Material): TetrahedronT := Inv(()->TetrahedronT.Create(x, y, z, 4 * Radius / Sqrt(6), m));
|
||
|
||
function Octahedron(x, y, z, Radius: real; m: Material): OctahedronT := Inv(()->OctahedronT.Create(x, y, z, Radius * Sqrt(2), m));
|
||
|
||
function Icosahedron(p: Point3D; Radius: real; m: Material): IcosahedronT := Icosahedron(p.X, p.Y, p.Z, Radius, m);
|
||
|
||
function Dodecahedron(p: Point3D; Radius: real; m: Material): DodecahedronT := Dodecahedron(p.X, p.Y, p.Z, Radius, m);
|
||
|
||
function Tetrahedron(p: Point3D; Radius: real; m: Material): TetrahedronT := Tetrahedron(p.X, p.Y, p.Z, Radius, m);
|
||
|
||
function Octahedron(p: Point3D; Radius: real; m: Material): OctahedronT := Octahedron(p.X, p.Y, p.Z, Radius, m);
|
||
|
||
function Segments3D(points: sequence of Point3D; thickness: real; c: Color): SegmentsT := Inv(()->SegmentsT.Create(points, thickness, c));
|
||
|
||
function Polyline3D(points: sequence of Point3D; thickness: real; c: Color): SegmentsT := Inv(()->SegmentsT.Create(points.Pairwise.SelectMany(x -> Seq(x[0], x[1])), thickness, c));
|
||
|
||
function Polygon3D(points: sequence of Point3D; thickness: real; c: Color): SegmentsT := Inv(()->SegmentsT.Create((points + points.First).Pairwise.SelectMany(x -> Seq(x[0], x[1])), thickness, c));
|
||
|
||
function Segment3D(p1, p2: Point3D; thickness: real; c: Color): SegmentsT := Inv(()->SegmentsT.Create(Seq(p1, p2), thickness, c));
|
||
|
||
function Torus(x, y, z, Diameter, TubeDiameter: real; m: Material): TorusT := Inv(()->TorusT.Create(x, y, z, Diameter, TubeDiameter, m));
|
||
|
||
function Torus(p: Point3D; Diameter, TubeDiameter: real; m: Material): TorusT := Torus(p.x, p.y, p.z, Diameter, TubeDiameter, m);
|
||
|
||
function Triangle(p1, p2, p3: Point3D; m: Material): TriangleT := Inv(()->TriangleT.Create(p1, p2, p3, m));
|
||
|
||
// Конец примитивов
|
||
//------------------------------------------------------------------------------------
|
||
|
||
// Функции для точек, лучей, прямых, плоскостей
|
||
|
||
function FindNearestObject(x, y: real): Object3D;
|
||
begin
|
||
Result := nil;
|
||
var v := hvp.FindNearestVisual(new Point(x, y));
|
||
foreach var obj in Object3DList do
|
||
if obj.model = v then
|
||
Result := obj
|
||
end;
|
||
|
||
function FindNearestObjectPoint(x, y: real): Point3D;
|
||
begin
|
||
var p1 := hvp.FindNearestPoint(Pnt(x, y));
|
||
if p1.HasValue then
|
||
Result := p1.Value
|
||
else Result := BadPoint;
|
||
end;
|
||
|
||
function Plane(p: Point3D; normal: Vector3D): Plane3D := new Plane3D(p, normal);
|
||
|
||
function Ray(p: Point3D; v: Vector3D): Ray3D := new Ray3D(p, v);
|
||
|
||
function Line(p: Point3D; v: Vector3D): Line3D := new Line3D(p, v);
|
||
|
||
function Line(p1, p2: Point3D): Line3D := new Line3D(p1, p2 - p1);
|
||
|
||
function GetRay(x, y: real): Ray3D := hvp.Viewport.GetRay(Pnt(x, y));
|
||
|
||
function PointOnPlane(Self: Plane3D; x, y: real): Point3D; extensionmethod;
|
||
begin
|
||
var r := GetRay(x, y);
|
||
var p1 := r.PlaneIntersection(Self.Position, Self.Normal);
|
||
if p1.HasValue then
|
||
Result := p1.Value
|
||
else Result := BadPoint;
|
||
end;
|
||
|
||
function NearestPointOnLine(Self: Ray3D; x, y: real): Point3D; extensionmethod;
|
||
begin
|
||
var ray := GetRay(x, y);
|
||
var a := Self.Direction;
|
||
var b := ray.Direction;
|
||
var ab := Vector3D.CrossProduct(a, b);
|
||
var planeNormal := Vector3D.CrossProduct(b, ab);
|
||
var p := Self.PlaneIntersection(ray.Origin, planeNormal);
|
||
if p.HasValue then
|
||
Result := p.Value
|
||
else Result := BadPoint;
|
||
end;
|
||
|
||
function PointOnPlane(Plane: Plane3D; x, y: real): Point3D := Plane.PointOnPlane(x,y);
|
||
|
||
function NearestPointOnLine(Line: Ray3D; x, y: real): Point3D := Line.NearestPointOnLine(x,y);
|
||
|
||
|
||
|
||
// Методы расширения для анимаций
|
||
|
||
function Sec(Self: integer): real; extensionmethod := Self;
|
||
|
||
function Sec(Self: real): real; extensionmethod := Self;
|
||
|
||
// А теперь - тадам! - перегрузка + для Animate.Sequence и перегрузка * для Animate.Group
|
||
function operator+(a, b: AnimationBase): AnimationBase; extensionmethod := Animate.Sequence(a, b);
|
||
|
||
function operator*(a, b: AnimationBase): AnimationBase; extensionmethod := Animate.Group(a, b);
|
||
|
||
// Конец методов расширения для анимаций
|
||
|
||
// Методы расширения для точки
|
||
|
||
function operator*(p: Point3D; r: real): Point3D; extensionmethod := p.Multiply(r);
|
||
|
||
function operator*(r: real; p: Point3D): Point3D; extensionmethod := p.Multiply(r);
|
||
|
||
function operator+(p1, p2: Point3D): Point3D; extensionmethod := p3d(p1.X + p2.X, p1.Y + p2.Y, p1.Z + p2.Z);
|
||
|
||
function operator-(v: Vector3D): Vector3D; extensionmethod := v3d(-v.x,-v.y,-v.z);
|
||
|
||
function MoveX(Self: Point3D; dx: real): Point3D; extensionmethod := P3D(Self.x + dx, Self.y, Self.z);
|
||
|
||
function MoveY(Self: Point3D; dy: real): Point3D; extensionmethod := P3D(Self.x, Self.y + dy, Self.z);
|
||
|
||
function MoveZ(Self: Point3D; dz: real): Point3D; extensionmethod := P3D(Self.x, Self.y, Self.z + dz);
|
||
|
||
function Move(Self: Point3D; dx, dy, dz: real): Point3D; extensionmethod := P3D(Self.x + dx, Self.y + dy, Self.z + dz);
|
||
|
||
// Конец методов расширения для точки
|
||
|
||
type
|
||
TupleInt3 = (integer, integer, integer);
|
||
TupleReal3 = (real, real, real);
|
||
|
||
// Разные методы расширения
|
||
|
||
function ChangeOpacity(Self: GColor; value: integer): Color; extensionmethod := ARGB(value, Self.R, Self.G, Self.B);
|
||
|
||
function operator implicit(t: TupleInt3): Point3D; extensionmethod := new Point3D(t[0], t[1], t[2]);
|
||
|
||
function operator implicit(t: TupleReal3): Point3D; extensionmethod := new Point3D(t[0], t[1], t[2]);
|
||
|
||
function operator implicit(ar: array of TupleInt3): Point3DCollection; extensionmethod := new Point3DCollection(ar.Select(t -> new Point3D(t[0], t[1], t[2])));
|
||
|
||
function operator implicit(ar: array of Point3D): Point3DCollection; extensionmethod := new Point3DCollection(ar);
|
||
|
||
function operator implicit(ar: List<Point3D>): Point3DCollection; extensionmethod := new Point3DCollection(ar);
|
||
|
||
// Конец разных методов расширения
|
||
|
||
type
|
||
GMHelper = auto class
|
||
a, b: Material;
|
||
function GroupMaterial: Material;
|
||
begin
|
||
var g := new MaterialGroup();
|
||
g.Children.Add(a);
|
||
g.Children.Add(b);
|
||
Result := g;
|
||
end;
|
||
end;
|
||
|
||
// Методы расширения для Material
|
||
|
||
function operator+(a, b: Material): Material; extensionmethod := Invoke&<Material>(GMHelper.Create(a, b).GroupMaterial);
|
||
|
||
function operator implicit(c: GColor): GMaterial; extensionmethod := Materialhelper.CreateMaterial(c);
|
||
|
||
// Конец методов расширения для Material
|
||
|
||
|
||
//=============================================================================
|
||
|
||
// Экспериментальные функции и классы
|
||
type
|
||
MyAnyT = class(PlatonicAbstractT)
|
||
protected
|
||
function CreateObject: Object3D; override := new MyAnyT(X, Y, Z, Length, Material);
|
||
public
|
||
constructor(x, y, z, Length: real; m: GMaterial);
|
||
begin
|
||
CreateBase(new MyAnyVisual3D(Length), x, y, z, m);
|
||
end;
|
||
|
||
function Clone := (inherited Clone) as MyAnyT;
|
||
end;
|
||
|
||
|
||
procedure ProbaP;
|
||
begin
|
||
//var m := MaterialHelper.CreateMaterial(Brushes.Green,100,100);
|
||
//m.AmbientColor := Colors.Red;
|
||
//m.Color := Colors.Green;
|
||
//var bi := new System.Windows.Media.Imaging.BitmapImage(new System.Uri('dog.png',System.UriKind.Relative));
|
||
//var b := new ImageBrush(bi);
|
||
//b.ViewportUnits := BrushMappingMode.Absolute;
|
||
//b.Viewport := Rect(0,0,0.2,0.3);
|
||
//b.TileMode := System.Windows.Media.TileMode.Tile;
|
||
//Cube(6,-4,0,4,MaterialHelper.CreateMaterial(b));
|
||
Sphere(2, -4, 0, 2, MaterialHelper.CreateMaterial(Brushes.Green, 0.4, 100, 255));
|
||
Sphere(-2, -4, 0, 2, MaterialHelper.CreateMaterial(Brushes.Green, 0.6, 100, 255));
|
||
Sphere(-6, -4, 0, 2, MaterialHelper.CreateMaterial(Brushes.Green, 0.8, 100, 0));
|
||
|
||
Sphere(6, 0, 0, 2, MaterialHelper.CreateMaterial(Brushes.Green, 0.5, 100, 255));
|
||
Sphere(2, 0, 0, 2, MaterialHelper.CreateMaterial(Brushes.Green, 0.5, 70, 255));
|
||
Sphere(-2, 0, 0, 2, MaterialHelper.CreateMaterial(Brushes.Green, 0.5, 40, 255));
|
||
Sphere(-6, 0, 0, 2, MaterialHelper.CreateMaterial(Brushes.Green, 0.5, 20, 255));
|
||
|
||
Sphere(6, 4, 0, 2, MaterialHelper.CreateMaterial(Brushes.Green, Brushes.Gray, nil, 1));
|
||
//Sphere(2,4,0,2,MaterialHelper.CreateMaterial((Brushes.Green,new SolidColorBrush(RGB(0,64,0)),new SolidColorBrush(Rgb(128, 128, 128)), 100));
|
||
Sphere(-2, 4, 0, 2, MaterialHelper.CreateMaterial(Brushes.Green, 0.5, 40, 255));
|
||
//Cube(-6,4,0,4,Materials.Rainbow);
|
||
//var g := hvp.Children[1] as DefaultLights;
|
||
end;
|
||
|
||
procedure Proba := Invoke(ProbaP);
|
||
|
||
procedure ProbaP2;
|
||
begin
|
||
//var c := new CubeVisual3D();
|
||
//var c := new IcosahedronVisual3D();
|
||
//c.Length := 1;
|
||
//c.Material := Colors.Green;
|
||
//hvp.Children.Add(c);
|
||
//var ex := new HelixToolkit.Wpf.XamlExporter();
|
||
//ex.Export(c,new System.IO.FileStream('cube.xaml',System.IO.FileMode.Create));
|
||
|
||
//XamlWriter.Save(c,new System.IO.StreamWriter('www1.xaml'));
|
||
//var c1 := XamlReader.Load(new System.IO.FileStream('cube.xaml',System.IO.FileMode.Open)) as CubeVisual3D;
|
||
//hvp.Children.Add(c1);
|
||
|
||
{var off := new offreader(nil);
|
||
var s := System.IO.File.OpenRead('boxcube.off');
|
||
off.Load(s);
|
||
|
||
var m1 := new MeshVisual3D();
|
||
m1.FaceMaterial := Colors.Green;
|
||
m1.EdgeDiameter := 0;
|
||
m1.VertexRadius := 0;
|
||
m1.Mesh := off.CreateMesh;
|
||
hvp.Children.Add(m1);}
|
||
|
||
{var ex := new ExtrudedVisual3D();
|
||
ex.BackMaterial := Colors.Green;
|
||
ex.Diameters := new DoubleCollection(Arr(1.0,1.5,1.2));
|
||
ex.Path := new Point3DCollection(Arr(P3D(0,0,0),P3D(0,1,0),P3D(0,1,1),P3D(1,1,1)));
|
||
hvp.Children.Add(ex);}
|
||
|
||
var m := new SphereVisual3D();
|
||
m.Radius := 0.5;
|
||
hvp.Children.Add(m);
|
||
|
||
var t := new TranslateManipulator();
|
||
t.Color := Colors.Green;
|
||
//t.Offset := v3D(2,3,4);
|
||
t.Length := 2;
|
||
t.Diameter := 0.15;
|
||
t.Direction := V3D(1, 2, 0);
|
||
t.Value := 5;
|
||
|
||
var b := new System.Windows.Data.Binding('Transform');
|
||
b.Source := m;
|
||
|
||
var b1 := new System.Windows.Data.Binding('Transform');
|
||
b1.Source := m;
|
||
|
||
System.Windows.Data.BindingOperations.SetBinding(t, Manipulator.TargetTransformProperty, b);
|
||
System.Windows.Data.BindingOperations.SetBinding(t, Manipulator.TransformProperty, b);
|
||
|
||
//t.Bind(m);
|
||
hvp.Children.Add(t);
|
||
|
||
{var l := Lst(P3D(0,1,0),P3D(1,0,0),P3D(0,-1,0),P3D(-1,0,0),P3D(0,1,0));
|
||
|
||
var l1 := CanonicalSplineHelper.CreateSpline(l,0.5);
|
||
Polyline3D(l1);}
|
||
|
||
end;
|
||
|
||
procedure Proba2 := Invoke(ProbaP2);
|
||
|
||
procedure ProbaP3(x,y,z: real);
|
||
begin
|
||
hvp.CameraController.AddMoveForce(x,y,z);
|
||
end;
|
||
|
||
procedure Proba3(x,y,z: real) := Invoke(ProbaP3,x,y,z);
|
||
|
||
type
|
||
My = class(ParametricSurface3D)
|
||
public
|
||
function Evaluate(u: real; v: real; var textureCoord: System.Windows.Point): Point3D; override;
|
||
begin
|
||
u -= 0.5;
|
||
v -= 0.5;
|
||
u *= 3;
|
||
v *= 3;
|
||
textureCoord := new Point(u, 2 * v);
|
||
Result := P3D(u, v, 0.2 * u * u + sin(u * v) + 2);
|
||
end;
|
||
end;
|
||
|
||
My13D = class(MeshElement3D)
|
||
public function Tessellate(): MeshGeometry3D; override;
|
||
begin
|
||
var tm := new MeshBuilder(false, false);
|
||
tm.AddRevolvedGeometry(Arr(Pnt(0, 0), Pnt(0, 1), Pnt(0.3, 1), Pnt(0.5, 0.3), Pnt(2, 1), Pnt(3, 0)), nil, Origin, OrtZ, 80);
|
||
Result := tm.ToMesh(false);
|
||
end;
|
||
end;
|
||
|
||
type
|
||
AnyT = class(ObjectWithMaterial3D)
|
||
constructor(x, y, z: real; c: GColor);
|
||
begin
|
||
{var a := new ExtrudedVisual3D;
|
||
a.Path := new Point3DCollection(Arr(P3D(1,0,-0.5),P3D(1,0,0.5)));
|
||
a.Section := new PointCollection(Arr(Pnt(0,0),Pnt(0.5,0),Pnt(0,0.5)));
|
||
a.IsSectionClosed := True;}
|
||
|
||
//var a := new TerrainVisual3D;
|
||
//a.Content := (new SphereVisual3D()).Model;
|
||
//a.Text := 'PascalABC';
|
||
//var a := new LinesVisual3D;
|
||
{a.Thickness := 1.99;
|
||
a.Points := Arr(P3D(0, 0, 0), P3D(3, 0, 0), P3D(3, 0, 0), P3D(3, 3, 0), P3D(3, 3, 0), P3D(3, 3, 3));
|
||
a.Color := c;}
|
||
|
||
var a := new My13D;
|
||
a.Material := c;
|
||
|
||
|
||
{var aa := 1;
|
||
var b := 80;
|
||
|
||
var q := Partition(0,2*Pi*20,360*20*10).Select(t->P3D(5*cos(1*t),5*sin(1*t),t/5));
|
||
var q1 := q.Interleave(q.Skip(1));
|
||
|
||
//a.Points := Lst(P3D(0,0,0),P3D(4,4,2),p3D(4,4,2),p3D(2,8,-1));
|
||
a.Points := Lst(q1);
|
||
a.Color := Colors.Blue;
|
||
|
||
a.Thickness := 1.5;}
|
||
|
||
{var a := new HelixToolkit.Wpf.PieSliceVisual3D;
|
||
a.StartAngle := 0;
|
||
a.EndAngle := 360;
|
||
a.ThetaDiv := 60;}
|
||
|
||
{var a := new HelixToolkit.Wpf.TubeVisual3D;
|
||
var p := new Point3DCollection(Arr(P3D(1,2,0),P3D(2,1,0),P3D(3,1,0)));
|
||
a.Diameter := 0.05;
|
||
a.Path := p;}
|
||
|
||
{var a := new LegoVisual3D();
|
||
a.Rows := 1;
|
||
a.Columns := 2;
|
||
a.Height := 3;
|
||
//a.Divisions := 100;
|
||
a.Fill := Brushes.Blue;}
|
||
|
||
CreateBase0(a, x, y, z);
|
||
end;
|
||
end;
|
||
|
||
function MyH(x, y, z, Length: real; c: Color): MyAnyT := Inv(()->MyAnyT.Create(x, y, z, Length, c));
|
||
|
||
function MyH(x, y, z, Length: real; c: Material): MyAnyT := Inv(()->MyAnyT.Create(x, y, z, Length, c));
|
||
|
||
function Any(x, y, z: real; c: Color): AnyT := Inv(()->AnyT.Create(x, y, z, c));
|
||
|
||
// Сервисные функции и классы
|
||
|
||
type
|
||
Graph3DWindow = class(GMainWindow)
|
||
public
|
||
procedure InitMainGraphControl; override;
|
||
begin
|
||
var g := Content as DockPanel;
|
||
hvp := new HelixViewport3D();
|
||
g.Children.Add(hvp);
|
||
|
||
hvp.ZoomExtentsWhenLoaded := True;
|
||
hvp.ShowCoordinateSystem := True;
|
||
|
||
hvp.Children.Add(new DefaultLights);
|
||
|
||
var mv := new ModelVisual3D;
|
||
LightsGroup := new Model3DGroup;
|
||
mv.Content := LightsGroup;
|
||
hvp.Children.Add(mv);
|
||
|
||
gvl := new GridLinesVisual3D();
|
||
gvl.Width := 12;
|
||
gvl.Length := 12;
|
||
gvl.Normal := OrtZ;
|
||
gvl.MinorDistance := 1;
|
||
gvl.MajorDistance := 1;
|
||
gvl.Thickness := 0.02;
|
||
hvp.Children.Add(gvl);
|
||
end;
|
||
|
||
procedure InitWindowProperties; override;
|
||
begin
|
||
(Width, Height) := (800, 600);
|
||
Title := '3D графика';
|
||
WindowStartupLocation := System.Windows.WindowStartupLocation.CenterScreen;
|
||
end;
|
||
|
||
procedure InitGlobals; override;
|
||
begin
|
||
Window := new WindowType;
|
||
Camera := new CameraType;
|
||
Lights := new LightsType;
|
||
GridLines := new GridLinesType;
|
||
View3D := new View3DType;
|
||
|
||
NameScope.SetNameScope(Self, new NameScope());
|
||
end;
|
||
|
||
/// --- SystemKeyEvents
|
||
procedure SystemOnKeyDown(sender: Object; e: System.Windows.Input.KeyEventArgs);
|
||
begin
|
||
if Graph3D.OnKeyDown <> nil then
|
||
Graph3D.OnKeyDown(e.Key);
|
||
e.Handled := True;
|
||
end;
|
||
|
||
procedure SystemOnKeyUp(sender: Object; e: System.Windows.Input.KeyEventArgs) :=
|
||
begin
|
||
if Graph3D.OnKeyUp <> nil then
|
||
Graph3D.OnKeyUp(e.Key);
|
||
e.Handled := True;
|
||
end;
|
||
|
||
/// --- SystemMouseEvents
|
||
procedure SystemOnMouseDown(sender: Object; e: System.Windows.Input.MouseButtonEventArgs);
|
||
begin
|
||
var mb := 0;
|
||
var p := e.GetPosition(hvp);
|
||
if e.LeftButton = MouseButtonState.Pressed then
|
||
mb := 1
|
||
else if e.RightButton = MouseButtonState.Pressed then
|
||
mb := 2;
|
||
if Graph3D.OnMouseDown <> nil then
|
||
Graph3D.OnMouseDown(p.x, p.y, mb);
|
||
end;
|
||
|
||
procedure SystemOnMouseUp(sender: Object; e: MouseButtonEventArgs);
|
||
begin
|
||
var mb := 0;
|
||
var p := e.GetPosition(hvp);
|
||
if e.LeftButton = MouseButtonState.Pressed then
|
||
mb := 1
|
||
else if e.RightButton = MouseButtonState.Pressed then
|
||
mb := 2;
|
||
if Graph3D.OnMouseUp <> nil then
|
||
Graph3D.OnMouseUp(p.x, p.y, mb);
|
||
end;
|
||
|
||
procedure SystemOnMouseMove(sender: Object; e: MouseEventArgs);
|
||
begin
|
||
var mb := 0;
|
||
var p := e.GetPosition(hvp);
|
||
if e.LeftButton = MouseButtonState.Pressed then
|
||
mb := 1
|
||
else if e.RightButton = MouseButtonState.Pressed then
|
||
mb := 2;
|
||
if Graph3D.OnMouseMove <> nil then
|
||
Graph3D.OnMouseMove(p.x, p.y, mb);
|
||
end;
|
||
|
||
procedure InitHandlers; override;
|
||
begin
|
||
hvp.PreviewMouseDown += (o, e) -> SystemOnMouseDown(o, e);
|
||
hvp.PreviewMouseUp += (o, e) -> SystemOnMouseUp(o, e);
|
||
hvp.PreviewMouseMove += (o, e) -> SystemOnMouseMove(o, e);
|
||
|
||
hvp.PreviewKeyDown += (o, e)-> SystemOnKeyDown(o, e);
|
||
hvp.PreviewKeyUp += (o, e)-> SystemOnKeyUp(o, e);
|
||
|
||
hvp.Focus();
|
||
Closed += procedure(sender, e) -> begin Halt; end;
|
||
end;
|
||
end;
|
||
|
||
var
|
||
mre := new ManualResetEvent(false);
|
||
|
||
procedure InitApp;
|
||
begin
|
||
app := new Application;
|
||
|
||
app.Dispatcher.UnhandledException += (o, e) -> begin
|
||
Println(e.Exception.Message);
|
||
if e.Exception.InnerException <> nil then
|
||
Println(e.Exception.InnerException.Message);
|
||
halt;
|
||
end;
|
||
|
||
MainWindow := new Graph3DWindow;
|
||
//MainWindow.MainPanel;
|
||
|
||
mre.Set();
|
||
|
||
app.Run(MainWindow);
|
||
end;
|
||
|
||
procedure InitMainThread;
|
||
begin
|
||
var MainFormThread := new System.Threading.Thread(InitApp);
|
||
MainFormThread.SetApartmentState(ApartmentState.STA);
|
||
MainFormThread.Start;
|
||
|
||
mre.WaitOne; // Основная программа не начнется пока не будут инициализированы все компоненты приложения
|
||
end;
|
||
|
||
var
|
||
///--
|
||
__initialized := false;
|
||
|
||
var
|
||
///--
|
||
__finalized := false;
|
||
|
||
procedure __InitModule;
|
||
begin
|
||
InitMainThread;
|
||
end;
|
||
|
||
///--
|
||
procedure __InitModule__;
|
||
begin
|
||
if not __initialized then
|
||
begin
|
||
__initialized := true;
|
||
__InitModule;
|
||
end;
|
||
end;
|
||
|
||
///--
|
||
procedure __FinalizeModule__;
|
||
begin
|
||
if not __finalized then
|
||
begin
|
||
__finalized := true;
|
||
end;
|
||
end;
|
||
|
||
initialization
|
||
__InitModule;
|
||
|
||
finalization
|
||
end. |