def update_target_point(dts):
global target_point, target_matrix
v = target_node.GetTransform().GetPosition() - target_point
target_point += v * pos_inertia * dts * 60
mat_n = target_node.GetTransform().GetWorld()
rz = hg.Cross(target_matrix.GetZ(), mat_n.GetZ())
ry = hg.Cross(target_matrix.GetY(), mat_n.GetY())
mr = rz + ry
if mr.Len() > 0.001:
target_matrix = MathsSupp.rotate_matrix(
target_matrix, mr.Normalized(),
mr.Len() * rot_inertia * dts * 60)
def rotate_matrix(cls, mat: hg.Matrix3, axe: hg.Vector3, angle): axeX = mat.GetX() axeY = mat.GetY() # axeZ=mat.GetZ() axeXr = cls.rotate_vector(axeX, axe, angle) axeYr = cls.rotate_vector(axeY, axe, angle) axeZr = hg.Cross(axeXr, axeYr) # cls.rotate_vector(axeZ,axe,angle) return hg.Matrix3(axeXr, axeYr, axeZr)
def update_kinetics(self, position: hg.Vector3, direction: hg.Vector3, v0: hg.Vector3, axisY: hg.Vector3, dts):
self.num_new = 0
if not self.end:
self.particles_cnt_f += dts * self.flow
self.num_new = int(self.particles_cnt_f) - self.particles_cnt
if self.num_new > 0:
for i in range(self.num_new):
if not self.loop and self.particles_cnt+i>=self.num_particles:break
particle = self.particles[(self.particles_cnt + i) % self.num_particles]
particle.age = 0
particle.delay = uniform(self.delay_range.x, self.delay_range.y)
particle.scale = uniform(self.scale_range.x,self.scale_range.y)
mat = particle.node.GetTransform()
dir = self.get_direction(direction)
rot_mat = hg.Matrix3(hg.Cross(axisY, dir), axisY, dir)
mat.SetPosition(position + dir * self.start_offset)
mat.SetRotationMatrix(rot_mat)
mat.SetScale(self.start_scale)
particle.rot_speed = hg.Vector3(uniform(self.rot_range_x.x, self.rot_range_x.y),
uniform(self.rot_range_y.x, self.rot_range_y.y),
uniform(self.rot_range_z.x, self.rot_range_z.y))
particle.v_move = v0 + dir * uniform(self.start_speed_range.x, self.start_speed_range.y)
particle.node.SetEnabled(False)
self.particles_cnt += self.num_new
n=0
for particle in self.particles:
if particle.age > particle.delay:
particle.kill()
elif particle.age == 0:
particle.age += dts
n+=1
elif particle.age > 0:
n+=1
if not particle.node.GetEnabled(): particle.node.SetEnabled(True)
t = particle.age / particle.delay
mat = particle.node.GetTransform()
pos = mat.GetPosition()
rot = mat.GetRotation()
particle.v_move += self.gravity * dts
spd = particle.v_move.Len()
particle.v_move -= particle.v_move.Normalized()*spd*self.linear_damping*dts
pos += particle.v_move * dts
rot += particle.rot_speed * dts
pos.y=max(0,pos.y)
mat.SetPosition(pos)
mat.SetRotation(rot)
mat.SetScale((self.start_scale * (1 - t) + self.end_scale * t)*particle.scale)
# material = particle.node.GetObject().GetGeometry().GetMaterial(0)
# material.SetFloat4("self_color",1.,1.,0.,1-t)
self.update_color(particle)
# particle.node.GetObject().GetGeometry().GetMaterial(0).SetFloat4("teint", 1,1,1,1)
particle.age += dts
if n==0 and not self.loop: self.end=True
def get_direction(self, main_dir): if self.stream_angle == 0: return main_dir axe0 = hg.Vector3(0, 0, 0) axeRot = hg.Vector3(0, 0, 0) while axeRot.Len() < 1e-4: while axe0.Len() < 1e-5: axe0 = hg.Vector3(uniform(-1, 1), uniform(-1, 1), uniform(-1, 1)) axe0.Normalize() axeRot = hg.Cross(axe0, main_dir) axeRot.Normalize() return MathsSupp.rotate_vector(main_dir, axeRot, random() * radians(self.stream_angle))
def update_radar(Main, plus, aircraft, targets):
value = Main.render_to_texture.value
t = hg.time_to_sec_f(plus.GetClock())
rx, ry = 150 / 1600 * Main.resolution.x, 150 / 900 * Main.resolution.y
rs = 200 / 1600 * Main.resolution.x
rm = 6 / 1600 * Main.resolution.x
radar_scale = 4000
plot_size = 12 / 1600 * Main.resolution.x / 2
plus.Sprite2D(rx, ry, rs, "assets/sprites/radar.png",
hg.Color(1, 1, 1, value))
mat = aircraft.get_parent_node().GetTransform().GetWorld()
aZ = mat.GetZ()
aZ.y = 0
aZ.Normalize()
aY = mat.GetY()
if aY.y < 0:
aY = hg.Vector3(0, -1, 0)
else:
aY = hg.Vector3(0, 1, 0)
aX = hg.Cross(aY, aZ)
mat_trans = hg.Matrix4.TransformationMatrix(mat.GetTranslation(),
hg.Matrix3(aX, aY,
aZ)).InversedFast()
for target in targets:
if not target.wreck and target.activated:
t_mat = target.get_parent_node().GetTransform().GetWorld()
aZ = t_mat.GetZ()
aZ.y = 0
aZ.Normalize()
aY = hg.Vector3(0, 1, 0)
aX = hg.Cross(aY, aZ)
t_mat_trans = mat_trans * hg.Matrix4.TransformationMatrix(
t_mat.GetTranslation(), hg.Matrix3(aX, aY, aZ))
pos = t_mat_trans.GetTranslation()
v2D = hg.Vector2(pos.x, pos.z) / radar_scale * rs / 2
if abs(v2D.x) < rs / 2 - rm and abs(v2D.y) < rs / 2 - rm:
if target.type == Destroyable_Machine.TYPE_MISSILE:
plot = Main.texture_hud_plot_missile
elif target.type == Destroyable_Machine.TYPE_AIRCRAFT:
plot = Main.texture_hud_plot_aircraft
elif target.type == Destroyable_Machine.TYPE_SHIP:
plot = Main.texture_hud_plot_ship
t_mat_rot = t_mat_trans.GetRotationMatrix()
ps = plot_size
a = 0.5 + 0.5 * abs(sin(t * uniform(1, 500)))
else:
if target.type == Destroyable_Machine.TYPE_MISSILE: continue
dir = v2D.Normalized()
v2D = dir * (rs / 2 - rm)
ps = plot_size
plot = Main.texture_hud_plot_dir
aZ = hg.Vector3(dir.x, 0, dir.y)
aX = hg.Cross(hg.Vector3.Up, aZ)
t_mat_rot = hg.Matrix3(aX, hg.Vector3.Up, aZ)
a = 0.5 + 0.5 * abs(sin(t * uniform(1, 500)))
cx, cy = rx + v2D.x, ry + v2D.y
if target.nationality == 1:
c = hg.Color(0.25, 1., 0.25, a)
elif target.nationality == 2:
c = hg.Color(1., 0.5, 0.5, a)
c.a *= value
p1 = t_mat_rot * hg.Vector3(-plot_size, 0, -ps)
p2 = t_mat_rot * hg.Vector3(-plot_size, 0, ps)
p3 = t_mat_rot * hg.Vector3(plot_size, 0, ps)
p4 = t_mat_rot * hg.Vector3(plot_size, 0, -ps)
plus.Quad2D(cx + p1.x, cy + p1.z, cx + p2.x, cy + p2.z, cx + p3.x,
cy + p3.z, cx + p4.x, cy + p4.z, c, c, c, c, plot)
c = hg.Color(1, 1, 1, value * max(pow(1 - aircraft.health_level, 2), 0.05))
plus.Quad2D(rx - rs / 2, ry - rs / 2, rx - rs / 2, ry + rs / 2,
rx + rs / 2, ry + rs / 2, rx + rs / 2, ry - rs / 2, c, c, c, c,
Main.texture_noise, 0.25 + 0.25 * sin(t * 103),
(0.65 + 0.35 * sin(t * 83)), 0.75 + 0.25 * sin(t * 538),
0.75 + 0.25 * cos(t * 120))
c = hg.Color(1, 1, 1, value)
plus.Sprite2D(rx, ry, rs, "assets/sprites/radar_light.png",
hg.Color(1, 1, 1, 0.3 * value))
plus.Sprite2D(rx, ry, rs, "assets/sprites/radar_box.png", c)
def render(self,
plus,
scene,
camera,
disable_render_scripts=False,
mat_camera=None):
renderer = plus.GetRenderer()
# Clipping plane:
# mat=self.plane.GetTransform().GetWorld()
# plane_pos=mat.GetTranslation()
# plane_normal=mat.GetY()
# renderer.SetClippingPlane(plane_pos+plane_normal*0.01, plane_normal)
plane_pos = hg.Vector3(0, 0, 0)
plane_normal = hg.Vector3(0, 1, 0)
# Camera reflect:
if mat_camera is not None:
mat = mat_camera
else:
mat = camera.GetTransform().GetWorld()
pos = mat.GetTranslation()
t = self.get_plane_projection_factor(pos, plane_pos, plane_normal)
pos_reflect = pos + plane_normal * 2 * t
xAxis = mat.GetX()
zAxis = mat.GetZ()
px = pos + xAxis
tx = self.get_plane_projection_factor(px, plane_pos, plane_normal)
x_reflect = px + plane_normal * 2 * tx - pos_reflect
z_reflect = hg.Reflect(zAxis, plane_normal)
y_reflect = hg.Cross(z_reflect, x_reflect)
mat.SetTranslation(pos_reflect)
mat.SetX(x_reflect)
mat.SetY(y_reflect)
mat.SetZ(z_reflect)
self.camera_reflect.GetTransform().SetWorld(mat)
scene.SetCurrentCamera(self.camera_reflect)
cam_org = camera.GetCamera()
cam = self.camera_reflect.GetCamera()
cam.SetZoomFactor(cam_org.GetZoomFactor())
cam.SetZNear(cam_org.GetZNear())
cam.SetZFar(cam_org.GetZFar())
# Render target:
vp_mem = renderer.GetViewport()
rect = self.render_texture.GetRect()
renderer.SetViewport(rect)
renderer.SetRenderTarget(self.render_target)
renderer.Clear(hg.Color(0., 0., 0., 0.))
if disable_render_scripts:
enabled_list = []
render_scripts = scene.GetComponents("RenderScript")
for rs in render_scripts:
enabled_list.append(rs.GetEnabled())
rs.SetEnabled(False)
scene.Commit()
scene.WaitCommit()
plus.UpdateScene(scene)
# Update reflection texture:
# material = self.plane.GetObject().GetGeometry().GetMaterial(0)
# material.SetTexture("reflect_map", self.render_texture)
# material.SetFloat("reflect_level", self.reflect_level)
# material.SetFloat4("color", self.color.r,self.color.g,self.color.b,self.color.a)
# System restauration
scene.SetCurrentCamera(camera)
renderer.ClearRenderTarget()
# renderer.ClearClippingPlane()
renderer.SetViewport(vp_mem)
if disable_render_scripts:
for rs in enumerate(render_scripts):
if enabled_list[rs[0]]:
rs[1].SetEnabled(True)
scene.Commit()
scene.WaitCommit()
