def draw_circle(scene_simple_graphic, world, r, color): step = 50 prev = gs.Vector3(math.cos(0) * r, 0, math.sin(0) * r) * world for i in range(step+1): val = gs.Vector3(math.cos(math.pi*2*float(i)/step) * r, 0, math.sin(math.pi*2*float(i)/step) * r) * world scene_simple_graphic.Line(prev.x, prev.y, prev.z, val.x, val.y, val.z, color, color) prev = val
def deserialize_matrix(s):
f = s.split(";")
m = gs.Matrix4()
m.SetRow(0, gs.Vector3(float(f[0]), float(f[1]), float(f[2])))
m.SetRow(1, gs.Vector3(float(f[3]), float(f[4]), float(f[5])))
m.SetRow(2, gs.Vector3(float(f[6]), float(f[7]), float(f[8])))
m.SetRow(3, gs.Vector3(float(f[9]), float(f[10]), float(f[11])))
return m
def affiche_geometrie(self, x, y, z, ex, ey, axe_x, axe_y, axe_z, teinte):
pos = gs.Vector3(x, y, z)
rot = gs.Matrix3(axe_x, axe_y, axe_z)
mat = gs.Matrix4.TransformationMatrix(pos, rot)
mat.SetScale(gs.Vector3(ex, ey, 1))
materiau = self.geometrie.GetMaterial(0)
materiau.SetFloat4("teinte", teinte.r, teinte.g, teinte.b, teinte.a)
Demo.rendu_scene.DrawGeometry(self.geometrie, mat)
def setup_scenario_1(): # walls scene.add_physic_cube(scn, mat=gs.Matrix4.TransformationMatrix(gs.Vector3(tile_quantizer(md_screen_w * -0.1), tile_quantizer(md_screen_h * 0.25), 0),gs.Vector3(0,0, pi * 0.25)), width=sphere_radius * 2.0, height=sphere_radius * 12.0, depth=sphere_radius, mass=0.0) scene.add_physic_cube(scn, mat=gs.Matrix4.TransformationMatrix(gs.Vector3(tile_quantizer(md_screen_w * 0.1), tile_quantizer(md_screen_h * -0.15), 0),gs.Vector3(0,0, pi * -0.25)), width=sphere_radius * 2.0, height=sphere_radius * 12.0, depth=sphere_radius, mass=0.0) scene.add_physic_cube(scn, mat=gs.Matrix4.TransformationMatrix(gs.Vector3(tile_quantizer(md_screen_w * -0.1), tile_quantizer(md_screen_h * -0.5), 0),gs.Vector3(0,0, pi * 0.25)), width=sphere_radius * 2.0, height=sphere_radius * 12.0, depth=sphere_radius, mass=0.0)
def affiche_geometrie(self):
#SpriteFrame.affiche_geometrie(self,self.x,self.y,self.z,self.ex,self.ey,self.axe_x,self.axe_y,self.axe_z,self.teinte)
#Version optimisée:
pos = gs.Vector3(self.x, self.y, self.z)
mat = gs.Matrix4.TransformationMatrix(pos, self.rotation)
mat.SetScale(gs.Vector3(self.ex, self.ey, 1))
materiau = self.geometrie.GetMaterial(0)
materiau.SetFloat4("teinte", self.teinte.r, self.teinte.g,
self.teinte.b, self.teinte.a)
Demo.rendu_scene.DrawGeometry(self.geometrie, mat)
def affiche_geometrie_inverse_X(self, x, y, z, ex, ey, axe_x, axe_y, axe_z,
teinte):
pos = gs.Vector3(x, y, z)
#axe_x_inverse=MathsSupp.rotation_vecteur(axe_x,axe_y,pi*2)
rot = gs.Matrix3(gs.Vector3(-axe_x.x, -axe_x.y, -axe_x.z), axe_y,
gs.Vector3(-axe_z.x, -axe_z.y, -axe_z.z))
mat = gs.Matrix4.TransformationMatrix(pos, rot)
mat.SetScale(gs.Vector3(ex, ey, 1))
materiau = self.geometrie.GetMaterial(0)
materiau.SetFloat4("teinte", teinte.r, teinte.g, teinte.b, teinte.a)
Demo.rendu_scene.DrawGeometry(self.geometrie, mat)
def __init__(self): self.tgt = gs.Vector3() self.rot = gs.Matrix3() self.d = 10 self.rot_speed = 1.0 self.k_wheel = 40
def update_keyboard(self, cam, dt): keyboard_device = gs.GetKeyboard() # fps move speed speed = dt * 3 * self.speed if keyboard_device.IsDown(gs.InputDevice.KeyLShift): speed *= 6 # fps move local_dt = gs.Vector3() if keyboard_device.IsDown(self.fps_move_forward): local_dt += gs.Vector3.Front if keyboard_device.IsDown(self.fps_move_back): local_dt += gs.Vector3.Back if keyboard_device.IsDown(self.fps_move_right): local_dt += gs.Vector3.Right if keyboard_device.IsDown(self.fps_move_left): local_dt += gs.Vector3.Left if keyboard_device.IsDown(self.fps_move_up): local_dt += gs.Vector3.Up if keyboard_device.IsDown(self.fps_move_down): local_dt += gs.Vector3.Down if local_dt == gs.Vector3.Zero: return False self.pos += cam.GetTransform().GetWorld().Rotate(local_dt.Normalized() * speed) return True
def render_strings_array(strings=None, fade=1.0, fonts_dict={}):
sys = render.get_render_system()
render.get_renderer().EnableBlending(True)
render.get_renderer().EnableDepthTest(False)
for line in strings:
font_key = line[4] + "_" + str(line[5])
if not font_key in fonts_dict:
fonts_dict[font_key] = gs.RasterFont(
"@assets/" + line[4] + ".ttf", int(line[5] * zoom_size() / 3),
512)
rect = fonts_dict[font_key].GetTextRect(sys, line[0])
x = (demo_screen_size[0] - rect.GetWidth()) * 0.5
y = (amiga_screen_size[1] - line[1]) * zoom_size()
fonts_dict[font_key].Write(sys, line[0], gs.Vector3(x, y, 0.5),
gs.Color.White * fade)
sys.DrawRasterFontBatch()
render.get_renderer().EnableBlending(False)
# underline ?
for line in strings:
if line[3] == 1:
font_key = line[4] + "_" + str(line[5])
rect = fonts_dict[font_key].GetTextRect(sys, line[0])
x = (demo_screen_size[0] - rect.GetWidth()) * 0.5
y = (amiga_screen_size[1] - line[1]) * zoom_size() - (
line[5] * 0.2 * zoom_size() / 3)
render.line2d(x, y, x + rect.GetWidth(), y,
gs.Color.White * fade * fade,
gs.Color.White * fade * fade)
return fonts_dict
def calcul_point_plan_projection(cls, cx, cy, cz, spx, spy, axe_x, axe_y):
"""
Projette un point du plan du sprite dans l'espace
:param cx: position spatiale de l'origine du plan du sprite
:param cy:
:param cz:
:param spx: Position dans le plan du sprite
:param spy:
:param axe_x: Plan du sprite
:param axe_y:
:return: gs.Vector3 - la position du point dans l'espace
"""
projX = gs.Vector3(spx * axe_x.x, spx * axe_x.y, spx * axe_x.z)
projY = gs.Vector3(spy * axe_y.x, spy * axe_y.y, spy * axe_y.z)
point = gs.Vector3(projX + projY) + gs.Vector3(cx, cy, cz)
return point
def rotation_vecteur(cls, point, axe, angle):
prod_scal = point.x * axe.x + point.y * axe.y + point.z * axe.z
cos_angle = cos(angle)
sin_angle = sin(angle)
return gs.Vector3(cos_angle * point.x + sin_angle * (axe.y * point.z - axe.z * point.y) + (1 - cos_angle) * prod_scal * axe.x,\
cos_angle * point.y + sin_angle * (axe.z * point.x - axe.x * point.z) + (1 - cos_angle) * prod_scal * axe.y,\
cos_angle * point.z + sin_angle * (axe.x * point.y - axe.y * point.x) + (1 - cos_angle) * prod_scal * axe.z)
def reset_view(scn, cam, cam_handler, use_vr):
cam_world = None
# move the camera to see the fbx entirely
spawnpoint = scn.GetNode("spawnpoint_0")
if spawnpoint is not None:
cam_world = spawnpoint.GetTransform().GetWorld()
print("Find spawnpoint_0")
else:
print("can't find sppawnpoint_0")
if cam_world is None:
# move the camera to see the fbx entirely
min_max = gs.MinMax()
for n in scn.GetNodes():
if n.GetObject() is not None:
min_max.Grow(n.GetObject().GetLocalMinMax().Transformed(n.GetTransform().GetWorld()))
d = min_max.mx.x - min_max.mn.x
d = max(d, min_max.mx.y - min_max.mn.y)
d = max(d, min_max.mx.z - min_max.mn.z)
d = max(0.2, d) * 2
cam_pos = gs.Vector3(-1, -1, 1).Normalized() * -d
cam_world = gs.Matrix4.TransformationMatrix(cam_pos, gs.Matrix3.LookAt(cam_pos * -1),
gs.Vector3.One)
# in case of vr, no rotation
if use_vr:
cam_world = gs.Matrix4.TranslationMatrix(cam_pos * -1)
d = 1
else:
# in case of no vr, up the camera to 1.75
if not use_vr:
cam_world = cam_world * gs.Matrix4.TranslationMatrix(gs.Vector3(0, 1.75, 0))
print("no vr: camera up to 1.75m")
d = 1
if not use_vr:
cam_handler.reset(cam_world, d, cam)
else:
cam.GetTransform().SetWorld(cam_world)
def setup_scenario_2(): # walls # scene.add_physic_cube(scn, mat=gs.Matrix4.TransformationMatrix(gs.Vector3(tile_quantizer(md_screen_h * -0.2), -md_screen_h * 0.5,0),gs.Vector3(0,0,0)), # width=sphere_radius * 2.0, height=sphere_radius * 12.0, depth=sphere_radius, mass=0.0) # scene.add_physic_cube(scn, mat=gs.Matrix4.TransformationMatrix(gs.Vector3(tile_quantizer(md_screen_h * 0.2), -md_screen_h * 0.5,0),gs.Vector3(0,0,0)), # width=sphere_radius * 2.0, height=sphere_radius * 12.0, depth=sphere_radius, mass=0.0) scene.add_physic_cube(scn, mat=gs.Matrix4.TransformationMatrix(gs.Vector3(tile_quantizer(md_screen_h * -0.4), -md_screen_h * 0.5,0),gs.Vector3(0,0,0)), width=sphere_radius * 2.0, height=sphere_radius * 8, depth=sphere_radius, mass=0.0) scene.add_physic_cube(scn, mat=gs.Matrix4.TransformationMatrix(gs.Vector3(tile_quantizer(md_screen_h * 0.4), -md_screen_h * 0.5,0),gs.Vector3(0,0,0)), width=sphere_radius * 2.0, height=sphere_radius * 8, depth=sphere_radius, mass=0.0) scene.add_physic_sphere(scn, mat=gs.Matrix4.TransformationMatrix(gs.Vector3(0,-md_screen_h * 0.25,0),gs.Vector3(0,0,0)), radius=sphere_radius * 4.0, mass=0.0) scene.add_physic_cube(scn, mat=gs.Matrix4.TransformationMatrix(gs.Vector3(tile_quantizer(md_screen_w * -0.48), -md_screen_h * 0.5,0),gs.Vector3(0,0,0)), width=sphere_radius * 2.0, height=sphere_radius * 16.0, depth=sphere_radius, mass=0.0) scene.add_physic_cube(scn, mat=gs.Matrix4.TransformationMatrix(gs.Vector3(tile_quantizer(md_screen_w * 0.48), -md_screen_h * 0.5,0),gs.Vector3(0,0,0)), width=sphere_radius * 2.0, height=sphere_radius * 16.0, depth=sphere_radius, mass=0.0)
def tri_sprites(cls, liste, camera):
if len(liste) > 0:
camPos = camera.GetTransform().GetWorld().GetTranslation()
for sprite in liste:
sprPos = camPos - gs.Vector3(sprite.x, sprite.y, sprite.z)
sprite.distance_camera = sprPos.Len()
return sorted(liste,
key=attrgetter("distance_camera"),
reverse=True)
else:
return liste
def draw_spline(scene_simple_graphic, p1, p2, p3, p4, color): P = [(p1.x, p1.y, p1.z), (p2.x, p2.y, p2.z), (p3.x, p3.y, p3.z), (p4.x, p4.y, p4.z)] C = bspline.C_factory(P, 3, "clamped") if C: step = 50 prev_value = [p1.x, p1.y, p1.z] val = gs.Vector3() for i in range(step): val = C(float(i)/step * C.max) scene_simple_graphic.Line(prev_value[0], prev_value[1], prev_value[2], val[0], val[1], val[2], color, color) prev_value = val
def __init__(self): self.pos = gs.Vector3() self.rot = gs.Matrix3() self.fps_move_forward = gs.InputDevice.KeyZ self.fps_move_back = gs.InputDevice.KeyS self.fps_move_left = gs.InputDevice.KeyQ self.fps_move_right = gs.InputDevice.KeyD self.fps_move_up = gs.InputDevice.KeyE self.fps_move_down = gs.InputDevice.KeyA self.speed = 1.0 self.rot_speed = 1.0
def throw_bullet(size=1.0, mass=1.0, type='sphere', spread_angle=1.0, spread_pos=1.0):
world = gs.Matrix4.TransformationMatrix(make_solid_pos(uniform(md_screen_w * -0.01 * size * spread_pos, md_screen_w * 0.01 * size * spread_pos), md_screen_h / 2 + (sphere_radius * size)), gs.Vector3())
if type.find('sphere') > -1:
new_bullet, rigid_body = scene.add_physic_sphere(scn, world, sphere_radius * size, mass=mass)
elif type.find('cube') > -1:
new_bullet, rigid_body = scene.add_physic_cube(scn, world, sphere_radius * size * 1.6, sphere_radius * size * 1.6, sphere_radius * size * 1.6, mass=mass)
if type.find('elastic') > -1:
rigid_body.SetRestitution(1.15)
ejection_vector = world.GetY() + gs.Vector3(uniform(-1.0, 1.0), uniform(0.0, 1.0), 0.0) * spread_angle
rigid_body.ApplyLinearImpulse(ejection_vector * (-50 / scale_factor))
new_bullet.SetName('type;' + type + ';size;' + str(int(size)) + ';mass;' + str(int(mass)))
def draw_fps(scn, gui, scene_simple_graphic, use_vr, dt_sec):
fps_text = "FPS:{0}".format(int(1 / dt_sec.to_sec()))
if use_vr:
head_controller = gs.GetInputSystem().GetDevice("openvr_hmd")
if head_controller is not None and scn.GetCurrentCamera() is not None:
text_mat = head_controller.GetMatrix(
gs.InputDevice.MatrixHead) * gs.Matrix4.TranslationMatrix(
gs.Vector3(-0.1, -0.1, 0.5))
text_pos = text_mat.GetTranslation() + scn.GetCurrentCamera(
).GetTransform().GetPosition()
scene_simple_graphic.SetDepthTest(False)
scene_simple_graphic.SetBlendMode(gs.BlendAlpha)
scene_simple_graphic.Text(text_pos.x, text_pos.y, text_pos.z,
fps_text, gs.Color.Green, font, 0.001)
gui.Text(fps_text)
def create_new_scene():
global scn, sky_script, scene_simple_graphic, cam, openvr_frame_renderer
if scn is None:
scn = plus.NewScene()
# check if we use VR
openvr_frame_renderer = gs.GetFrameRenderer("OpenVR")
if openvr_frame_renderer is not None and openvr_frame_renderer.Initialize(
plus.GetRenderSystem()):
scn.GetSystem("Renderable").SetFrameRenderer(openvr_frame_renderer)
else:
openvr_frame_renderer = None
# openvr_frame_renderer = None
else:
scn.Dispose()
# purge cache
plus.GetRenderSystemAsync().PurgeCache()
plus.GetRendererAsync().PurgeCache()
plus.UpdateScene(scn, gs.time(1.0 / 60))
plus.UpdateScene(scn, gs.time(1.0 / 60))
plus.UpdateScene(scn, gs.time(1.0 / 60))
# scn.GetPhysicSystem().SetDebugVisuals(True)
vr_controller.clear_controllers(scn)
# add sky
if show_sky:
sky_script = gs.LogicScript("@core/lua/sky_lighting.lua")
sky_script.Set("time_of_day", 15.0)
sky_script.Set("attenuation", 0.75)
sky_script.Set("shadow_range", 1000.0) # 1km shadow range
sky_script.Set("shadow_split", gs.Vector4(0.1, 0.2, 0.3, 0.4))
scn.AddComponent(sky_script)
else:
sky_script = None
# add simple graphic, to draw 3D line
scene_simple_graphic = gs.SimpleGraphicSceneOverlay(False)
scn.AddComponent(scene_simple_graphic)
cam = plus.AddCamera(scn,
gs.Matrix4.TranslationMatrix(gs.Vector3(0, 1, -10)))
def set_state_from_target(self, tgt, dir, d): self.tgt, self.rot, self.d = gs.Vector3(tgt), gs.Matrix3.LookAt(dir), d
def update_camera_teleporter(scn, scene_simple_graphic, cam, use_vr, authorise_ground_node):
controller0 = gs.GetInputSystem().GetDevice("openvr_controller_0")
pos_start = None
dir_teleporter = None
teleporter_activate = False
if use_vr is not None and controller0 is not None:
if controller0.GetValue(gs.InputDevice.InputButton0) != 0 or controller0.GetValue(gs.InputDevice.InputButton1) != 0:
pos_cam = cam.GetTransform().GetPosition()
mat_controller = controller0.GetMatrix(gs.InputDevice.MatrixHead)
dir_teleporter = mat_controller.GetZ()
pos_start = mat_controller.GetTranslation() + pos_cam
teleporter_activate = controller0.WasButtonPressed(gs.InputDevice.Button0)
else:
if plus.KeyDown(gs.InputDevice.KeyX) or plus.KeyDown(gs.InputDevice.KeyC):
pos_start = cam.GetTransform().GetPosition()
dir_teleporter = cam.GetTransform().GetWorld().GetZ()
if pos_start is not None:
if pos_start.y < 0:
return
# teleporter
# project point on the ground
cos_angle = dir_teleporter.Dot(gs.Vector3(dir_teleporter.x, 0, dir_teleporter.z).Normalized())
cos_angle = min(1.0, max(cos_angle, -1))
angle = math.acos(cos_angle)
if dir_teleporter.y < 0:
angle = -angle
velocity = 5
d = ((velocity * cos_angle) / 9.81) * (velocity * math.sin(angle) + math.sqrt((velocity * math.sin(angle)) ** 2 + 2 * 9.81 * pos_start.y))
else:
velocity = 5
min_d = ((velocity * 1) / 9.81) * (velocity * math.sin(0) + math.sqrt((velocity * math.sin(0)) ** 2 + 2 * 9.81 * pos_start.y))
max_d = 10
d = min_d + (1.0 - abs(cos_angle)) * max_d
ground_pos = gs.Vector3(pos_start.x, 0, pos_start.z) + gs.Vector3(dir_teleporter.x, 0, dir_teleporter.z).Normalized() *d
authorise_movement = True
if authorise_ground_node is not None:
authorise_ground_node.GetObject().GetGeometry().GetMaterial(0).SetFloat3("pos_touched", ground_pos.x, ground_pos.y, ground_pos.z)
hit, trace = scn.GetPhysicSystem().Raycast(ground_pos + gs.Vector3(0, 0.5, 0), gs.Vector3(0, -1, 0), 4, 3)
if not hit or trace.GetNode() != authorise_ground_node:
authorise_movement = False
strength_force = math.pow((math.sin(angle) + 1) / 2, 2) * 2
color = gs.Color(0, 1, 198/255) if authorise_movement else gs.Color(1, 18/255, 0)
helper_2d.draw_spline(scene_simple_graphic, pos_start, pos_start + dir_teleporter * strength_force, ground_pos + gs.Vector3(0, strength_force, 0), ground_pos, color)
if authorise_ground_node is None:
helper_2d.draw_circle(scene_simple_graphic, gs.Matrix4.TranslationMatrix(ground_pos), 1, color)
if authorise_movement and teleporter_activate:
if use_vr:
head_controller = gs.GetInputSystem().GetDevice("openvr_hmd")
head_pos = head_controller.GetMatrix(gs.InputDevice.MatrixHead).GetTranslation()
head_pos.y = 0
ground_pos = ground_pos - head_pos
cam.GetTransform().SetWorld(gs.Matrix4.TranslationMatrix(ground_pos))
else:
if authorise_ground_node is not None:
authorise_ground_node.GetObject().GetGeometry().GetMaterial(0).SetFloat3("pos_touched", 99999, 99999, 99999)
def apply_state(self, camera): world = gs.Matrix4.TransformationMatrix(self.tgt, self.rot, gs.Vector3.One) * gs.Matrix4.TranslationMatrix(gs.Vector3(0, 0, -self.d)) camera.GetTransform().SetWorld(world) return world
def init(cls):
#-------- Environnement:
cls.couleur_horizon = gs.Color(1., .699, .586)
cls.couleur_zenith = gs.Color(1., 0.978, 0.407)
cls.couleur_ambiante = gs.Color(0.19, 0.42, 0.34)
#cls.couleur_ambiante=gs.Color(0.5,0.5,0.5)
#-------- Création de la scène:
cls.scene3d = scene.new_scene()
cls.contexte = gs.SceneLoadContext(render.get_render_system())
cls.scene3d.Load("scene_01/Gare_test.scn", cls.contexte)
#----------- Attend que la scène soit accessible:
scene.update_scene(cls.scene3d, 1 / 60)
#----------- Prise en main de la scène:
cls.noeuds = cls.contexte.GetNodes()
cls.components = cls.scene3d.GetComponents()
for comp in cls.components:
if comp.GetAspect() == "Environment":
cls.environnement = comp
break
#----------- Init billboards et shaders:
cls.init_billboards(cls.noeuds, cls.liste_sprites_scene)
cls.init_shaders(cls.noeuds)
#----------- Init environnement:
cls.environnement.SetBackgroundColor(cls.couleur_horizon)
cls.environnement.SetFogColor(cls.couleur_horizon)
cls.environnement.SetFogNear(1)
cls.environnement.SetFogFar(100)
cls.environnement.SetAmbientIntensity(2)
cls.environnement.SetAmbientColor(cls.couleur_ambiante)
cls.camera = cls.scene3d.GetNode("Camera")
cls.camera.GetCamera().SetZNear(.1)
cls.camera.GetCamera().SetZFar(1000.)
cls.camera_start_pos_mem = cls.camera.GetTransform().GetPosition()
#cls.camera.AddComponent(gs.Target()) #Si la caméra suit une cible
cls.lumiere_clair_obscur = cls.scene3d.GetNode("clair obscur")
cls.lumiere_soleil = cls.scene3d.GetNode("soleil")
cls.lumiere_soleil.GetLight().SetShadow(
gs.Light.Shadow_Map) #Active les ombres portées
cls.lumiere_soleil.GetLight().SetShadowRange(100)
cls.lumiere_soleil.GetLight().SetDiffuseIntensity(1.)
cls.lumiere_soleil.GetLight().SetSpecularIntensity(1.)
orientation = gs.Vector3(54 / 180 * pi, 135 / 180 * pi, 0)
cls.lumiere_clair_obscur.GetTransform().SetRotation(orientation)
orientation = gs.Vector3(54 / 180 * pi, -45 / 180 * pi, 0)
cls.lumiere_soleil.GetTransform().SetRotation(orientation)
#cls.lumiere_clair_obscur.GetLight().SetDiffuseIntensity(2.)
#cls.lumiere_clair_obscur.GetLight().SetSpecularIntensity(2.)
#-------- Mémorise les intensités lumineuses pour le switch des éclairages:
noeuds = cls.scene3d.GetNodes()
for noeud in noeuds:
if not noeud.GetLight() == None:
cls.lumieres_intens_mem.append(
noeud.GetLight().GetDiffuseIntensity())
cls.lumieres_intens_mem.append(
noeud.GetLight().GetSpecularIntensity())
#--------Init les variables de shaders:
#Couleur d'ambiance:
"""
for noeud in cls.noeuds:
if not noeud.GetObject()==None:
obj=noeud.GetObject()
geo=obj.GetGeometry()
n=geo.GetMaterialCount()
i=0
while i<n:
materiau=geo.GetMaterial(i)
materiau.SetFloat3("ambient_color",cls.couleur_ambiante.r*0.,cls.couleur_ambiante.g*0.,cls.couleur_ambiante.b*0.)
i+=1
"""
#--------- Init listes des sprites:
#cls.liste_sprites_scene.append(...)
#--------- Inits de l'éditeur embarqué
cls.cube_l_soleil = scene.add_cube(cls.scene3d, gs.Matrix4.Identity,
0.5, 0.5, 2.)
cls.cube_l_clair_obscur = scene.add_cube(cls.scene3d,
gs.Matrix4.Identity, 0.5, 0.5,
2.)
cls.scene3d.SetCurrentCamera(cls.camera)
scene.update_scene(cls.scene3d, 1 / 60)
def convert_to_max(pos):
return gs.Vector3(pos.x, pos.z, pos.y)
def make_solid_pos(x,y): return gs.Vector3(x, y, 0.0)
def render_mask_screen():
mask_segment_list = wireframe_json_to_segment_list(
"@assets/exxos_mask.json")
scn = scene.new_scene()
while not scn.IsReady():
scene.update_scene(scn, 0.0)
# Add an environment to the scene
env = gs.Environment()
env.SetBackgroundColor(gs.Color.Black)
scn.AddComponent(env)
# Add a camera
render_camera = gs.Node()
render_camera.AddComponent(gs.Transform())
render_camera.AddComponent(gs.Camera())
scn.AddNode(render_camera)
scn.SetCurrentCamera(render_camera)
render_camera.GetTransform().SetPosition(gs.Vector3(0, 0, -50))
# Create a (parent) node to rotate the mask
master_node = gs.Node()
master_node.AddComponent(gs.Transform())
scn.AddNode(master_node)
# Init the starfield
starfield.init_stars()
starfield.set_camera_velocity(gs.Vector3(0, 0, -50))
segment_nodes_list = []
for seg in mask_segment_list:
node_a, node_b = gs.Node(), gs.Node()
tr_a, tr_b = gs.Transform(), gs.Transform()
tr_a.SetPosition(gs.Vector3(seg[0][0], seg[0][1], seg[0][2]))
tr_b.SetPosition(gs.Vector3(seg[1][0], seg[1][1], seg[1][2]))
tr_a.SetParent(master_node)
tr_b.SetParent(master_node)
node_a.AddComponent(tr_a)
node_b.AddComponent(tr_b)
scn.AddNode(node_a)
scn.AddNode(node_b)
segment_nodes_list.append([node_a, node_b])
seq_duration = 20.0
fx_timer = 0.0
while fx_timer < seq_duration:
render.clear()
dt_sec = clock.update()
master_node.GetTransform().SetRotation(
master_node.GetTransform().GetRotation() +
gs.Vector3(1, 1, 1) * dt_sec * 0.25)
scene.update_scene(scn, dt_sec)
# render.commit_3d()
# render.set_depth_write3d(False)
starfield.update_stars(dt_sec)
starfield.draw_stars(render)
for seg in segment_nodes_list:
pos_a = seg[0].GetTransform().GetWorld().GetTranslation()
pos_b = seg[1].GetTransform().GetWorld().GetTranslation()
render.line3d(pos_a.x,
pos_a.y,
pos_a.z,
pos_b.x,
pos_b.y,
pos_b.z,
start_color=gs.Color.Blue,
end_color=gs.Color.Blue)
render.flip()
fx_timer += dt_sec
def make_solid_pos(x, y):
return gs.Vector3(x * 1.15, y + height * 0.5, cos(x * y + x) * 0.15)
import gs.plus.scene as scene
import gs.plus.clock as clock
from math import pi, cos, sin, asin
import codecs
filename_out = "../src/simulation"
scale_factor = 5.0
gs.plus.create_workers()
gs.LoadPlugins(gs.get_default_plugins_path())
render.init(1280, 720, "../pkg.core")
scn = scene.new_scene()
cam = scene.add_camera(scn,
gs.Matrix4.TranslationMatrix(gs.Vector3(0, 3.5, -12.5)))
cam.GetTransform().SetRotation(
gs.Vector3(pi * 5.0 / 180.0, pi * -5.0 / 180.0, 0))
scene.add_light(scn, gs.Matrix4.RotationMatrix(gs.Vector3(0.65, -0.45, 0)),
gs.Light.Model_Linear, 150)
scene.add_light(scn,
gs.Matrix4.RotationMatrix(gs.Vector3(0.55, pi, 0.2)),
gs.Light.Model_Linear,
diffuse=gs.Color(0.3, 0.3, 0.4))
scene.add_physic_plane(scn)
# nodes = add_kapla_tower(scn, 0.5, 2, 2, 6, 16)
width, height, length = 1, 1, 1
## Starfield 3D
import gs
import random
max_stars = 0
stars = []
starfield_size = gs.Vector3(50, 50, 500)
camera_velocity = gs.Vector3()
pos_dt = gs.Vector3()
def init_stars(_max_stars=500):
global stars, max_stars, starfield_size
max_stars = _max_stars
def rand_point_within_size():
global starfield_size
return gs.Vector3(random.uniform(-starfield_size.x, starfield_size.x),
random.uniform(-starfield_size.y, starfield_size.y),
random.uniform(-starfield_size.z, starfield_size.z))
for i in range(max_stars):
stars.append({'pos': rand_point_within_size(), 'intensity': 1.0})
def set_camera_velocity(vec):
global camera_velocity, pos_dt
camera_velocity = vec
framerate = 60.0
while framerate > 0 and pos_dt.Len() < 5.0:
def rand_point_within_size():
global starfield_size
return gs.Vector3(random.uniform(-starfield_size.x, starfield_size.x),
random.uniform(-starfield_size.y, starfield_size.y),
random.uniform(-starfield_size.z, starfield_size.z))
