def Init(self):
self.scenescfg = "./data/scenescfg.json"
if not os.path.exists(self.scenescfg) and not os.path.isfile(
self.scenescfg):
PutLogList("(!) Cannot open configuration file:%s" %
self.scenescfg)
return False
scenes = json.load(open(self.scenescfg))
path = scenes['path']
self.scenelist = scenes['scenes'].split(',')
start_scene = scenes['start_scene']
for scenename in self.scenelist:
scenecfg = path + os.sep + scenename
if not os.path.exists(scenecfg) and not os.path.isfile(scenecfg):
PutLogList("(!) Cannot open configuration file:%s" % scenecfg)
self.scenelist.remove(scenename)
continue
scene = Scene(scenecfg)
self.scenes[scene.sceneid] = scene
start_scene = path + os.sep + start_scene
if start_scene == scenecfg:
self.newbie_scene = scene.sceneid
from GateLogic import GateLogic
from StoreClient import StoreClient
self.gatelogic = GateLogic.instance()
self.storeclient = StoreClient.instance()
return True
def test_Scene_set_init_velo_1():
x = randrange(-10e6, 10e6)
y = randrange(-10e6, 10e6)
s = randrange(1, 10e6)
m = randrange(1, 10e6)
v_x = randrange(-10e6, 10e6)
v_y = randrange(-10e6, 10e6)
def F_x(t):
return randrange(-50, 50) * t + randrange(-50, 50)
def F_y(t):
return randrange(-50, 50) * t + randrange(-50, 50)
t = TriangleT(x, y, s, m)
scene = Scene(t, F_x, F_y, v_x, v_y)
new_v_x = randrange(-10e6, 10e6)
new_v_y = randrange(-10e6, 10e6)
scene.set_init_velo(new_v_x, new_v_y)
assert scene.get_init_velo() == (new_v_x, new_v_y)
def initHomeScene(self):
objects = {}
def start():
# breakpoint()
self.homeScene.objects["titleDisplay"] = Text(
self.homeScene, Vector2(6, 70), Vector2(67, 200),
pygame.Color(255, 255, 255), "Assets/Recreativos.otf",
"Snake Adventures")
self.homeScene.objects["pressStartDisplay"] = Text(
self.homeScene, Vector2(170, 300), Vector2(42, 200),
pygame.Color(255, 255, 255), "Assets/Recreativos.otf",
"PRESS SPACE BAR")
def update():
# breakpoint()
self.homeScene.objects["titleDisplay"].draw(self.screenRef)
self.homeScene.objects["pressStartDisplay"].draw(self.screenRef)
# pygame.time.wait(500)
# self.screenRef.fill((0, 0, 0))
# titleDisplay.draw(self.screenRef)
# pygame.time.wait(500)
key = pygame.key.get_pressed()
if key[pygame.K_SPACE]:
self.sceneLoad(self.mainScene)
self.homeScene = Scene(objects, start, update)
def render_task(cfgpath, pid, taskqueue, resultqueue):
#print('pid:%d'%(pid))
# print("SceneInit:X:%d,Y:%d,W:%d,H:%d"%(beginx,beginy,width,height))
# scene = Scene()
# if scene.init_scene(cfgpath) == False:
# print("Scene Init Faild")
# return
# print("Scene Render Begin")
# scene.render_range(beginx, beginy, width, height, pixelqueue)
# print("Range Finish")
#colors = []
#colordict[pid] = []
#if colordict.has_key(pid) == False:
#print("Key:%d"%(pid))
#colordict[7] = 5
scene = Scene()
if scene.init_scene(cfgpath) == False:
print("Scene Init Faild")
return None
# print("Scene Render Begin:PID:,X:%d,Y:%d,W:%d,H:%d"%(data[0],data[1],data[2],data[3]))
# scene.render_range(data[0],data[1],data[2],data[3],data[4],data[5], colors)
# print("Range Finish")
# return colors
while taskqueue.empty() == False:
dt = taskqueue.get(True)
print("Scene Render Begin:PID:%d,X:%d,Y:%d,W:%d,H:%d"%(pid,dt[0],dt[1],dt[2],dt[3]))
scene.render_range(dt[0],dt[1],dt[2],dt[3],dt[4],dt[5], resultqueue)
print("Range Finish")
def Main():
x_length = 600
y_length = 600
clock = pygame.time.Clock()
while True:
scene = Scene(x_length, y_length)
snake = Snake()
while True:
clock.tick(10)
direction = GetClick()
coord = scene.CalculateDistances(snake)
#print(coord)
snake.UpdateDirection(direction)
scene.CheckCatchApple(snake)
snake.UpdateSnake()
ret = scene.CheckColisson(snake)
if ret == False:
scene.UpdateScreen(snake)
else:
score = scene.GameOver()
break
def initOverScene(self):
objects = {}
def start():
self.gameOverScene.objects["titleDisplay"] = Text(
self.homeScene, Vector2(180, 70), Vector2(67, 200),
pygame.Color(255, 0, 0), "Assets/Recreativos.otf", "Game Over")
# self.gameOverScene.objects["killDisplay"] = Text(self.homeScene, Vector2(180, 500), Vector2(67, 200), pygame.Color(255, 0, 0), "Assets/Recreativos.otf","Player waskilled by" + self.mainScene.objects.gameObject.getType())
self.gameOverScene.objects["pressStartDisplay"] = Text(
self.homeScene, Vector2(170, 300), Vector2(42, 200),
pygame.Color(255, 255, 255), "Assets/Recreativos.otf",
"PRESS SPACE BAR")
def update():
self.gameOverScene.objects["titleDisplay"].draw(self.screenRef)
self.gameOverScene.objects["pressStartDisplay"].draw(
self.screenRef)
# pygame.time.wait(500)
# self.screenRef.fill((0, 0, 0))
# titleDisplay.draw(self.screenRef)
# pygame.time.wait(500)
key = pygame.key.get_pressed()
if key[pygame.K_SPACE]:
self.sceneLoad(self.homeScene)
self.gameOverScene = Scene(objects, start, update)
def __init__(self, im, shape, faces):
self.pic = Pic(im, faces)
scene.background = [1, 1, 1]
self.scene = Scene(scene, self.pic)
scene.bind('keydown', self.keyInput)
Object(self.pic, self.scene, shape)
self.scene.background.visible = false
def GetScene(self):
scene = Scene()
self.dataSource.LoadPage()
upComingDateString = self.dataSource.GetUpcomingGameDate()
if self.shouldDisplayUpComingGame(upComingDateString):
scene.Home_Team_Logo_Image = self.dataSource.GetUpcomingGameHomeTeamLogo(
)
scene.Away_Team_Logo_Image = self.dataSource.GetUpcomingGameAwayTeamLogo(
)
split = upComingDateString.split(" ")
firstline = ""
secondline = ""
for line in split[:3]:
firstline += line + " "
for line in split[3:]:
secondline += line + " "
scene.AdditionalText.append(firstline)
scene.AdditionalText.append(secondline)
else:
scene.Home_Team_Logo_Image = self.dataSource.GetHomeTeamLogo()
scene.Away_Team_Logo_Image = self.dataSource.GetAwayTeamLogo()
scene.Home_Team_Score = self.dataSource.GetHomeTeamScore()
scene.Away_Team_Score = self.dataSource.GetAwayTeamScore()
scene.MainText = self.dataSource.GetInning()
scene.AdditionalText = self.dataSource.GetAdditionalText()
return scene
def __init__(self, frame_skip = 2):
height = 400
width = 600
goal_length = 300
self.scene = Scene(width, height)
self.frame_skip = frame_skip
self.ball_idle = 0
self.ball_idle_limit = 3
self.action_space = ActionSpace([Action.up, Action.down, Action.nomoveshoot])
self.box = Box(0, width, 0, height, 0)
self.goal1 = Goal(leftright_margin, height / 2, Way.left, goal_length)
self.player1 = Player(80, height / 2, player_radius, player_mass, \
player_restitution, player_damping, player_kick_damping, player_kick_power, Side.red)
self.ball = Ball(width - 100, height / 2, ball_radius, ball_mass, ball_restitution, ball_damping)
self.penalty_spot = Disc(self.ball.center.x, self.ball.center.y, 4, 0, 0, 0, Color.green).make_ghost().make_hollow()
# self.player_border_left = VerticalBorder(50, height / 2, height, 0, visible=True)
# self.player_border_right = VerticalBorder(100, height / 2, height, 0, visible=True)
self.scene.add_object(self.goal1)
self.scene.add_object(self.player1)
self.scene.add_object(self.ball)
self.scene.add_object(self.penalty_spot)
self.scene.add_object(self.box)
self.reset()
def test_Scene_set_shape_1():
x = randrange(-10e6, 10e6)
y = randrange(-10e6, 10e6)
s = randrange(1, 10e6)
m = randrange(1, 10e6)
v_x = randrange(-10e6, 10e6)
v_y = randrange(-10e6, 10e6)
length = randrange(10e4)
x_s = [randrange(-10e6, 10e6) for _ in range(length)]
y_s = [randrange(-10e6, 10e6) for _ in range(length)]
m_s = [randrange(1, 10e6) for _ in range(length)]
def F_x(t):
return randrange(-50, 50) * t + randrange(-50, 50)
def F_y(t):
return randrange(-50, 50) * t + randrange(-50, 50)
t = TriangleT(x, y, s, m)
b = BodyT(x_s, y_s, m_s)
scene = Scene(t, F_x, F_y, v_x, v_y)
scene.set_shape(b)
assert scene.get_shape() == b
def test_Scene_set_unbal_forces_2():
x = randrange(-10e6, 10e6)
y = randrange(-10e6, 10e6)
s = randrange(1, 10e6)
m = randrange(1, 10e6)
v_x = randrange(-10e6, 10e6)
v_y = randrange(-10e6, 10e6)
def F_x(t):
return randrange(-50, 50) * t + randrange(-50, 50)
def F_y(t):
return randrange(-50, 50) * t + randrange(-50, 50)
def new_F_x(t):
return 0
def new_F_y(t):
return 0
t = TriangleT(x, y, s, m)
scene = Scene(t, F_x, F_y, v_x, v_y)
scene.set_unbal_forces(new_F_x, new_F_y)
assert scene.get_unbal_forces() == (new_F_x, new_F_y)
def __init__(self):
self.input = Input()
pygame.init()
pygame.display.set_mode(
(Constants.SCREEN_WIDTH, Constants.SCREEN_HEIGHT))
pygame.display.set_caption("Twister!")
screen = pygame.display.get_surface()
self.scene = Scene(screen, self.input)
def workArea(screenRect):
wArea = Viewport()
wArea.setBackgroundBrush(QColor(PV['bgColor']))
wArea.resize(screenRect.width(), screenRect.height())
wArea.setTransformationAnchor(wArea.AnchorUnderMouse)
wAreaScene = Scene(QRectF(0.0, 0.0, 1240.0, 720.0), wArea)
wArea.setScene(wAreaScene)
return wArea
def main():
renderApp = QApplication(sys.argv)
renderView = RenderWindow()
redLambert = Material(diffuseColor=Vector(0.9, 0.1, 0.1))
blueLambert = Material(diffuseColor=Vector(0, 0, 0.9))
greenLambert = Material(diffuseColor=Vector(0.1, 0.9, 0.1))
whiteLambert = Material(diffuseColor=Vector(0.9, 0.9, 0.9))
yellowLambert = Material(diffuseColor=Vector(0.95, 0.4, 0.0))
lightBlueLambert = Material(diffuseColor=Vector(0.1, 0.5, 0.9))
mirror = Material(reflectionColor=Vector(1, 1, 1), reflectionWeight=1)
redMirror = Material(reflectionColor=Vector(0.9, 0, 0), reflectionWeight=1)
emissive = Material(emissionAmount=500)
glass = Material(refractionWeight=1, reflectionWeight=1)
sphere02 = Sphere(Vector(10, -20, -146), 30, material=mirror)
sphere03 = Sphere(Vector(-25, -35, -115), 15, material=redMirror)
sphere04 = Sphere(Vector(25, -35, -100), 15, material=glass)
plane01 = Plane(Vector(0, -50, -136),
Vector(0, 1, 0),
material=whiteLambert) # bottom wall
plane02 = Plane(Vector(-50, 0, -136),
Vector(1, 0, 0),
material=yellowLambert) # left wall
plane03 = Plane(Vector(0, 0, -186), Vector(0, 0, 1),
material=whiteLambert) # back wall
plane04 = Plane(Vector(50, 0, -136),
Vector(-1, 0, 0),
material=lightBlueLambert) # right wall
plane05 = Plane(Vector(0, 50, -136), Vector(0, -1, 0),
material=emissive) # top wall
light01 = DiskLight(Vector(0, 48, -136),
30,
normal=Vector(0, -1, 0),
samples=1,
isDoubleSided=True,
visible=True)
newScene = Scene({
"geometry": [
plane01, plane02, plane03, plane04, plane05, sphere02, sphere03,
sphere04
],
"light": [light01]
})
teleCam = Camera(Vector(0, 0, 130),
Vector(0, 0, 1),
80,
aperture=1.4,
focusDist=243,
filmFit="Horizontal")
renderView.startRender(newScene, teleCam)
sys.exit(renderApp.exec_())
def __init__(self, filename):
print('Parsing ' + filename)
self.Materials = dict() # used for storing ref to materials
self.Nodes = dict() # used for storing ref to nodes
self.NodeStack = []
self.scene = Scene()
xml = minidom.parse(filename)
self.parse(xml)
print('parsing done.')
def __init__(self, sim_dir, simulation_helper):
self.__sim_dir = sim_dir
self.__sim_helper = simulation_helper
self.__scene = Scene()
# calculated members
self.__input_conf_path = os.path.join(sim_dir, "Parameters", "input.conf")
f = open(self.__input_conf_path)
self.__input_conf = json.load(f)
f.close()
def __init__(self, debug_mode=True):
pyxel.init(200, 200, caption="ADV")
pyxel.mouse(visible=True)
pyxel.load("../asset.pyxres")
self.debug_mode = debug_mode
messages = self.get_messages()
self.scene = Scene(messages, debug_mode=self.debug_mode)
pyxel.run(self.update, self.draw)
def __init__(self, title, _width, _height):
pygame.init()
self.surface = pygame.display.set_mode((_width, _height))
pygame.display.set_caption(title)
self.clock = pygame.time.Clock()
self.fps = 60
self.running = True
self.resolution = 2
self.Scenes = Scene(self.surface, _width, _height)
def __init__(self):
# save current working directory
cwd = os.getcwd()
# Initialize the library
if not glfw.init():
return
# restore cwd
os.chdir(cwd)
# buffer hints
glfw.window_hint(glfw.DEPTH_BITS, 32)
# define desired frame rate
self.frame_rate = 100
# make a window
self.width, self.height = 640, 480
self.aspect = self.width / float(self.height)
self.window = glfw.create_window(self.width, self.height,
"2D Graphics", None, None)
if not self.window:
glfw.terminate()
return
# Make the window's context current
glfw.make_context_current(self.window)
# initialize GL
glViewport(0, 0, self.width, self.height)
glEnable(GL_DEPTH_TEST)
glClearColor(1.0, 1.0, 1.0, 1.0)
glMatrixMode(GL_PROJECTION)
glOrtho(-self.width / 2, self.width / 2, -self.height / 2,
self.height / 2, -2, 2)
glMatrixMode(GL_MODELVIEW)
# set window callbacks
glfw.set_mouse_button_callback(self.window, self.onMouseButton)
glfw.set_key_callback(self.window, self.onKeyboard)
glfw.set_window_size_callback(self.window, self.onSize)
# create 3D
self.scene = Scene(self.width, self.height)
# exit flag
self.exitNow = False
# animation flag
self.animation = True
def __init__(self, song, speed):
self.input = Input()
self.resource = Resource()
self.audio = Audio()
self.audio.pre_open()
pygame.init()
self.audio.open()
if song != None:
self.song = loadSong(self.resource, song)
else:
self.song = loadSong(self.resource, "gangnam")
self.clock = pygame.time.Clock()
pygame.display.set_mode(
(Constants.SCREEN_WIDTH, Constants.SCREEN_HEIGHT))
pygame.display.set_caption("DanceCV")
screen = pygame.display.get_surface()
if speed != None:
self.scene = Scene(self.resource, self.song, screen, self.input,
speed)
else:
self.scene = Scene(self.resource, self.song, screen, self.input, 2)
def test_Scene_sim_4():
x = randrange(-10e6, 10e6)
y = randrange(-10e6, 10e6)
s = randrange(1, 10e6)
m = randrange(1, 10e6)
v_x = randrange(-10e6, 10e6)
v_y = randrange(-10e6, 10e6)
t_final = randrange(1, 1000)
nsteps = randrange(100, 100000)
def F_x(t):
if t > 100:
return 0
else:
return t**2
def F_y(t):
if t < 40:
return -9.81 * m
else:
return 9.81 * m
t = TriangleT(x, y, s, m)
scene = Scene(t, F_x, F_y, v_x, v_y)
mass = scene.get_shape().mass()
def ode(w, t):
return w[2], w[3], F_x(t) / mass, F_y(t) / mass
cm_x = scene.get_shape().cm_x()
cm_y = scene.get_shape().cm_y()
results = scene.sim(t_final, nsteps)
t_result = results[0]
w_result = results[1]
v = scene.get_init_velo()
t_calc = [i * t_final / (nsteps - 1) for i in range(nsteps)]
w_calc = sp.odeint(ode, [cm_x, cm_y, v[0], v[1]], t_calc)
w_success = True
for i, j in zip(w_calc, w_result):
for a, b in zip(i, j):
if not math.isclose(a, b, rel_tol=0.0001):
w_success = False
assert t_result == t_calc and w_success
def __init__(self, screenRef):
self.screenRef = screenRef
self.mainScene = Scene()
self.homeScene = Scene()
self.gameOverScene = Scene()
self.bossScene = Scene()
self.winScene = Scene()
self.currScene = Scene()
def main():
''' Initialises the engine and loads the scene. For every frame it updates the
camera, updates the animated entity (which updates the animation),
renders the scene to the screen, and then updates the display. When the
display is closed the engine gets cleaned up.
'''
# texture_path = 'data/models/assimp/duck_sample.jpg'
# texture_path = 'data/shea-coulee.png'
texture_path = 'data/models/farm_boy/diffuse.png'
# model_path = 'data/models/duck/duck_triangles.dae'
# model_path = 'data/models/basic/cow.obj'
# model_path = 'data/models/regina/regina.dae'
model_path = 'data/models/farm_boy/model.dae'
engine = RenderEngine()
loader = OpenGLLoader()
model = ColladaParser(model_path)
raw_model: RawModel = loader.load_to_VAO(model)
textureID = loader.load_texture(texture_path)
animated_model = AnimatedModel(raw_model,
textureID,
root_joint=model.root_joint,
num_joints=16)
entity = Entity(animated_model,
position=[0, -5, -30],
rotation=[-90, 30, 0],
scale=1.0) # farm boy
# entity = Entity(animated_model, position=[0, -160, -600], rotation=[0, 0, 0], scale=1.0) # regina
camera = Camera(model.vertices.max())
scene = Scene(entity, camera)
animation = Animation(model.key_frames)
scene.entity.animator.set_animation(animation)
while not engine.window_should_close():
glfw.poll_events()
scene.camera.move()
scene.entity.increase_position([0, 0, 0])
# scene.entity.increase_rotation([0, 0.2, 0])
scene.entity.update()
engine.render_scene(scene)
engine.update()
loader.clean_up()
engine.close()
def __init__(self, mode):
if mode == 'local' or mode == 'Local' or mode =='LOCAL':
print("Running in a local video...")
self.input = Input()
self.mode = 1
elif mode == 'reatime' or mode == 'RealTime' or mode =='realTime' or mode =='Realtime' or mode =='REALTIME':
self.input = Input()
pygame.init()
pygame.display.set_mode((Constants.SCREEN_WIDTH, Constants.SCREEN_HEIGHT))
pygame.display.set_caption("PoseTracking!")
screen = pygame.display.get_surface()
self.scene = Scene(screen, self.input)
self.mode = 0
def __init__(self, random_start = True, step_limit = None, ball_idle_limit = None, state_output_mode = 'pixels', rendering = True, frame_skip=4):
self.action_space = ActionSpace([Action.up, Action.down, Action.forward, Action.backward, Action.nomoveshoot, Action.nomove])
self.step_limit = step_limit
self.ball_idle_limit = ball_idle_limit
self.state_output_mode = state_output_mode
self.rendering = rendering
self.ball_idle = 0
self.step_limit = step_limit
if state_output_mode == 'pixels': self.rendering = True
self.step_count = 0
self.random_start = random_start
self.frame_skip = frame_skip
self.scene = Scene(c_width, c_height)
self.scene.add_object(Box(5, c_width - 5, 5, c_height - 5, 0))
self.scene.add_object(Disc(c_width / 2, c_height / 2, middle_field_radius, 10, 1, 1, Color.white).make_ghost().make_hollow().set_outer_color(Color.border))
self.scene.add_object(VerticalBorder(c_width / 2, c_height / 2, c_height - 2 * topbottom_margin, None).make_ghost())
self.scene.add_object(HorizontalBorder(c_width / 2, topbottom_margin, c_width - 2 * leftright_margin, border_restitution).extend_to(Way.up).set_collision_mask([Ball]))
self.scene.add_object(HorizontalBorder(c_width / 2, c_height - topbottom_margin, c_width - 2 * leftright_margin, border_restitution).extend_to(Way.down).set_collision_mask([Ball]))
self.scene.add_object(VerticalBorder(leftright_margin, (c_height / 2 - goal_length / 2 + topbottom_margin) / 2, c_height / 2 - topbottom_margin - goal_length / 2, border_restitution).extend_to(Way.left).set_collision_mask([Ball]))
self.scene.add_object(VerticalBorder(leftright_margin, c_height - (c_height / 2 - goal_length / 2 + topbottom_margin) / 2, c_height / 2 - topbottom_margin - goal_length / 2, border_restitution).extend_to(Way.left).set_collision_mask([Ball]))
self.scene.add_object(VerticalBorder(c_width - leftright_margin, (c_height / 2 - goal_length / 2 + topbottom_margin) / 2, c_height / 2 - topbottom_margin - goal_length / 2, border_restitution).extend_to(Way.right).set_collision_mask([Ball]))
self.scene.add_object(VerticalBorder(c_width - leftright_margin, c_height - (c_height / 2 - goal_length / 2 + topbottom_margin) / 2, c_height / 2 - topbottom_margin - goal_length / 2, border_restitution).extend_to(Way.right).set_collision_mask([Ball]))
self.goal1 = Goal(leftright_margin, c_height / 2, Way.left, goal_length)
self.goal2 = Goal(c_width - leftright_margin, c_height / 2, Way.right, goal_length)
self.player1 = Player(120, c_height / 2, player_radius, player_mass, \
player_restitution, player_damping, player_kick_damping, player_kick_power, Side.red)
self.player2 = Player(c_width - 120, c_height / 2, player_radius, player_mass, \
player_restitution, player_damping, player_kick_damping, player_kick_power, Side.blue)
self.ball = Ball(c_width / 2, c_height / 2, ball_radius, ball_mass, ball_restitution, ball_damping)
self.scene.add_object(self.goal1)
self.scene.add_object(self.goal2)
self.scene.add_object(self.player1)
self.scene.add_object(self.player2)
self.scene.add_object(self.ball)
self.sequence1 = StateSequence([84, 84, 4])
self.sequence2 = StateSequence([84, 84, 4])
def initScene(self):
#Scene initialization
self.scene = Scene(self)
self.earth = self.scene.sys.earth.mod
self.moon = self.scene.sys.moon.mod
self.sun = self.scene.sys.sun.mod
self.home = self.scene.home
self.focus = self.scene.focus
#camera manip and mode
self.Camera = Camera(self)
#mouse and keyboard inputs
self.InputHandler = InputHandler(self)
#Interface
self.Interface = Interface(self)
def main():
renderApp = QApplication(sys.argv)
renderView = RenderWindow() #All setting loaded from json file
#--------------------Scene Modeling-------------------------------
#Materials--------------------------------------------
redLambert = Material(diffuseColor=Vector(0.9,0.1,0.1))
blueLambert = Material(diffuseColor=Vector(0,0,0.9))
greenLambert = Material(diffuseColor=Vector(0.1,0.9,0.1))
whiteLambert = Material(diffuseColor=Vector(0.9,0.9,0.9))
mirror = Material(reflectionColor=Vector(1,1,1),reflectionWeight=1)
redMirror = Material(reflectionColor=Vector(0.9,0,0),reflectionWeight=1)
emissive = Material(emissionAmount=500)
glass = Material(refractionWeight=1,reflectionWeight=1)
#Geometries----------------------------------------------
#important! This is a right handed coordinate system!
sphere01 = Sphere(Vector(-15,-30,-136),20,material=whiteLambert)
sphere02 = Sphere(Vector(10,-20,-146),30,material=mirror)
sphere03 = Sphere(Vector(-25,-35,-115),15,material=glass)
sphere04 = Sphere(Vector(25,-35,-100),15,material=whiteLambert)
#plane01 = Plane(Vector(0,-50,-136),Vector(0,1,0),material=whiteLambert) #bottom wall
#plane02 = Plane(Vector(-50,0,-136),Vector(1,0,0),material=redLambert) #left wall
#plane03 = Plane(Vector(0,0,-186),Vector(0,0,1),material=whiteLambert) #back wall
#plane04 = Plane(Vector(50,0,-136),Vector(-1,0,0),material=greenLambert) #right wall
#plane05 = Plane(Vector(0,50,-136),Vector(0,-1,0),material=whiteLambert) #top wall
tri01 = Triangle(Vector(30,40,-136),Vector(-10,20,-136),Vector(50,20,-156),material=glass)
tri02 = Triangle(Vector(30,40,-146),Vector(50,20,-166),Vector(-10,20,-146),material=glass)
disk01 = Disk(Vector(-30,30,-136),15,Vector(1,0,0),material=blueLambert)
quad01 = Quad(Vector(-50,-50,-186),Vector(-50,-50,-76),Vector(50,-50,-76),Vector(50,-50,-186),material=whiteLambert) #bottom wall
quad02 = Quad(Vector(-50,50,-76),Vector(-50,-50,-76),Vector(-50,-50,-186),Vector(-50,50,-186),material=redLambert) #left wall
quad03 = Quad(Vector(-50,50,-186),Vector(-50,-50,-186),Vector(50,-50,-186),Vector(50,50,-186),material=whiteLambert) #back wall
quad04 = Quad(Vector(50,50,-186),Vector(50,-50,-186),Vector(50,-50,-76),Vector(50,50,-76),material=greenLambert) #right wall
quad05 = Quad(Vector(-50,50,-76),Vector(-50,50,-186),Vector(50,50,-186),Vector(50,50,-76),material=emissive) #top wall
quad06 = Quad(Vector(-50,20,-76),Vector(-50,20,-186),Vector(30,20,-186),Vector(30,20,-76),material=whiteLambert) #top matte
#Lights-------------------------------------------------------
light01 = DiskLight(Vector(0,48,-136),30,normal=Vector(0,-1,0),samples=8,isDoubleSided=True,visible=True) #light source on the top
light02 = PointLight(Vector(-20,40,-120))
light03 = PointLight(Vector(20,30,-90))
newScene = Scene({"geometry":[quad01,quad02,quad03,quad04,quad05,sphere02,sphere03,sphere04],"light":[light01]})
cam = Camera(Vector(0,0,0),Vector(0,0,1),60)
renderView.startRender(newScene,cam)
sys.exit(renderApp.exec_())
def test_Scene_get_init_velo_1():
x = randrange(-10e6, 10e6)
y = randrange(-10e6, 10e6)
s = randrange(1, 10e6)
m = randrange(1, 10e6)
v_x = randrange(-10e6, 10e6)
v_y = randrange(-10e6, 10e6)
def F_x(t):
return randrange(-50, 50) * t + randrange(-50, 50)
def F_y(t):
return randrange(-50, 50) * t + randrange(-50, 50)
t = TriangleT(x, y, s, m)
assert Scene(t, F_x, F_y, v_x, v_y).get_init_velo() == (v_x, v_y)
def test_Scene_get_unbal_forces_2():
x = randrange(-10e6, 10e6)
y = randrange(-10e6, 10e6)
s = randrange(1, 10e6)
m = randrange(1, 10e6)
v_x = randrange(-10e6, 10e6)
v_y = randrange(-10e6, 10e6)
def F_x(t):
return 0
def F_y(t):
return 0
t = TriangleT(x, y, s, m)
assert Scene(t, F_x, F_y, v_x, v_y).get_unbal_forces() == (F_x, F_y)
def test_Scene_get_init_velo_2():
x = randrange(-10e6, 10e6)
y = randrange(-10e6, 10e6)
s = randrange(1, 10e6)
m = randrange(1, 10e6)
v_x = 0
v_y = 0
def F_x(t):
return 0
def F_y(t):
return 0
t = TriangleT(x, y, s, m)
assert Scene(t, F_x, F_y, v_x, v_y).get_init_velo() == (v_x, v_y)
