physics-qa-python/rb_kinematic_set_world_matrix.py at main · Angar0Os/physics-qa-python · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
import harfang as hg
import math


def create_physic_cube_ex(scene, size, mtx, model_ref, materials, rb_type, mass):
    node = hg.CreateObject(scene, mtx, model_ref, materials)
    node.SetName("Physic Cube")
    rb = scene.CreateRigidBody()
    rb.SetType(rb_type)
    node.SetRigidBody(rb)

    # Création d'une collision en forme de cube
    col = scene.CreateCollision()
    col.SetType(hg.CT_Cube)
    col.SetSize(size)
    col.SetMass(mass)

    # Assigner la collision au cube
    node.SetCollision(0, col)
    return node, rb


hg.AddAssetsFolder("assets_compiled")

# Initialisation des entrées et de la fenêtre
hg.InputInit()
hg.WindowSystemInit()

res_x, res_y = 1280, 720
win = hg.RenderInit("Physics Test", res_x, res_y, hg.RF_VSync | hg.RF_MSAA4X)

pipeline = hg.CreateForwardPipeline()
res = hg.PipelineResources()

# Debug physics
vtx_line_layout = hg.VertexLayoutPosFloatColorUInt8()
line_shader = hg.LoadProgramFromAssets("shaders/pos_rgb")

# Création du matériau
pbr_shader = hg.LoadPipelineProgramRefFromAssets("core/shader/pbr.hps", res, hg.GetForwardPipelineInfo())
mat_grey = hg.CreateMaterial(pbr_shader, "uBaseOpacityColor", hg.Vec4(1, 1, 1),
                             "uOcclusionRoughnessMetalnessColor", hg.Vec4(1, 0.5, 0.05))

# Création des modèles
vtx_layout = hg.VertexLayoutPosFloatNormUInt8()

# Cube
cube_size = hg.Vec3(1, 1, 1)
cube_ref = res.AddModel("cube", hg.CreateCubeModel(vtx_layout, cube_size.x, cube_size.y, cube_size.z))

# Sol
ground_size = hg.Vec3(4, 0.05, 4)
ground_ref = res.AddModel("ground", hg.CreateCubeModel(vtx_layout, ground_size.x, ground_size.y, ground_size.z))

# Configuration de la scène
scene = hg.Scene()

# Création de la caméra
cam_mat = hg.TransformationMat4(hg.Vec3(0, 1.5, -5), hg.Vec3(hg.Deg(20), 0, 0))
cam = hg.CreateCamera(scene, cam_mat, 0.01, 1000)
view_matrix = hg.InverseFast(cam_mat)
c = cam.GetCamera()
projection_matrix = hg.ComputePerspectiveProjectionMatrix(c.GetZNear(), c.GetZFar(),
                                                          hg.FovToZoomFactor(c.GetFov()),
                                                          hg.Vec2(res_x / res_y, 1))

scene.SetCurrentCamera(cam)

# Lumière
lgt = hg.CreateLinearLight(scene, hg.TransformationMat4(hg.Vec3(0, 0, 0), hg.Vec3(hg.Deg(30), hg.Deg(30), 0)),
                           hg.Color(1, 1, 1), hg.Color(1, 1, 1), 10, hg.LST_Map, 0.0001,
                           hg.Vec4(2, 4, 10, 16))

# Création d'un cube physique
cube_node, _ = create_physic_cube_ex(scene, cube_size, hg.TranslationMat4(hg.Vec3(0, 0, 0)),
                                     cube_ref, [mat_grey], hg.RBT_Kinematic, 1.0)

# Initialisation de la physique
physics = hg.SceneBullet3Physics()
physics.SceneCreatePhysicsFromAssets(scene)
physics_step = hg.time_from_sec_f(1 / 60)
dt_frame_step = hg.time_from_sec_f(1 / 60)

clocks = hg.SceneClocks()

hg.SetLogLevel(hg.LL_Normal)
print(">>> Description:\n>>> Déplace un cube cinématique de gauche à droite et le fait tourner sur son axe Y.")

# Boucle principale
keyboard = hg.Keyboard()
frame_count = 0

while not keyboard.Down(hg.K_Escape) and hg.IsWindowOpen(win):
    keyboard.Update()

    # Position et rotation du cube
    _pos = hg.Vec3((math.fmod(frame_count, 200.0) - 100.0) / 100.0, 0.0, 0.0)
    _rot = hg.Vec3(0.0, math.pi * frame_count / 360.0, 0.0)
    cube_node.GetTransform().SetWorld(hg.TransformationMat4(_pos, _rot))

    # Mise à jour de la scène
    view_id = 0
    hg.SceneUpdateSystems(scene, clocks, dt_frame_step, physics, physics_step, 3)
    view_id, pass_id = hg.SubmitSceneToPipeline(view_id, scene, hg.IntRect(0, 0, res_x, res_y),
                                                True, pipeline, res)

    # Debug physics display
    hg.SetViewClear(view_id, 0, 0, 1.0, 0)
    hg.SetViewRect(view_id, 0, 0, res_x, res_y)
    hg.SetViewTransform(view_id, view_matrix, projection_matrix)
    rs = hg.ComputeRenderState(hg.BM_Opaque, hg.DT_Disabled, hg.FC_Disabled)
    physics.RenderCollision(view_id, vtx_line_layout, line_shader, rs, 0)

    frame_count += 1

    hg.Frame()
    hg.UpdateWindow(win)

# Nettoyage
scene.Clear()
scene.GarbageCollect()
hg.RenderShutdown()
hg.DestroyWindow(win)

hg.WindowSystemShutdown()
hg.InputShutdown()