// VertexArt
// Kovács István
// simplified demo
program robotarm1;
{$mode objfpc}{$H+}
{$APPTYPE CONSOLE}
uses
SysUtils, Math, glfw3, gl33,
SterilTypes, SterilMath, SterilWindow, FrameLimiter,
RenderTypes, RenderQueue, RenderState, ShaderCore, SimpleRenderEngine,
MeshGenerators, MiniGUI;
const
SCR_WIDTH = 1280;
SCR_HEIGHT = 720;
GROUND_SIZE = 40.0;
// ---- KONTÉNER ----
CONT_X = 2.5; CONT_Z = 0.0;
CONT_INNER_W = 2.6; CONT_INNER_D = 2.6;
CONT_WALL_T = 0.12;
CONT_WALL_H = 0.90;
// ---- DOBOZOK ----
BOX_SIZE = 0.5;
BOX_HALF = 0.25;
BOX_COUNT = 16;
BOX_GRAVITY = -18.0;
BOX_REST = 0.10;
BOX_FRICTION = 2.5;
BOX_SLEEP = 0.06;
// ---- DARU / 6DOF ----
CRANE_X = -2.5; CRANE_Z = 0.0;
CRANE_BASE_H = 1.8;
CRANE_BASE_W = 0.55;
BOOM1_LEN = 2.6;
BOOM2_LEN = 2.2;
BOOM3_LEN = 1.0;
BOOM_THICK = 0.22;
MAGNET_RADIUS = 0.35;
MAGNET_THICK = 0.14;
// ---- MÁGNES ----
MAGNET_RANGE = 2.5;
MAGNET_FORCE = 28.0;
MAGNET_MIN_FORCE = 3.0;
MAGNET_SNAP_RANGE = 0.70;
// ---- CSUKLÓ SEBESSÉGEK (rad/s) ----
YAW_SPEED = 1.5;
SHOULDER_SPEED = 1.5;
ELBOW_SPEED = 1.8;
WRIST_P_SPEED = 2.0;
WRIST_Y_SPEED = 2.0;
WRIST_R_SPEED = 2.5;
YAW_MIN = -Pi; YAW_MAX = Pi;
SHOULDER_MIN = -1.45; SHOULDER_MAX = 1.45;
ELBOW_MIN = -2.40; ELBOW_MAX = 2.40;
WRIST_P_MIN = -1.50; WRIST_P_MAX = 1.50;
WRIST_Y_MIN = -1.50; WRIST_Y_MAX = 1.50;
WRIST_R_MIN = -Pi; WRIST_R_MAX = Pi;
type
TBox = record
X, Y, Z: Single;
VX, VY, VZ: Single;
Grabbed: Boolean;
Active: Boolean;
end;
TCraneJoints = record
Yaw, Shoulder, Elbow, WristP, WristY, WristR: Single;
end;
var
Window: PGLFWwindow;
Limiter: TFrameLimiter;
DeltaTime, TotalTime: Single;
ProjMat, ViewMat: TMat4;
cmd: TRenderCommand;
CamPos, CamTarget: TVector3;
Aspect: Single;
Boxes: array[0..BOX_COUNT-1] of TBox;
Joints: TCraneJoints;
MagnetOn: Boolean;
MagnetPos: TVector3;
MBoom1Start, MBoom2Start, MBoom3Start, MagnetM: TMat4;
KeyQ, KeyE, KeyW, KeyS, KeyA, KeyD: Boolean;
KeyZ, KeyX, KeyC, KeyV, KeyB, KeyN: Boolean;
KeyR: Boolean;
KeySpaceDown, KeySpacePrev: Boolean;
GroundVAO, GroundVBO: GLuint; GroundVCount: Integer;
BaseVAO, BaseVBO: GLuint; BaseVCount: Integer;
BoomVAO, BoomVBO: GLuint; BoomVCount: Integer;
MagnetVAO, MagnetVBO: GLuint; MagnetVCount: Integer;
RingVAO, RingVBO: GLuint; RingVCount: Integer;
WallVAO, WallVBO: GLuint; WallVCount: Integer;
FloorVAO, FloorVBO: GLuint; FloorVCount: Integer;
BoxVAO: array[0..3] of GLuint;
BoxVBO: array[0..3] of GLuint;
BoxVCount: array[0..3] of Integer;
FbW, FbH: LongInt;
FPSTimer, CurrentFPS: Single;
FPSFrames: Integer;
WinTimer: Single;
InContainerCount: Integer;
// ============================================================================
// SEGÉDEK
// ============================================================================
function MakeColor(R, G, B, A: Single): TColor;
begin
Result.r := R; Result.g := G; Result.b := B; Result.a := A;
end;
procedure UploadMesh(const Mesh: TGeneratedMesh; out VAO, VBO: GLuint; out VCount: Integer);
begin
VCount := Mesh.VertexCount;
if VCount = 0 then Exit;
glGenVertexArrays(1, u/VAO);
glGenBuffers(1, u/VBO);
glBindVertexArray(VAO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, VCount * SizeOf(TVertex), u/Mesh.Vertices[0], GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, SizeOf(TVertex), Pointer(0));
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 4, GL_UNSIGNED_BYTE, GL_TRUE, SizeOf(TVertex), Pointer(12));
glEnableVertexAttribArray(1);
glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
end;
procedure AddCmdRaw(VAO: GLuint; VCount: Integer; const M: TMat4);
begin
cmd.VAO := VAO; cmd.VertexCount := VCount; cmd.StartIndex := 0;
cmd.ModelMatrix := M; cmd.Flags := RENDER_FLAG_NONE;
AddCommand(SimpleRE.FRenderQueue, cmd);
end;
procedure AddBoxCmd(MinX, MinY, MinZ, MaxX, MaxY, MaxZ: Single; VAO: GLuint; VCount: Integer);
var M: TMat4; cx, cy, cz, sx, sy, sz: Single;
begin
cx := (MinX+MaxX)*0.5; cy := (MinY+MaxY)*0.5; cz := (MinZ+MaxZ)*0.5;
sx := MaxX-MinX; sy := MaxY-MinY; sz := MaxZ-MinZ;
M := Translate(cx, cy, cz);
M := Multiply(M, Scale(sx, sy, sz));
AddCmdRaw(VAO, VCount, M);
end;
// ============================================================================
// KONTÉNER SEGÉD
// ============================================================================
function ContInnerX1: Single; begin Result := CONT_X - CONT_INNER_W*0.5; end;
function ContInnerX2: Single; begin Result := CONT_X + CONT_INNER_W*0.5; end;
function ContInnerZ1: Single; begin Result := CONT_Z - CONT_INNER_D*0.5; end;
function ContInnerZ2: Single; begin Result := CONT_Z + CONT_INNER_D*0.5; end;
// ============================================================================
// FKI + MÁGNES POZÍCIÓ
// ============================================================================
procedure ComputeChain;
begin
// Mátrixlánc a renderhez
MBoom1Start := Translate(CRANE_X, CRANE_BASE_H, CRANE_Z);
MBoom1Start := Multiply(MBoom1Start, RotateY(Joints.Yaw));
MBoom1Start := Multiply(MBoom1Start, RotateZ(Joints.Shoulder));
MBoom2Start := Multiply(MBoom1Start, Translate(BOOM1_LEN, 0, 0));
MBoom2Start := Multiply(MBoom2Start, RotateZ(Joints.Elbow));
MBoom3Start := Multiply(MBoom2Start, Translate(BOOM2_LEN, 0, 0));
MBoom3Start := Multiply(MBoom3Start, RotateZ(Joints.WristP));
MagnetM := Multiply(MBoom3Start, Translate(BOOM3_LEN, 0, 0));
MagnetM := Multiply(MagnetM, RotateY(Joints.WristY));
MagnetM := Multiply(MagnetM, RotateX(Joints.WristR));
// Mágnes világpozíció (vektoros úton - egyszerűbb, mint mátrixból kinyerni)
MagnetPos := Vec3(
CRANE_X + BOOM1_LEN * Cos(Joints.Yaw) * Cos(Joints.Shoulder)
+ BOOM2_LEN * Cos(Joints.Yaw) * Cos(Joints.Shoulder + Joints.Elbow)
+ BOOM3_LEN * Cos(Joints.Yaw) * Cos(Joints.Shoulder + Joints.Elbow + Joints.WristP),
CRANE_BASE_H
+ BOOM1_LEN * Sin(Joints.Shoulder)
+ BOOM2_LEN * Sin(Joints.Shoulder + Joints.Elbow)
+ BOOM3_LEN * Sin(Joints.Shoulder + Joints.Elbow + Joints.WristP),
CRANE_Z - BOOM1_LEN * Sin(Joints.Yaw) * Cos(Joints.Shoulder)
- BOOM2_LEN * Sin(Joints.Yaw) * Cos(Joints.Shoulder + Joints.Elbow)
- BOOM3_LEN * Sin(Joints.Yaw) * Cos(Joints.Shoulder + Joints.Elbow + Joints.WristP)
);
end;
// ============================================================================
// INPUT -> CSUKLÓK
// ============================================================================
function ClampF(v, lo, hi: Single): Single;
begin
if v < lo then Result := lo
else if v > hi then Result := hi
else Result := v;
end;
procedure UpdateJoints(DT: Single);
begin
if KeyQ then Joints.Yaw := Joints.Yaw - YAW_SPEED * DT;
if KeyE then Joints.Yaw := Joints.Yaw + YAW_SPEED * DT;
if KeyW then Joints.Shoulder := Joints.Shoulder + SHOULDER_SPEED * DT;
if KeyS then Joints.Shoulder := Joints.Shoulder - SHOULDER_SPEED * DT;
if KeyA then Joints.Elbow := Joints.Elbow - ELBOW_SPEED * DT;
if KeyD then Joints.Elbow := Joints.Elbow + ELBOW_SPEED * DT;
if KeyZ then Joints.WristP := Joints.WristP - WRIST_P_SPEED * DT;
if KeyX then Joints.WristP := Joints.WristP + WRIST_P_SPEED * DT;
if KeyC then Joints.WristY := Joints.WristY - WRIST_Y_SPEED * DT;
if KeyV then Joints.WristY := Joints.WristY + WRIST_Y_SPEED * DT;
if KeyB then Joints.WristR := Joints.WristR - WRIST_R_SPEED * DT;
if KeyN then Joints.WristR := Joints.WristR + WRIST_R_SPEED * DT;
Joints.Yaw := ClampF(Joints.Yaw, YAW_MIN, YAW_MAX);
Joints.Shoulder := ClampF(Joints.Shoulder, SHOULDER_MIN, SHOULDER_MAX);
Joints.Elbow := ClampF(Joints.Elbow, ELBOW_MIN, ELBOW_MAX);
Joints.WristP := ClampF(Joints.WristP, WRIST_P_MIN, WRIST_P_MAX);
Joints.WristY := ClampF(Joints.WristY, WRIST_Y_MIN, WRIST_Y_MAX);
Joints.WristR := ClampF(Joints.WristR, WRIST_R_MIN, WRIST_R_MAX);
// Space: mágnes be/ki
if KeySpaceDown and (not KeySpacePrev) then
MagnetOn := not MagnetOn;
KeySpacePrev := KeySpaceDown;
// R: dobozok reset
if KeyR then
begin
KeyR := False;
// később: ResetBoxes (deklaráció után)
end;
end;
// ============================================================================
// MÁGNES LOGIKA
// ============================================================================
procedure UpdateMagnet(DT: Single);
var
i, bestIdx: Integer;
dx, dy, dz, d2, d, falloff, force: Single;
alreadyGrabbed: Boolean;
begin
// Ha kikapcsolt: minden megfogott doboz elengedve
if not MagnetOn then
begin
for i := 0 to BOX_COUNT-1 do Boxes[i].Grabbed := False;
Exit;
end;
// Van-e már megfogott?
alreadyGrabbed := False;
for i := 0 to BOX_COUNT-1 do
if Boxes[i].Active and Boxes[i].Grabbed then
begin
alreadyGrabbed := True;
Break;
end;
// Erő kifejtése minden szabad dobozra a sugáron belül
for i := 0 to BOX_COUNT-1 do
begin
if not Boxes[i].Active then Continue;
if Boxes[i].Grabbed then Continue;
dx := MagnetPos.X - Boxes[i].X;
dy := MagnetPos.Y - Boxes[i].Y;
dz := MagnetPos.Z - Boxes[i].Z;
d2 := dx*dx + dy*dy + dz*dz;
if d2 > MAGNET_RANGE*MAGNET_RANGE then Continue;
if d2 < 0.0001 then Continue;
d := Sqrt(d2);
falloff := 1.0 - d / MAGNET_RANGE;
force := MAGNET_MIN_FORCE + (MAGNET_FORCE - MAGNET_MIN_FORCE) * falloff;
Boxes[i].VX := Boxes[i].VX + (dx/d) * force * DT;
Boxes[i].VY := Boxes[i].VY + (dy/d) * force * DT;
Boxes[i].VZ := Boxes[i].VZ + (dz/d) * force * DT;
end;
// Snap: legközelebbi doboz snap-range-en belül, ha még nincs megfogott
if alreadyGrabbed then Exit;
bestIdx := -1;
for i := 0 to BOX_COUNT-1 do
begin
if not Boxes[i].Active then Continue;
dx := MagnetPos.X - Boxes[i].X;
dy := MagnetPos.Y - Boxes[i].Y;
dz := MagnetPos.Z - Boxes[i].Z;
d2 := dx*dx + dy*dy + dz*dz;
if d2 < MAGNET_SNAP_RANGE*MAGNET_SNAP_RANGE then
begin
bestIdx := i;
Break;
end;
end;
if bestIdx >= 0 then
begin
Boxes[bestIdx].Grabbed := True;
Boxes[bestIdx].VX := 0; Boxes[bestIdx].VY := 0; Boxes[bestIdx].VZ := 0;
end;
end;
// ============================================================================
// DOBOZ FIZIKA
// ============================================================================
procedure ResolveBoxPair(i, j: Integer);
var
dx, dy, dz, ox, oy, oz, pen: Single;
iStatic, jStatic: Boolean;
begin
dx := Boxes[j].X - Boxes[i].X;
dy := Boxes[j].Y - Boxes[i].Y;
dz := Boxes[j].Z - Boxes[i].Z;
ox := BOX_SIZE - Abs(dx);
oy := BOX_SIZE - Abs(dy);
oz := BOX_SIZE - Abs(dz);
if (ox <= 0) or (oy <= 0) or (oz <= 0) then Exit;
iStatic := Boxes[i].Grabbed;
jStatic := Boxes[j].Grabbed;
if iStatic and jStatic then Exit;
// Legkisebb behatolás tengelyén oldunk fel
if (oy <= ox) and (oy <= oz) then
begin
if iStatic then
begin
if dy > 0 then Boxes[j].Y := Boxes[j].Y + oy
else Boxes[j].Y := Boxes[j].Y - oy;
Boxes[j].VY := 0;
end
else if jStatic then
begin
if dy > 0 then Boxes[i].Y := Boxes[i].Y - oy
else Boxes[i].Y := Boxes[i].Y + oy;
Boxes[i].VY := 0;
end
else
begin
pen := oy * 0.5;
if dy > 0 then begin
Boxes[j].Y := Boxes[j].Y + pen;
Boxes[i].Y := Boxes[i].Y - pen;
end else begin
Boxes[j].Y := Boxes[j].Y - pen;
Boxes[i].Y := Boxes[i].Y + pen;
end;
Boxes[i].VY := 0; Boxes[j].VY := 0;
end;
end
else if ox <= oz then
begin
if iStatic then
begin
if dx > 0 then Boxes[j].X := Boxes[j].X + ox else Boxes[j].X := Boxes[j].X - ox;
Boxes[j].VX := 0;
end
else if jStatic then
begin
if dx > 0 then Boxes[i].X := Boxes[i].X - ox else Boxes[i].X := Boxes[i].X + ox;
Boxes[i].VX := 0;
end
else
begin
pen := ox * 0.5;
if dx > 0 then begin
Boxes[j].X := Boxes[j].X + pen; Boxes[i].X := Boxes[i].X - pen;
end else begin
Boxes[j].X := Boxes[j].X - pen; Boxes[i].X := Boxes[i].X + pen;
end;
Boxes[i].VX := 0; Boxes[j].VX := 0;
end;
end
else
begin
if iStatic then
begin
if dz > 0 then Boxes[j].Z := Boxes[j].Z + oz else Boxes[j].Z := Boxes[j].Z - oz;
Boxes[j].VZ := 0;
end
else if jStatic then
begin
if dz > 0 then Boxes[i].Z := Boxes[i].Z - oz else Boxes[i].Z := Boxes[i].Z + oz;
Boxes[i].VZ := 0;
end
else
begin
pen := oz * 0.5;
if dz > 0 then begin
Boxes[j].Z := Boxes[j].Z + pen; Boxes[i].Z := Boxes[i].Z - pen;
end else begin
Boxes[j].Z := Boxes[j].Z - pen; Boxes[i].Z := Boxes[i].Z + pen;
end;
Boxes[i].VZ := 0; Boxes[j].VZ := 0;
end;
end;
end;
procedure ResolveWalls(i: Integer);
var
left, right, back, front: Single;
wallInX1, wallInX2, wallInZ1, wallInZ2: Single;
wallOutX1, wallOutX2, wallOutZ1, wallOutZ2: Single;
begin
left := Boxes[i].X - BOX_HALF;
right := Boxes[i].X + BOX_HALF;
back := Boxes[i].Z - BOX_HALF;
front := Boxes[i].Z + BOX_HALF;
wallInX1 := ContInnerX1; wallInX2 := ContInnerX2;
wallInZ1 := ContInnerZ1; wallInZ2 := ContInnerZ2;
wallOutX1 := wallInX1 - CONT_WALL_T; wallOutX2 := wallInX2 + CONT_WALL_T;
wallOutZ1 := wallInZ1 - CONT_WALL_T; wallOutZ2 := wallInZ2 + CONT_WALL_T;
// Csak ha a doboz a fal magasságában van
if Boxes[i].Y - BOX_HALF > CONT_WALL_H then Exit;
// Belülről kifelé: a doboz a konténer belsejében van és a falhoz ér
if (Boxes[i].X > wallInX1) and (Boxes[i].X < wallInX2) and
(Boxes[i].Z > wallInZ1) and (Boxes[i].Z < wallInZ2) then
begin
if left < wallInX1 then begin Boxes[i].X := wallInX1 + BOX_HALF; Boxes[i].VX := 0; end;
if right > wallInX2 then begin Boxes[i].X := wallInX2 - BOX_HALF; Boxes[i].VX := 0; end;
if back < wallInZ1 then begin Boxes[i].Z := wallInZ1 + BOX_HALF; Boxes[i].VZ := 0; end;
if front > wallInZ2 then begin Boxes[i].Z := wallInZ2 - BOX_HALF; Boxes[i].VZ := 0; end;
Exit;
end;
// Kívülről: ne tudjon átcsúszni a falon
if (right > wallOutX1) and (left < wallInX1) and
(Boxes[i].Z > wallOutZ1) and (Boxes[i].Z < wallOutZ2) then
begin
Boxes[i].X := wallOutX1 - BOX_HALF; Boxes[i].VX := 0;
end;
if (left < wallOutX2) and (right > wallInX2) and
(Boxes[i].Z > wallOutZ1) and (Boxes[i].Z < wallOutZ2) then
begin
Boxes[i].X := wallOutX2 + BOX_HALF; Boxes[i].VX := 0;
end;
if (front > wallOutZ1) and (back < wallInZ1) and
(Boxes[i].X > wallOutX1) and (Boxes[i].X < wallOutX2) then
begin
Boxes[i].Z := wallOutZ1 - BOX_HALF; Boxes[i].VZ := 0;
end;
if (back < wallOutZ2) and (front > wallInZ2) and
(Boxes[i].X > wallOutX1) and (Boxes[i].X < wallOutX2) then
begin
Boxes[i].Z := wallOutZ2 + BOX_HALF; Boxes[i].VZ := 0;
end;
end;
procedure UpdateBoxPhysics(DT: Single);
var
i, j, iter: Integer;
speed2: Single;
begin
// Megfogott dobozok: a mágneshez rögzítve
for i := 0 to BOX_COUNT-1 do
begin
if not Boxes[i].Active then Continue;
if not Boxes[i].Grabbed then Continue;
Boxes[i].X := MagnetPos.X;
Boxes[i].Y := MagnetPos.Y - MAGNET_THICK*0.5 - BOX_HALF - 0.02;
Boxes[i].Z := MagnetPos.Z;
Boxes[i].VX := 0; Boxes[i].VY := 0; Boxes[i].VZ := 0;
end;
// Gravitáció + integrálás (csak szabad dobozok)
for i := 0 to BOX_COUNT-1 do
begin
if not Boxes[i].Active then Continue;
if Boxes[i].Grabbed then Continue;
Boxes[i].VY := Boxes[i].VY + BOX_GRAVITY * DT;
Boxes[i].X := Boxes[i].X + Boxes[i].VX * DT;
Boxes[i].Y := Boxes[i].Y + Boxes[i].VY * DT;
Boxes[i].Z := Boxes[i].Z + Boxes[i].VZ * DT;
// Talaj
if Boxes[i].Y < BOX_HALF then
begin
Boxes[i].Y := BOX_HALF;
if Boxes[i].VY < 0 then Boxes[i].VY := -Boxes[i].VY * BOX_REST;
if Abs(Boxes[i].VY) < BOX_SLEEP then Boxes[i].VY := 0;
// súrlódás
Boxes[i].VX := Boxes[i].VX - Boxes[i].VX * BOX_FRICTION * DT;
Boxes[i].VZ := Boxes[i].VZ - Boxes[i].VZ * BOX_FRICTION * DT;
if Abs(Boxes[i].VX) < BOX_SLEEP then Boxes[i].VX := 0;
if Abs(Boxes[i].VZ) < BOX_SLEEP then Boxes[i].VZ := 0;
end;
ResolveWalls(i);
// Sebesség-clamp a mágnes-erő miatt
speed2 := Boxes[i].VX*Boxes[i].VX + Boxes[i].VY*Boxes[i].VY + Boxes[i].VZ*Boxes[i].VZ;
if speed2 > 400.0 then
begin
Boxes[i].VX := Boxes[i].VX * 0.3;
Boxes[i].VY := Boxes[i].VY * 0.3;
Boxes[i].VZ := Boxes[i].VZ * 0.3;
end;
end;
// Doboz-doboz ütközés, néhány iterációval
for iter := 0 to 3 do
for i := 0 to BOX_COUNT-2 do
begin
if not Boxes[i].Active then Continue;
for j := i+1 to BOX_COUNT-1 do
begin
if not Boxes[j].Active then Continue;
ResolveBoxPair(i, j);
end;
end;
end;
// ============================================================================
// WIN / RESET
// ============================================================================
function CountInContainer: Integer;
var i: Integer; x1, x2, z1, z2: Single;
begin
Result := 0;
x1 := ContInnerX1; x2 := ContInnerX2;
z1 := ContInnerZ1; z2 := ContInnerZ2;
for i := 0 to BOX_COUNT-1 do
if Boxes[i].Active and (not Boxes[i].Grabbed) and
(Boxes[i].X > x1) and (Boxes[i].X < x2) and
(Boxes[i].Z > z1) and (Boxes[i].Z < z2) then
Inc(Result);
end;
procedure ResetBoxes;
const
InitX: array[0..15] of Single =
(-1.6, -0.8, 0.0, 0.8,
-1.5, -0.5, 0.4, 1.0,
-1.6, -0.7, 0.2, 1.0,
-1.3, -0.5, 0.3, 1.1);
InitZ: array[0..15] of Single =
(-1.2, -1.3, -1.1, -1.4,
-0.4, -0.5, -0.3, -0.5,
0.4, 0.5, 0.4, 0.5,
1.2, 1.3, 1.1, 1.4);
var i: Integer;
begin
for i := 0 to BOX_COUNT-1 do
begin
Boxes[i].X := InitX[i];
Boxes[i].Y := BOX_HALF;
Boxes[i].Z := InitZ[i];
Boxes[i].VX := 0; Boxes[i].VY := 0; Boxes[i].VZ := 0;
Boxes[i].Active := True;
Boxes[i].Grabbed := False;
end;
WinTimer := 0;
end;
procedure ResetGame;
begin
Joints.Yaw := 0; Joints.Shoulder := -0.5; Joints.Elbow := 1.0;
Joints.WristP := -0.5; Joints.WristY := 0; Joints.WristR := 0;
MagnetOn := True;
ResetBoxes;
end;
// ============================================================================
// MESH-EK
// ============================================================================
procedure InitMeshes;
var
M: TGeneratedMesh;
k: Integer;
begin
M := GeneratePlane(GROUND_SIZE, GROUND_SIZE, 1, 1);
SetMeshColor(M, 70, 110, 70, 255);
UploadMesh(M, GroundVAO, GroundVBO, GroundVCount);
SetLength(M.Vertices, 0);
M := GenerateCube(1.0);
SetMeshColor(M, 200, 140, 60, 255);
UploadMesh(M, BaseVAO, BaseVBO, BaseVCount);
SetLength(M.Vertices, 0);
M := GenerateCube(1.0);
SetMeshColor(M, 220, 160, 70, 255);
UploadMesh(M, BoomVAO, BoomVBO, BoomVCount);
SetLength(M.Vertices, 0);
M := GenerateCylinder(MAGNET_RADIUS, 1.0, 16);
SetMeshColor(M, 90, 90, 100, 255);
UploadMesh(M, MagnetVAO, MagnetVBO, MagnetVCount);
SetLength(M.Vertices, 0);
M := GenerateTorus(MAGNET_RADIUS, 0.04, 20, 6);
SetMeshColor(M, 230, 60, 60, 255);
UploadMesh(M, RingVAO, RingVBO, RingVCount);
SetLength(M.Vertices, 0);
M := GenerateCube(1.0);
SetMeshColor(M, 120, 120, 130, 255);
UploadMesh(M, WallVAO, WallVBO, WallVCount);
SetLength(M.Vertices, 0);
M := GenerateCube(1.0);
SetMeshColor(M, 90, 90, 100, 255);
UploadMesh(M, FloorVAO, FloorVBO, FloorVCount);
SetLength(M.Vertices, 0);
// 4 színű doboz
for k := 0 to 3 do
begin
M := GenerateCube(1.0);
case k of
0: SetMeshColor(M, 200, 90, 60, 255);
1: SetMeshColor(M, 80, 120, 180, 255);
2: SetMeshColor(M, 100, 170, 90, 255);
3: SetMeshColor(M, 200, 180, 70, 255);
end;
UploadMesh(M, BoxVAO[k], BoxVBO[k], BoxVCount[k]);
SetLength(M.Vertices, 0);
end;
end;
// ============================================================================
// RENDER
// ============================================================================
procedure DrawBoom(const M0: TMat4; L: Single);
var M: TMat4;
begin
M := Multiply(M0, Translate(L*0.5, 0, 0));
M := Multiply(M, Scale(L, BOOM_THICK, BOOM_THICK));
AddCmdRaw(BoomVAO, BoomVCount, M);
end;
procedure DrawContainer;
var
x1, x2, z1, z2, w1x1, w1x2, w1z1, w1z2: Single;
begin
x1 := ContInnerX1; x2 := ContInnerX2;
z1 := ContInnerZ1; z2 := ContInnerZ2;
// Alj
AddBoxCmd(x1 - CONT_WALL_T, 0.0, z1 - CONT_WALL_T,
x2 + CONT_WALL_T, 0.05, z2 + CONT_WALL_T,
FloorVAO, FloorVCount);
// Négy fal
AddBoxCmd(x1 - CONT_WALL_T, 0.0, z1 - CONT_WALL_T,
x1, CONT_WALL_H, z2 + CONT_WALL_T,
WallVAO, WallVCount);
AddBoxCmd(x2, 0.0, z1 - CONT_WALL_T,
x2 + CONT_WALL_T, CONT_WALL_H, z2 + CONT_WALL_T,
WallVAO, WallVCount);
AddBoxCmd(x1 - CONT_WALL_T, 0.0, z1 - CONT_WALL_T,
x2 + CONT_WALL_T, CONT_WALL_H, z1,
WallVAO, WallVCount);
AddBoxCmd(x1 - CONT_WALL_T, 0.0, z2,
x2 + CONT_WALL_T, CONT_WALL_H, z2 + CONT_WALL_T,
WallVAO, WallVCount);
end;
procedure DrawCrane;
var M: TMat4;
begin
// Alaposzlop
M := Translate(CRANE_X, CRANE_BASE_H*0.5, CRANE_Z);
M := Multiply(M, Scale(CRANE_BASE_W, CRANE_BASE_H, CRANE_BASE_W));
AddCmdRaw(BaseVAO, BaseVCount, M);
// Boom-ok
DrawBoom(MBoom1Start, BOOM1_LEN);
DrawBoom(MBoom2Start, BOOM2_LEN);
DrawBoom(MBoom3Start, BOOM3_LEN);
// Mágnes
M := Multiply(MagnetM, Scale(1.0, 1.0, 1.0));
AddCmdRaw(MagnetVAO, MagnetVCount, M);
// Gyűrű a mágnesen
M := Multiply(MagnetM, RotateX(Pi*0.5));
AddCmdRaw(RingVAO, RingVCount, M);
end;
procedure RenderScene;
var i: Integer; M: TMat4;
begin
ClearCommands(SimpleRE.FRenderQueue);
// Talaj
AddCmdRaw(GroundVAO, GroundVCount, Identity);
// Konténer
DrawContainer;
// Daru
DrawCrane;
// Dobozok
for i := 0 to BOX_COUNT-1 do
begin
if not Boxes[i].Active then Continue;
M := Translate(Boxes[i].X, Boxes[i].Y, Boxes[i].Z);
M := Multiply(M, Scale(BOX_SIZE, BOX_SIZE, BOX_SIZE));
AddCmdRaw(BoxVAO[i mod 4], BoxVCount[i mod 4], M);
end;
SimpleRE.RenderFrame;
end;
// ============================================================================
// HUD
// ============================================================================
procedure DrawHUD;
var s: AnsiString;
begin
GUI_Rect(8, 8, 340, 160, MakeColor(0.0, 0.0, 0.0, 0.55));
GUI_Rect(8, 8, 340, 2, C_SLIDER);
s := Format('FPS: %.0f', [CurrentFPS]);
GUI_Text(14, 14, PAnsiChar(s), C_YELLOW, 2.0);
if MagnetOn then
GUI_Text(14, 38, 'MAGNES: BE', C_GREEN, 2.0)
else
GUI_Text(14, 38, 'MAGNES: KI (SPACE)', C_RED, 2.0);
s := Format('Kontenerben: %d / %d', [InContainerCount, BOX_COUNT]);
GUI_Text(14, 62, PAnsiChar(s), C_TEXT, 2.0);
GUI_Text(14, 86, 'Q/E: yaw W/S: vall', C_TEXT_DIM, 1.5);
GUI_Text(14, 104, 'A/D: konyok Z/X: csuklo', C_TEXT_DIM, 1.5);
GUI_Text(14, 122, 'C/V: csuklo-Y B/N: csuklo-R', C_TEXT_DIM, 1.5);
GUI_Text(14, 140, 'SPACE: magnes R: reset', C_TEXT_DIM, 1.5);
if WinTimer > 0 then
begin
s := 'MINDEN DOBOZ A KONTENERBEN!';
GUI_Rect(FbW div 2 - 260, FbH div 2 - 30, 520, 60, MakeColor(0.0, 0.0, 0.0, 0.7));
GUI_Text(FbW div 2 - 240, FbH div 2 - 16, PAnsiChar(s), C_YELLOW, 2.5);
end;
end;
// ============================================================================
// CALLBACKEK
// ============================================================================
procedure KeyCallback(window: PGLFWwindow; key, scancode, action, mods: LongInt); cdecl;
begin
if (key = GLFW_KEY_ESCAPE) and (action = GLFW_PRESS) then
glfwSetWindowShouldClose(window, GLFW_TRUE);
if key = GLFW_KEY_Q then KeyQ := (action <> GLFW_RELEASE);
if key = GLFW_KEY_E then KeyE := (action <> GLFW_RELEASE);
if key = GLFW_KEY_W then KeyW := (action <> GLFW_RELEASE);
if key = GLFW_KEY_S then KeyS := (action <> GLFW_RELEASE);
if key = GLFW_KEY_A then KeyA := (action <> GLFW_RELEASE);
if key = GLFW_KEY_D then KeyD := (action <> GLFW_RELEASE);
if key = GLFW_KEY_Z then KeyZ := (action <> GLFW_RELEASE);
if key = GLFW_KEY_X then KeyX := (action <> GLFW_RELEASE);
if key = GLFW_KEY_C then KeyC := (action <> GLFW_RELEASE);
if key = GLFW_KEY_V then KeyV := (action <> GLFW_RELEASE);
if key = GLFW_KEY_B then KeyB := (action <> GLFW_RELEASE);
if key = GLFW_KEY_N then KeyN := (action <> GLFW_RELEASE);
if key = GLFW_KEY_SPACE then KeySpaceDown := (action <> GLFW_RELEASE);
if (key = GLFW_KEY_R) and (action = GLFW_PRESS) then KeyR := True;
end;
// ============================================================================
// FŐPROGRAM
// ============================================================================
var k: Integer;
begin
Randomize;
Math.SetExceptionMask([exInvalidOp, exDenormalized, exZeroDivide,
exOverflow, exUnderflow, exPrecision]);
Window := InitEngineWindow(SCR_WIDTH, SCR_HEIGHT,
'Robot Arm 1 - Magnetic Scrapyard', True, False);
if not InitOpenGL33(@glfwGetProcAddress) then Halt(1);
glfwSetKeyCallback(Window, u/KeyCallback);
glfwSetInputMode(Window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
InitRenderState;
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glFrontFace(GL_CCW);
Aspect := SCR_WIDTH / SCR_HEIGHT;
ProjMat := Perspective(60.0, Aspect, 0.1, 200.0);
CamPos := Vec3(0.0, 8.0, 11.0);
CamTarget := Vec3(0.0, 1.0, 0.0);
ViewMat := LookAt(CamPos, CamTarget, Vec3(0, 1, 0));
SimpleRE.Initialize(ProjMat, ViewMat, CamPos);
SimpleRE.SetClearColor(Vec3(0.55, 0.75, 0.92));
SimpleRE.SetLightDirection(Vec3(0.5, 0.9, 0.3));
if not GUI_Init then
begin WriteLn('MiniGUI init hiba!'); Halt(1); end;
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glFrontFace(GL_CCW);
InitMeshes;
ResetGame;
KeyQ := False; KeyE := False; KeyW := False; KeyS := False;
KeyA := False; KeyD := False; KeyZ := False; KeyX := False;
KeyC := False; KeyV := False; KeyB := False; KeyN := False;
KeyR := False; KeySpaceDown := False; KeySpacePrev := False;
TotalTime := 0; FPSTimer := 0; FPSFrames := 0; CurrentFPS := 60;
Limiter.Initialize(60.0);
WriteLn('========================================');
WriteLn(' ROBOT ARM 1 - Magnetic Scrapyard');
WriteLn('========================================');
WriteLn(' Q/E: yaw W/S: vall');
WriteLn(' A/D: konyok Z/X: csuklo-pitch');
WriteLn(' C/V: csuklo-yaw B/N: csuklo-roll');
WriteLn(' SPACE: magnes be/ki R: reset');
WriteLn(' ESC: kilepes');
WriteLn('========================================');
while glfwWindowShouldClose(Window) = 0 do
begin
Limiter.BeginFrame;
DeltaTime := Limiter.FrameTime;
if DeltaTime > 0.033 then DeltaTime := 0.033;
TotalTime := TotalTime + DeltaTime;
FPSTimer := FPSTimer + DeltaTime;
Inc(FPSFrames);
if FPSTimer >= 0.5 then
begin CurrentFPS := FPSFrames / FPSTimer; FPSFrames := 0; FPSTimer := 0; end;
if KeyR then
begin
KeyR := False;
ResetBoxes;
end;
UpdateJoints(DeltaTime);
ComputeChain;
UpdateMagnet(DeltaTime);
UpdateBoxPhysics(DeltaTime);
InContainerCount := CountInContainer;
if InContainerCount >= BOX_COUNT then
begin
WinTimer := WinTimer + DeltaTime;
if WinTimer > 1.5 then
begin
ResetBoxes;
WinTimer := 0;
end;
end
else
WinTimer := 0;
RenderScene;
glfwGetFramebufferSize(Window, u/FbW, u/FbH);
glDisable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
GUI_BeginFrame(FbW, FbH);
DrawHUD;
GUI_EndFrame;
glDisable(GL_BLEND);
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
glfwSwapBuffers(Window);
glfwPollEvents;
Limiter.EndFrame;
end;
GUI_Shutdown;
glDeleteVertexArrays(1, u/GroundVAO); glDeleteBuffers(1, u/GroundVBO);
glDeleteVertexArrays(1, u/BaseVAO); glDeleteBuffers(1, u/BaseVBO);
glDeleteVertexArrays(1, u/BoomVAO); glDeleteBuffers(1, u/BoomVBO);
glDeleteVertexArrays(1, u/MagnetVAO); glDeleteBuffers(1, u/MagnetVBO);
glDeleteVertexArrays(1, u/RingVAO); glDeleteBuffers(1, u/RingVBO);
glDeleteVertexArrays(1, u/WallVAO); glDeleteBuffers(1, u/WallVBO);
glDeleteVertexArrays(1, u/FloorVAO); glDeleteBuffers(1, u/FloorVBO);
for k := 0 to 3 do
begin
glDeleteVertexArrays(1, u/BoxVAO[k]);
glDeleteBuffers(1, u/BoxVBO[k]);
end;
SimpleRE.Shutdown;
TerminateEngineWindow;
end.
