Example #1
0
    def build(self):
        layout = FloatLayout()

        # Create renderer.
        self.renderer = Renderer()

        # Create scene.
        scene = Scene()

        # Create default cube for scene.
        cube_geo = BoxGeometry(1, 1, 1)
        cube_mat = Material()
        self.cube = Mesh(geometry=cube_geo, material=cube_mat)
        self.cube.pos.z = -5

        # Create camera for scene.
        self.camera = PerspectiveCamera(
            fov=75,  # distance from the screen
            aspect=0,  # "screen" ratio
            near=1,  #nearest rendered point
            far=10  # farthest rendered point
        )

        # Start rendering the scene and camera.
        scene.add(self.cube)
        self.renderer.render(scene, self.camera)

        # Set renderer ratio if its size changes.
        # e.g. when added to parent
        self.renderer.bind(size=self._adjust_aspect)

        layout.add_widget(self.renderer)
        Clock.schedule_interval(self.rotate_cube, 0.01)
        return layout
Example #2
0
 def test_load_scene(self):
     scene = Scene()
     loader = WaveLoader()
     obj_path = os.path.join(this_dir, 'testnurbs.obj')
     objects = loader.load(obj_path)
     scene.add(*objects)
     self.assertEqual(len(scene.children), 4)
Example #3
0
    def build(self):
        root = FloatLayout()
        self.renderer = Renderer(shader_file='examples/simple.glsl')
        scene = Scene()
        camera = PerspectiveCamera(30, 1, 1, 1000)
        # load obj file
        loader = OBJLoader()
        obj_path = os.path.join(os.path.dirname(__file__), "cube.obj")
        obj = loader.load(obj_path)
        cube = obj.children[0]
        #scene.add(*obj.children)
        #for obj in scene.children:

        scene.add(cube)
        cube.pos.z = -20
        cube.rot.y = -45
        cube.rot.x = 45
        cube.material.specular = .35, .35, .35

        # set colors to 3d objects
        scene.children[0].material.color = 0., .7, 0.  # green
        scene.children[0].material.diffuse = 0., .7, 0.  # green

        self.renderer.render(scene, camera)
        root.add_widget(self.renderer)
        self.renderer.bind(size=self._adjust_aspect)
        return root
Example #4
0
    def build(self):
        self.renderer = Renderer(shader_file=shader_file)
        scene = Scene()
        camera = PerspectiveCamera(45, 1, 0.1, 2500)
        self.renderer.set_clear_color((.2, .2, .2, 1.))

        self.camera = camera
        self.renderer.main_light.intensity = 5000
        root = ObjectTrackball(camera, 10)

        geometry = PrismGeometry(radius=1, height=1, segments=64)
        material = Material(color=(1., 1., 1.),
                            diffuse=(1., 1., 1.),
                            specular=(.35, .35, .35),
                            shininess=200,
                            transparency=0.8)
        obj = Mesh(geometry, material)
        scene.add(obj)

        # create a grid on the xz plane
        geometry = GridGeometry(size=(30, 30), spacing=1)
        material = Material(color=(1., 1., 1.),
                            diffuse=(1., 1., 1.),
                            specular=(.35, .35, .35),
                            transparency=.1)
        lines = Lines(geometry, material)
        lines.rotation.x = 90
        scene.add(lines)

        self.renderer.render(scene, camera)
        self.renderer.main_light.intensity = 500

        root.add_widget(self.renderer)
        self.renderer.bind(size=self._adjust_aspect)
        return root
Example #5
0
    def build(self):
        layout = FloatLayout()

        # create renderer
        self.renderer = Renderer()

        # create scene
        scene = Scene()

        # create default cube for scene
        cube_geo = my.Msh('sphere.msh',name='zob')
        cube_mat = Material()
        self.cube = Mesh(geometry = cube_geo, material = cube_mat) # default pos == (0,0,0)
        self.cube.pos.z = 0

        # create camera for scene
        self.camera = PerspectiveCamera(
                fov = 75,    #distance from the screen
                aspect=0,    # "screen" ratio
                near=1,      # nearest rendered point
                far=100       # furthest rendered point
        )
        # start rendering the scene and camera
        scene.add(self.cube)
        self.renderer.render(scene,self.camera)

        # set renderer ratio if its size changes
        # e. g. when added to parent
        self.renderer.bind(size=self._adjust_aspect)

        layout.add_widget(self.renderer)
        Clock.schedule_interval(self.rotate_cube, .01)
        return layout
Example #6
0
    def _setup_object(self):

        self.clear_widgets()
        if is_ios():  # TODO enable this when iOS bug is resolved
            return

        shader_file = resource_find(os.path.join('resource', 'models', 'shaders.glsl'))
        obj_path = resource_find(self.model_path)

        self.renderer = Renderer(shader_file=shader_file)
        scene = Scene()
        camera = PerspectiveCamera(15, 1, 1, 1000)
        loader = OBJLoader()
        obj = loader.load(obj_path)

        scene.add(*obj.children)
        for obj in scene.children:
            obj.pos.x = self.position_x
            obj.pos.y = self.position_y
            obj.pos.z = self.position_z
            obj.rotation.x = self.rotation_x
            obj.rotation.y = self.rotation_y
            obj.rotation.z = self.rotation_z
            obj.material.specular = .85, .85, .85
            obj.material.color = 1.0, 1.0, 1.0
            obj.material.diffuse = 0.5, 0.5, 0.5
            obj.material.transparency = 1.0
            obj.material.intensity = 0.5
            self.imu_obj = obj
            # obj.material.shininess = 1.0

        self.renderer.render(scene, camera)
        self.renderer.bind(size=self._adjust_aspect)
        Clock.schedule_once(lambda dt: self.add_widget(self.renderer))
Example #7
0
    def build(self):
        root = FloatLayout()
        self.renderer = Renderer()
        scene = Scene()
        camera = PerspectiveCamera(30, 1, 1, 1000)
        # load obj file
        loader = OBJLoader()
        obj_path = os.path.join(os.path.dirname(__file__),
                                "examples/testnurbs.obj")
        obj = loader.load(obj_path)

        scene.add(*obj.children)
        for obj in scene.children:
            obj.pos.z = -20
            obj.material.specular = .35, .35, .35

        # set colors to 3d objects
        scene.children[0].material.color = 0., .7, 0.  # green
        scene.children[1].material.color = .7, 0., 0.  # red
        scene.children[2].material.color = 0., 0., .7  # blue
        scene.children[3].material.color = .7, .7, 0.  # yellow

        scene.children[0].material.diffuse = 0., .7, 0.  # green
        scene.children[1].material.diffuse = .7, 0., 0.  # red
        scene.children[2].material.diffuse = 0., 0., .7  # blue
        scene.children[3].material.diffuse = .7, .7, 0.  # yellow

        self.renderer.render(scene, camera)
        root.add_widget(self.renderer)
        self.renderer.bind(size=self._adjust_aspect)
        return root
Example #8
0
    def _setup_object(self):

        self.clear_widgets()
        if is_ios():  # TODO enable this when iOS bug is resolved
            return

        shader_file = resource_find(
            os.path.join('resource', 'models', 'shaders.glsl'))
        obj_path = resource_find(self.model_path)

        self.renderer = Renderer(shader_file=shader_file)
        scene = Scene()
        camera = PerspectiveCamera(15, 1, 1, 1000)
        loader = OBJLoader()
        obj = loader.load(obj_path)

        scene.add(*obj.children)
        for obj in scene.children:
            obj.pos.x = self.position_x
            obj.pos.y = self.position_y
            obj.pos.z = self.position_z
            obj.rotation.x = self.rotation_x
            obj.rotation.y = self.rotation_y
            obj.rotation.z = self.rotation_z
            obj.material.specular = .85, .85, .85
            obj.material.color = 1.0, 1.0, 1.0
            obj.material.diffuse = 0.5, 0.5, 0.5
            obj.material.transparency = 1.0
            obj.material.intensity = 0.5
            self.imu_obj = obj
            # obj.material.shininess = 1.0

        self.renderer.render(scene, camera)
        self.renderer.bind(size=self._adjust_aspect)
        Clock.schedule_once(lambda dt: self.add_widget(self.renderer))
Example #9
0
    def build(self):
        root = FloatLayout()
        self.renderer = Renderer(shader_file=shader_file)
        scene = Scene()
        camera = PerspectiveCamera(90, 1, 1, 10000)

        # loader = OBJMTLLoader()
        # obj = loader.load(obj_file, mtl_file)

        loader = OBJLoader()
        obj = loader.load(obj_file)

        self.renderer.main_light.pos = 1, 20, 50
        self.renderer.main_light.intensity = 1000

        camera.pos = 0, 0, 50
        camera.look_at((0, 0, 0))

        scene.add(*obj.children)
        for obj in scene.children:
            obj.pos.z = -0.
            obj.scale = 0.1, 0.1, 0.1

        self.renderer.render(scene, camera)
        self.orion = scene.children

        root.add_widget(self.renderer)
        self.renderer.bind(size=self._adjust_aspect)
        Clock.schedule_interval(self._rotate_obj, 1 / 20)
        # Clock.schedule_interval(self.print_color, 2)
        return root
Example #10
0
    def build(self):
        root = FloatLayout()
        self.renderer = Renderer()
        scene = Scene()
        camera = PerspectiveCamera(15, 1, 1, 1000)
        # load obj file
        loader = OBJLoader()
        obj_path = os.path.join(os.path.dirname(__file__), "./testnurbs.obj")
        obj = loader.load(obj_path)

        scene.add(*obj.children)
        for obj in scene.children:
            obj.pos.z = -20
            obj.material.specular = .35, .35, .35

        # set colors to 3d objects
        scene.children[0].material.color = 0., .7, 0.  # green
        scene.children[1].material.color = .7, 0., 0.  # red
        scene.children[2].material.color = 0., 0., .7  # blue
        scene.children[3].material.color = .7, .7, 0.  # yellow

        scene.children[0].material.diffuse = 0., .7, 0.  # green
        scene.children[1].material.diffuse = .7, 0., 0.  # red
        scene.children[2].material.diffuse = 0., 0., .7  # blue
        scene.children[3].material.diffuse = .7, .7, 0.  # yellow

        self.renderer.render(scene, camera)
        root.add_widget(self.renderer)
        self.renderer.bind(size=self._adjust_aspect)
        return root
Example #11
0
    def build(self):
        root = FloatLayout()

        self.renderer = Renderer(shader_file=shader_file)
        self.renderer.set_clear_color((.16, .30, .44, 1.))

        scene = Scene()
        # geometry = CylinderGeometry(0.5, 2)
        geometry = SphereGeometry(1)
        # geometry = BoxGeometry(1, 1, 1)
        material = Material(color=(0.3, 0., 0.3),
                            diffuse=(0.3, 0.3, 0.3),
                            specular=(0., 0., 0.))

        loader = STLLoader()
        obj = loader.load(stl_file, material)
        self.item = obj

        scene.add(self.item)

        self.cube = Mesh(geometry, material)
        self.item.pos.z = -1.5
        #self.cube.pos.z=-5
        camera = PerspectiveCamera(75, 0.3, 0.5, 1000)
        #camera = OrthographicCamera()

        #scene.add(self.cube)
        self.renderer.render(scene, camera)

        root.add_widget(self.renderer)
        Clock.schedule_interval(self._rotate_cube, 1 / 20)
        self.renderer.bind(size=self._adjust_aspect)

        return root
Example #12
0
    def build(self):
        root = FloatLayout()
        self.renderer = Renderer()
        scene = Scene()
        # load stl file
        mesh_a = mesh.Mesh.from_file('./meshes/base_link.STL')
        geo = STLGeometry(mesh_a)
        material = Material(color=(0., 0., 1.),
                            diffuse=(0., 0., 0.1),
                            specular=(.1, .1, .1))
        obj = Mesh(geo, material)

        # obj.position.z = 10
        self.my_obj = obj

        # load obj file
        # loader = OBJLoader()
        # obj = loader.load(obj_file)
        # self.monkey = obj.children[0]
        #
        scene.add(obj)
        camera = PerspectiveCamera(15, 1, 1, 1000)

        self.renderer.render(scene, camera)
        root.add_widget(self.renderer)
        Clock.schedule_interval(self._update_obj, 1. / 20)
        self.renderer.bind(size=self._adjust_aspect)
        return root
Example #13
0
class RS(Widget):
    def __init__(self, root, **kwargs):
        super().__init__(root)
        self.path = 'forge/embyr/'
        self.glSetup()
        self.camera = PerspectiveCamera(30, 1, 10, 1000)
        #self.transform = Transform()
        self.transform = Transform(pos=[8, 20, 8], lookvec=[40, 10, 40])

        pos = kwargs.pop('pos', None)
        size = kwargs.pop('size', None)
        #pos_hint = {'right':ww, 'bottom':hh}
        self.renderer = Renderer(shader_file=self.path + shaderf)
        #self.renderer.pos_hint = pos_hint

        self.scene = Scene()
        #self.renderer.size_hint = (0.5, 0.5)
        self.transform.size = (0, 0)
        self.transform.size_hint = (0, 0)

        self.renderer.render(self.scene, self.camera)
        self.renderer.bind(size=self._adjust_aspect)
        self.renderer.size_hint = size
        self.renderer.pos = pos

        #self.renderer.pos = (256, 256)

        self.root.add_widget(self.renderer)
        self.root.add_widget(self.transform)
        #self._disabled_count = 0
        #self.add_widget(self.renderer)
        #self.add_widget(self.transform)

    def glSetup(self):
        gl.glEnable(gl.GL_CULL_FACE)
        gl.glCullFace(gl.GL_BACK)

    def add(self, obj):
        self.scene.add(obj)
        self.renderer.add(obj)

    def update(self, dt):
        pos, vec = self.transform.update(dt)
        self.renderer.camera.look_at(vec)
        x, y, z = pos
        self.renderer.camera.pos = (-x, -y, -z)
        return vec

    def _adjust_aspect(self, inst, val):
        rsize = self.renderer.size
        aspect = rsize[0] / float(rsize[1])
        self.renderer.camera.aspect = aspect
Example #14
0
    def build(self):
        root = FloatLayout()
        self.renderer = Renderer(shader_file=shader_file)
        scene = Scene()
        # load obj file
        loader = OBJLoader()
        obj = loader.load(obj_file)
        self.monkey = obj.children[0]

        scene.add(*obj.children)
        camera = PerspectiveCamera(15, 1, 1, 1000)

        self.renderer.render(scene, camera)
        root.add_widget(self.renderer)
        Clock.schedule_interval(self._update_obj, 1. / 20)
        self.renderer.bind(size=self._adjust_aspect)
        return root
Example #15
0
    def build(self):
        root = FloatLayout()
        self.renderer = Renderer(shader_file=shader_file)
        scene = Scene()
        camera = PerspectiveCamera(15, 1, 1, 1000)
        # load obj file
        loader = OBJLoader()
        obj = loader.load(obj_path)

        scene.add(*obj.children)
        for obj in scene.children:
            obj.pos.z = -20

        self.renderer.render(scene, camera)
        root.add_widget(self.renderer)
        self.renderer.bind(size=self._adjust_aspect)
        return root
Example #16
0
    def build(self):
        root = FloatLayout()
        self.renderer = Renderer(shader_file=shader_file)
        scene = Scene()
        camera = PerspectiveCamera(15, 1, 1, 1000)
        # load obj file
        loader = OBJLoader()
        obj = loader.load(obj_path)

        scene.add(*obj.children)
        for obj in scene.children:
            obj.pos.z = -20

        self.renderer.render(scene, camera)
        root.add_widget(self.renderer)
        self.renderer.bind(size=self._adjust_aspect)
        return root
Example #17
0
    def build(self):
        root = FloatLayout()
        self.renderer = Renderer(shader_file=shader_file)
        scene = Scene()
        # load obj file
        loader = OBJLoader()
        obj = loader.load(obj_file)
        self.monkey = obj.children[0]

        scene.add(*obj.children)
        camera = PerspectiveCamera(15, 1, 1, 1000)

        self.renderer.render(scene, camera)
        root.add_widget(self.renderer)
        Clock.schedule_interval(self._update_obj, 1. / 20)
        self.renderer.bind(size=self._adjust_aspect)
        return root
Example #18
0
    def build(self):
        self.renderer = Renderer()
        scene = Scene()
        camera = PerspectiveCamera(15, 1, 1, 1000)
        loader = OBJLoader()
        obj = loader.load(obj_file)
        self.obj3d = obj
        self.camera = camera
        root = ObjectTrackball(camera, 1500)

        scene.add(obj)

        self.renderer.render(scene, camera)

        root.add_widget(self.renderer)
        self.renderer.bind(size=self._adjust_aspect)
        return root
Example #19
0
	def build(self):
		box= BoxLayout(orientation='vertical')
		layout = GridLayout(cols=5)
		layout.add_widget(Button(text='rotx',on_press=self.stop_rotx))
		layout.add_widget(Button(text='roty',on_press=self.stop_roty))
		layout.add_widget(Button(text='up',on_press=self.up))
		layout.add_widget(Button(text='down',on_press=self.dn))
		layout.add_widget(Button(text='xpos',on_press=self.xp))
		layout.add_widget(Button(text='xneg',on_press=self.xm))
		layout.add_widget(PongGame(text='keyboard'))
		box.add_widget(layout)
		root = FloatLayout()
		box.add_widget(root)
		self.renderer = Renderer(shader_file="simple.glsl")
		print "self.renderr"
		dir(self.renderer)
		
		# hintergrund 
		self.renderer. set_clear_color((0.9,1,1, 1));
		
		scene = Scene()
		camera = PerspectiveCamera(45, 1, 1, 1000)
		camera.position=(0,0,90)
		self.camera=camera
		#loader = OBJMTLLoader()
		#obj = loader.load("my_colors.obj", "my_colors.mtl")

		loader = OBJLoader()
		#obj = loader.load("my_colors.obj")
		#obj = loader.load("Cube.obj")
		#obj = loader.load("Fusion003.obj")
		obj = loader.load(file)

		scene.add(*obj.children)
		self.scene=scene
		for obj in scene.children:
			obj.pos.z = -6.

		self.renderer.render(scene, camera)
		self.orion = scene.children[0]

		root.add_widget(self.renderer)
		self.renderer.bind(size=self._adjust_aspect)
		Clock.schedule_interval(self._rotate_obj, 1 / 20)
		return box
Example #20
0
    def build(self):
        root = FloatLayout()
        self.renderer = Renderer()
        scene = Scene()
        camera = PerspectiveCamera(15, 1, 1, 1000)
        # load obj file
        loader = OBJMTLLoader()
        obj_path = os.path.join(os.path.dirname(__file__), "./testnurbs.obj")
        obj = loader.load(obj_path, "./testnurbs.mtl")

        scene.add(*obj.children)
        for obj in scene.children:
            obj.pos.z = -20

        self.renderer.render(scene, camera)
        root.add_widget(self.renderer)
        self.renderer.bind(size=self._adjust_aspect)
        return root
class glContext(BoxLayout):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        with self.canvas.before:
            # sfondo
            Color(0, 0, 0)
            self.background = Rectangle()
            # colore del modello
            Color(.9, .9, 1)

        # renderer
        self.renderer = Renderer(shader_file="glContext\\simple.glsl")

        # scene
        self.scene = Scene()

        # objects
        self.objects = Objects_list()
        self.object_father = self.objects.get()

        # adding objects to scene
        self.scene.add(self.object_father)

        # camera
        self.camera = PerspectiveCamera(
            fov=75,  # distance from the screen
            aspect=0,  # "screen" ratio
            near=1,  # nearest rendered point
            far=100  # farthest rendered point
        )

        # rendering
        self.renderer.render(self.scene, self.camera)
        self.renderer.bind(size=self._adjust_aspect)
        self.add_widget(self.renderer)

    def _adjust_aspect(self, *args):
        rsize = self.renderer.size
        aspect = rsize[0] / float(rsize[1])
        self.renderer.camera.aspect = aspect
        # adjust background
        self.background.pos = self.pos
        self.background.size = self.size
Example #22
0
    def build(self):
        root = FloatLayout()
        self.renderer = Renderer(shader_file=shader_file)
        scene = Scene()
        camera = PerspectiveCamera(15, 1, 1, 1000)
        loader = OBJMTLLoader()
        obj = loader.load(obj_file, mtl_file)

        scene.add(*obj.children)
        for obj in scene.children:
            obj.pos.z = -20.

        self.renderer.render(scene, camera)
        self.orion = scene.children[0]

        root.add_widget(self.renderer)
        self.renderer.bind(size=self._adjust_aspect)
        Clock.schedule_interval(self._rotate_obj, 1 / 20)
        return root
Example #23
0
    def build(self):
        layout = FloatLayout()

        # create renderer
        self.renderer = Renderer()

        # create scene
        scene = Scene()

        # create default cube for scene
        for i in range(1, 6):
            for j in range(1, 6):
                cube_geo = BoxGeometry(*[1] * 3)
                cube_mat = Material(color=(randint(0, 10) * .1,
                                           randint(0, 10) * .1,
                                           randint(0, 10) * .1))
                cube = Mesh(geometry=cube_geo,
                            material=cube_mat)  # default pos == (0, 0, 0)
                cube.pos.y = -0.5
                cube.pos.z = -i
                cube.pos.x = j - 3
                self.cubes.append(cube)
                scene.add(cube)

        # create camera for scene
        self.camera = PerspectiveCamera(
            fov=75,  # distance from the screen
            aspect=0,  # "screen" ratio
            near=1,  # nearest rendered point
            far=20  # farthest rendered point
        )

        # start rendering the scene and camera
        self.renderer.render(scene, self.camera)

        # set renderer ratio is its size changes
        # e.g. when added to parent
        self.renderer.bind(size=self._adjust_aspect)

        layout.add_widget(self.renderer)
        #Clock.schedule_interval(self.move_cubes, 1/60)
        Window.bind(on_key_down=self.handle_keys)
        return layout
Example #24
0
    def build(self):
        root = FloatLayout()
        self.renderer = Renderer(shader_file=shader_file)
        scene = Scene()
        camera = PerspectiveCamera(15, 1, 1, 1000)
        loader = OBJMTLLoader()
        obj = loader.load(obj_file, mtl_file)

        scene.add(*obj.children)
        for obj in scene.children:
            obj.pos.z = -20.

        self.renderer.render(scene, camera)
        self.orion = scene.children[0]

        root.add_widget(self.renderer)
        self.renderer.bind(size=self._adjust_aspect)
        Clock.schedule_interval(self._rotate_obj, 1 / 20)
        return root
Example #25
0
    def gsensor_init(self):
        pilot.send ("GSENSOR ON")
        self.renderer = Renderer(shader_file="3d/simple.glsl")
        scene = Scene()
        # load obj file
        loader = OBJLoader()
        obj = loader.load("3d/k9.obj")
        self.k9obj = obj.children[0]

        scene.add(*obj.children)
        camera = PerspectiveCamera(15, 1, 1, 1000)

        self.renderer.size_hint = (None,None)
        self.renderer.pos_hint = {'right' : .99, 'y': 0.4}
        self.renderer.render(scene, camera)
        self.renderer.size = (300,300)

        self.add_widget(self.renderer)
        Clock.schedule_interval(self.gsensor_3d_update, 1. / 20)
        self.renderer.bind(size=self.gsensor_3d_adjust_aspect)
Example #26
0
    def build(self):
        root = FloatLayout()

        self.renderer = Renderer()
        self.renderer.set_clear_color((.2, .2, .2, 1.))
        scene = Scene()
        geometry = BoxGeometry(1, 1, 1)
        material = Material(color=(0., 0., 1.), diffuse=(1., 1., 0.),
                            specular=(.35, .35, .35))
        self.cube = Mesh(geometry, material)
        self.cube.pos.z = -5
        camera = PerspectiveCamera(75, 0.3, 1, 1000)

        scene.add(self.cube)
        self.renderer.render(scene, camera)

        root.add_widget(self.renderer)
        Clock.schedule_interval(self._rotate_cube, 1 / 20)
        self.renderer.bind(size=self._adjust_aspect)

        return root
Example #27
0
    def build(self):
        self.look_at = Vector3(0, 0, -1)
        root = FloatLayout()
        self.renderer = Renderer(shader_file=shader_file)
        scene = Scene()
        self.camera = PerspectiveCamera(75, 1, 1, 1000)
        self.camera.pos.z = 5
        loader = OBJMTLLoader()
        obj = loader.load(obj_file, mtl_file)
        self._keyboard = Window.request_keyboard(self._keyboard_closed, self)
        self._keyboard.bind(on_key_down=self._on_keyboard_down)

        scene.add(*obj.children)

        self.renderer.render(scene, self.camera)
        self.orion = scene.children[0]

        root.add_widget(self.renderer)
        self.renderer.bind(size=self._adjust_aspect)
        Clock.schedule_interval(self._rotate_obj, 1 / 20)
        return root
Example #28
0
    def build(self):
        self.look_at = Vector3(0, 0, -1)
        root = FloatLayout()
        self.renderer = Renderer(shader_file=shader_file)
        scene = Scene()
        self.camera = PerspectiveCamera(75, 1, 1, 1000)
        self.camera.pos.z = 5
        loader = OBJMTLLoader()
        obj = loader.load(obj_file, mtl_file)
        self._keyboard = Window.request_keyboard(self._keyboard_closed, self)
        self._keyboard.bind(on_key_down=self._on_keyboard_down)

        scene.add(*obj.children)

        self.renderer.render(scene, self.camera)
        self.orion = scene.children[0]

        root.add_widget(self.renderer)
        self.renderer.bind(size=self._adjust_aspect)
        Clock.schedule_interval(self._rotate_obj, 1 / 20)
        return root
Example #29
0
    def build(self):
        root = FloatLayout()

        self.renderer = Renderer()
        self.renderer.set_clear_color((.2, .2, .2, 1.))
        scene = Scene()
        geometry = BoxGeometry(1, 1, 1)
        material = Material(color=(0., 1., 0.),
                            diffuse=(0., 1., 0.),
                            specular=(.35, .35, .35))
        self.cube = Mesh(geometry, material)
        self.cube.pos.z = -3
        camera = PerspectiveCamera(75, 0.3, 1, 1000)

        scene.add(self.cube)
        self.renderer.render(scene, camera)

        root.add_widget(self.renderer)
        Clock.schedule_interval(self._rotate_cube, 1 / 20)
        self.renderer.bind(size=self._adjust_aspect)

        return root
Example #30
0
    def build(self):
        self.renderer = Renderer()
        scene = Scene()
        camera = PerspectiveCamera(45, 1, 0.1, 2500)
        self.renderer.set_clear_color((.2, .2, .2, 1.))

        self.camera = camera
        root = ObjectTrackball(camera, 10)

        # add a cube to the environment as an example
        # NOTE: the grid will be rendered without transparency if it
        # is added before the box.
        # This may be because the shader is not called until a 'triangles' mesh is
        # rendered? Hence the Fragment Shader has not yet been called?
        geometry = BoxGeometry(1, 1, 1)
        material = Material(color=(1., 1., 1.),
                            diffuse=(1., 1., 1.),
                            specular=(.35, .35, .35))
        obj = Mesh(geometry, material)
        scene.add(obj)

        # create a grid on the xz plane
        geometry = GridGeometry(size=(30, 30), spacing=1)
        material = Material(color=(1., 1., 1.),
                            diffuse=(1., 1., 1.),
                            specular=(.35, .35, .35),
                            transparency=.1)
        lines = Lines(geometry, material)
        lines.rotation.x = 90
        scene.add(lines)

        self.renderer.render(scene, camera)
        self.renderer.main_light.intensity = 500

        root.add_widget(self.renderer)
        self.renderer.bind(size=self._adjust_aspect)
        return root
Example #31
0
class My3DScreen(Screen):
    layout = ObjectProperty()

    def _adjust_aspect(self, *args):
        rsize = self.renderer.size
        aspect = rsize[0] / float(rsize[1])
        self.renderer.camera.aspect = aspect

    def __init__(self, **kwargs):
        super(My3DScreen, self).__init__(**kwargs)

        self.look_at = Vector3(0, 0, -1)

        self._keyboard = Window.request_keyboard(self._keyboard_closed, self)
        self._keyboard.bind(on_key_down=self._on_keyboard_down)

        #root = FloatLayout()
        self.camera = PerspectiveCamera(75, 0.3, 1, 1000)
        self.radius = 10
        self.phi = 90
        self.theta = 0
        self._touches = []
        self.camera.pos.z = self.radius
        self.camera.look_at((0, 0, 0))
        #root = self.layout

    def make_3d(self, clock=None):

        #self.root = FloatLayout()
        self.renderer = Renderer()
        self.renderer.set_clear_color((.2, .2, .2, 1.))

        self.scene = Scene()

        #geometry = BoxGeometry(0.5, 0.5, 0.5)
        geometry = SphereGeometry(0.1)
        material = Material(color=(0., 0., 1.),
                            diffuse=(1., 1., 0.),
                            specular=(.35, .35, .35))
        """
        a = 5
        liste = []
        i = 0
        for z in range(-5, -35, -1):
            for x in range(-5, 5):
                liste.append(Mesh(geometry, material))
                liste[-1].pos.x = x
                liste[-1].pos.y = -i
                liste[-1].pos.z = z
                print(x, -i, z)
                self.scene.add(liste[-1])
            i+=1
        """
        #!erster test für errecnete Daten
        liste = []
        for z in range(0, int(Global.config["maxy"])):
            #for z in range(0, 10):
            #i = 0
            test = calculationClass.find_mistakes_along_x_axis(z)
            #print(test)
            for x, y, rad in calculationClass.find_mistakes_along_x_axis(z):
                #for x, y in [[1, 2], [2, 0], [2.314, 5], [3, 0], [3.123, 4]]:
                #for x, y in [[1, 2], [2, 0], [3, 0]]:
                #for x in [8.06158101842821, 4.06158101842821, 0.09813725490196079]:
                #for x in test[:][0]:
                #for line in test[:10]:
                #x = line[0]
                x = float(x)
                y = float(y)
                #x = 8.06158101842821
                #new_list.append([x, y, z, rad])
                rad = 1
                #y = 0
                z += 5
                liste.append(Mesh(geometry, material))
                #liste[-1].pos.x = x - 8
                liste[-1].pos.x = -z
                liste[-1].pos.y = y
                liste[-1].pos.z = x
                #print(x, y, z)
                self.scene.add(liste[-1])
                #i += 1

        self.renderer.render(self.scene, self.camera)

        self.renderer.bind(size=self._adjust_aspect)

        self.layout.add_widget(self.renderer)

        print(liste[0])
        print(liste[0].pos)
        #self.look_at = liste[0].pos

        #self.look_at.x = liste[0][0]
        #self.look_at.y = liste[0][1]
        #self.look_at.z = liste[0][2]
        #self.camera.look_at(self.look_at)
        #test = (liste[0][0], liste[0][1], liste[0][2])
        #a = tuple(liste[0].pos)
        #print(a)
        #self.camera.look_at(a)
        #self.look_at.x = liste[0].pos.x
        #self.look_at.y = liste[0].pos.y
        #self.look_at.z = liste[0].pos.z
        self.look_at = Vector3(0, 0, -1)

        #self.camera.look_at(self.look_at)

        #self.add_widget(self.root)
        print("here")

    def _keyboard_closed(self):
        self._keyboard.unbind(on_key_down=self._on_keyboard_down)
        self._keyboard = None

    def _on_keyboard_down(self, keyboard, keycode, text, modifiers):
        if keycode[1] == 'w':
            self.camera.pos.y += 0.2
            #self.look_at.y += 0.2
        elif keycode[1] == 's':
            self.camera.pos.y -= 0.2
            #self.look_at.y -= 0.2
        elif keycode[1] == 'a':
            self.camera.pos.x -= 0.2
            #self.look_at.x -= 0.2
        elif keycode[1] == 'd':
            self.camera.pos.x += 0.2
            #self.look_at.x += 0.2
        elif keycode[1] == '-':
            self.camera.pos.z += 0.2
            #self.look_at.z += 0.2
        elif keycode[1] == '+':
            self.camera.pos.z -= 0.2
            #self.look_at.z -= 0.2

        elif keycode[1] == 'up':
            self.look_at.y += 0.2
        elif keycode[1] == 'down':
            self.look_at.y -= 0.2
        elif keycode[1] == 'right':
            self.look_at.x += 0.2
        elif keycode[1] == 'left':
            self.look_at.x -= 0.2

        elif keycode[1] == "q":
            self.camera.rotation.y += 1

        self.camera.look_at(self.look_at)

    def define_rotate_angle(self, touch):
        theta_angle = (touch.dx / self.width) * -360
        phi_angle = -1 * (touch.dy / self.height) * 360
        return phi_angle, theta_angle

    def on_touch_down(self, touch):
        if touch.is_mouse_scrolling:
            if touch.button == 'scrolldown':
                #self.look_at -= 0.2
                self.camera.pos -= 0.2
            elif touch.button == 'scrollup':
                #self.look_at += 0.2
                self.camera.pos += 0.2

        touch.grab(self)
        self._touches.append(touch)

        self.camera.look_at(self.look_at)

    def on_touch_up(self, touch):
        touch.ungrab(self)
        self._touches.remove(touch)

    def on_touch_move(self, touch):
        if touch in self._touches and touch.grab_current == self:
            if len(self._touches) == 1:
                self.do_rotate(touch)
            elif len(self._touches) == 2:
                pass

    def do_rotate(self, touch):
        d_phi, d_theta = self.define_rotate_angle(touch)
        self.phi += d_phi
        self.theta += d_theta

        _phi = math.radians(self.phi)
        _theta = math.radians(self.theta)
        z = self.radius * math.cos(_theta) * math.sin(_phi)
        x = self.radius * math.sin(_theta) * math.sin(_phi)
        y = self.radius * math.cos(_phi)
        self.camera.pos = x, y, z
        self.camera.look_at((0, 0, 0))

    def on_enter(self, *args):
        super(My3DScreen, self).on_enter(*args)
        #self.remove_widget(self.renderer)
        #mat = Material()
        #box = BoxGeometry(0.5, 0.5, 0.5)
        #cube = Mesh(box, mat)
        #cube.pos.z = -4
        #self.scene.add(cube)
        Clock.schedule_once(self.make_3d)
Example #32
0
    def build(self):
        layout = GridLayout(cols=3)

        # create renderer
        self.renderer = Renderer(size_hint=(5, 5))
        self.renderer.set_clear_color((0.1, 0.1, 0.1, 1))  # rgba

        # create scene
        scene = Scene()
        self.cubes = []

        # create cubes for scene
        #
        # default pure green cube
        cube_geo = BoxGeometry(.3, .3, .3)
        cube_mat = Material(color=(0, 0.5, 0)  # base color
                            )
        self.cubes.append(Mesh(geometry=cube_geo,
                               material=cube_mat))  # default pos == (0, 0, 0)
        self.cubes[0].pos.z = -5
        self.cubes[0].pos.x = 1
        self.cubes[0].pos.y = 0.8
        self.cubes[0].rotation.x = 45

        # black cube, red shadow, half-transparent
        cube_geo = BoxGeometry(.3, .3, .3)
        cube_mat = Material(
            transparency=0.5,
            color=(0, 0, 0),  # base color
            diffuse=(10, 0, 0),  # color of "shadows"
            specular=(0, 0, 0)  # mirror-like reflections
        )
        self.cubes.append(Mesh(geometry=cube_geo,
                               material=cube_mat))  # default pos == (0, 0, 0)
        self.cubes[1].pos.z = -5
        self.cubes[1].pos.x = -1
        self.cubes[1].pos.y = 0.8
        self.cubes[1].rotation.y = 45

        # default pure green cube with red reflections
        cube_geo = BoxGeometry(.3, .3, .3)
        cube_mat = Material(
            transparency=1,
            color=(0, 0.5, 0),  # base color
            diffuse=(0, 0, 0),  # color of "shadows"
            specular=(10, 0, 0)  # mirror-like reflections
        )
        self.cubes.append(Mesh(geometry=cube_geo,
                               material=cube_mat))  # default pos == (0, 0, 0)
        self.cubes[2].pos.z = -5
        self.cubes[2].pos.x = 1
        self.cubes[2].pos.y = -0.8
        self.cubes[2].rotation.z = 45

        # something.obj from Blender
        loader = OBJLoader()
        self.cubes.extend(
            loader.load(join(FOLDER, 'models', 'something.obj')).children)
        self.cubes[3].pos.z = -5
        self.cubes[3].pos.x = -1
        self.cubes[3].pos.y = -0.8
        self.cubes[3].rotation.x = 45
        self.cubes[3].material.color = (0.1, 0.4, 0.1)
        self.cubes[3].material.texture_ratio = 0.0

        # cube object from Blender
        loader = OBJLoader()
        self.main_cube = loader.load(join(FOLDER, 'models', 'cube.obj'))
        self.main_cube.rotation.x = 45
        self.main_cube.rotation.y = 45
        self.main_cube.pos.z = -5
        self.main_cube.scale = (0.5, 0.5, 0.5)
        scene.add(self.main_cube)

        planes = [((0, 0, -10), (0, 0, 0)), ((-10, 0, 0), (0, -90, 0)),
                  ((10, 0, 0), (0, 90, 0)),
                  ((0, 0, 10), (0, 180, 0))]  # position and rotation changes
        for plane in planes:
            geo = BoxGeometry(5, 5, .1)
            mat = Material(color=(1, 1, 1))
            mesh = Mesh(geometry=geo, material=mat)
            mesh.pos.x += plane[0][0]
            mesh.pos.y += plane[0][1]
            mesh.pos.z += plane[0][2]
            mesh.rot.x += plane[1][0]
            mesh.rot.y += plane[1][1]
            mesh.rot.z += plane[1][2]
            scene.add(mesh)

        # create camera for scene
        self.camera = PerspectiveCamera(
            fov=75,  # distance from the screen
            aspect=0,  # "screen" ratio
            near=.1,  # nearest rendered point
            far=1000  # farthest rendered point
        )

        # start rendering the scene and camera
        for cube in self.cubes:
            scene.add(cube)
        self.renderer.render(scene, self.camera)

        # set renderer ratio is its size changes
        # e.g. when added to parent
        self.renderer.bind(size=self._adjust_aspect)

        layout.add_widget(Factory.CamRot())
        layout.add_widget(Factory.LightPanel())
        layout.add_widget(Factory.CamStrafe())
        layout.add_widget(Widget())

        layout.add_widget(self.renderer)

        layout.add_widget(Label(text='+\n\nY\n\n-'))
        layout.add_widget(Factory.CamNav())
        layout.add_widget(Label(text='-      X      +'))
        layout.add_widget(Factory.ObjNav())

        Clock.schedule_interval(self.rotate_cube, .01)
        Clock.schedule_interval(self.scale_cube, 1)

        # keyboard listener
        Listener()
        return layout
Example #33
0
class SceneApp(App):
    joints = []

    def build(self):
        root = BaseBox()

        self.renderer = Renderer(shader_file=shader_file)
        self.renderer.set_clear_color((.2, .2, .2, 1.))
        self.scene = Scene()

        self.manipulator = self.construct_manipulator()

        camera = PerspectiveCamera(75, 0.01, 0.01, 1500)
        trackball = ObjectTrackball(camera, 2)

        self.scene.add(self.manipulator)
        self.renderer.render(self.scene, camera)

        self.renderer.main_light.intensity = 3000

        trackball.add_widget(self.renderer)
        root.add_widget(trackball)

        self.renderer.bind(size=self._adjust_aspect)

        root.joints = self.joints
        root.renderer = self.renderer
        return root

    def _adjust_aspect(self, inst, val):
        rsize = self.renderer.size
        aspect = rsize[0] / float(rsize[1])
        self.renderer.camera.aspect = aspect

    def _rotate_cube(self, dt):
        self.axis_e.rotation.x += 0
        self.axis_e.rotation.y += 1
        self.axis_e.rotation.z += 1

    def _rotate_rect(self, dt):
        self.axis_d.rotation.x += 0.5

    def construct_manipulator(self):
        material = Material(color=(0., 0., 1.),
                            diffuse=(1., 1., 0.),
                            specular=(.35, .35, .35))

        # axis a
        # one jaw
        axis_a_dimensions = JOINT_SIZE_A[0], JOINT_SIZE_A[2], JOINT_SIZE_A[1]
        axis_a_geometry = create_joint_rectangle(axis_a_dimensions[0],
                                                 axis_a_dimensions[1],
                                                 axis_a_dimensions[2])
        axis_a_left_mesh = Mesh(axis_a_geometry, material)
        axis_a_right_mesh = Mesh(axis_a_geometry, material)
        self.joints.append(axis_a_left_mesh)
        self.joints.append(axis_a_right_mesh)

        # axis b wrist
        axis_b_dimensions = get_joint_hypo_length(
            JOINT_OFFSET_A_1), JOINT_SIZE_B[1], JOINT_SIZE_B[2]
        axis_b_geometry = create_joint_rectangle(axis_b_dimensions[0],
                                                 axis_b_dimensions[1],
                                                 axis_b_dimensions[2])
        material = Material(color=(1., 0., 0.),
                            diffuse=(1., 0., 0.),
                            specular=(.35, .35, .35))
        axis_b_mesh = Mesh(axis_b_geometry, material)
        self.joints.append(axis_b_mesh)

        axis_b_mesh.add(axis_a_left_mesh)
        axis_a_left_mesh.pos.x = axis_b_dimensions[0]
        axis_a_left_mesh.pos.z = axis_b_dimensions[2] / 2

        axis_b_mesh.add(axis_a_right_mesh)
        axis_a_right_mesh.pos.x = axis_b_dimensions[0]
        axis_a_right_mesh.pos.z = -axis_b_dimensions[2] / 2

        # axis c bend
        axis_c_dimensions = get_joint_hypo_length(
            JOINT_OFFSET_B), JOINT_SIZE_C[1], JOINT_SIZE_C[2]
        axis_c_geometry = create_joint_rectangle(axis_c_dimensions[0],
                                                 axis_c_dimensions[1],
                                                 axis_c_dimensions[2])
        material = Material(color=(1., 1., 0.),
                            diffuse=(1., 1., 0.),
                            specular=(.35, .35, .35))
        axis_c_mesh = Mesh(axis_c_geometry, material)
        self.joints.append(axis_c_mesh)

        axis_c_mesh.add(axis_b_mesh)
        axis_b_mesh.pos.x = axis_c_dimensions[0]

        # axis d bend
        axis_d_dimensions = get_joint_hypo_length(
            JOINT_OFFSET_C), JOINT_SIZE_D[1], JOINT_SIZE_D[2]
        axis_d_geometry = create_joint_rectangle(axis_d_dimensions[0],
                                                 axis_d_dimensions[1],
                                                 axis_d_dimensions[2])
        material = Material(color=(1., 0., 1.),
                            diffuse=(1., 0., 1.),
                            specular=(.35, .35, .35))
        axis_d_mesh = Mesh(axis_d_geometry, material)
        self.joints.append(axis_d_mesh)

        axis_d_mesh.add(axis_c_mesh)
        axis_c_mesh.pos.x = axis_d_dimensions[0]

        # axis e mesh
        axis_e_dimensions = get_joint_hypo_length(
            JOINT_OFFSET_D), JOINT_SIZE_E[1], JOINT_SIZE_E[2]
        axis_e_geometry = create_joint_rectangle(axis_e_dimensions[0],
                                                 axis_e_dimensions[1],
                                                 axis_e_dimensions[2])
        material = Material(color=(0., 1., 0.),
                            diffuse=(0., 1., 0.),
                            specular=(.35, .35, .35))
        axis_e_mesh = Mesh(axis_e_geometry, material)
        self.joints.append(axis_e_mesh)

        axis_e_mesh.add(axis_d_mesh)
        axis_d_mesh.pos.x = axis_e_dimensions[0]

        # axis f
        axis_f_dimensions = get_joint_hypo_length(
            JOINT_OFFSET_E), JOINT_SIZE_F[1], JOINT_SIZE_F[2]
        axis_f_geometry = create_joint_rectangle(axis_f_dimensions[0],
                                                 axis_f_dimensions[1],
                                                 axis_f_dimensions[2])
        material = Material(color=(0., 1., 1.),
                            diffuse=(0., 1., 1.),
                            specular=(.35, .35, .35))
        axis_f_mesh = Mesh(axis_f_geometry, material)
        self.joints.append(axis_f_mesh)

        axis_f_mesh.add(axis_e_mesh)
        axis_e_mesh.pos.x = axis_f_dimensions[0]

        # axis_g
        axis_g_dimensions = get_joint_hypo_length(
            JOINT_OFFSET_F), JOINT_SIZE_G[1], JOINT_SIZE_G[2]
        axis_g_geometry = create_joint_rectangle(axis_g_dimensions[0],
                                                 axis_g_dimensions[1],
                                                 axis_g_dimensions[2])
        material = Material(color=(1., .4, .1),
                            diffuse=(1., .4, .1),
                            specular=(.35, .35, .35))
        axis_g_mesh = Mesh(axis_g_geometry, material)
        self.joints.append(axis_g_mesh)

        axis_g_mesh.add(axis_f_mesh)
        axis_f_mesh.pos.x = axis_g_dimensions[0]
        axis_f_mesh.rotation.z = -90

        # base
        base_dimensions = 0.05, axis_b_dimensions[1], axis_b_dimensions[2]
        base_geometry = create_joint_rectangle(base_dimensions[0],
                                               base_dimensions[1],
                                               base_dimensions[2])
        material = Material(color=(0., 1., 1.),
                            diffuse=(0., 1., 1.),
                            specular=(.35, .35, .35))
        base_mesh = Mesh(base_geometry, material)
        self.joints.append(base_mesh)

        base_mesh.add(axis_g_mesh)
        base_mesh.rotation.z = 90

        axis_g_mesh.pos.x = base_dimensions[0]
        axis_g_mesh.rotation.z = -90

        return base_mesh
Example #34
0
class MyApp(Application):
    def __init__(self, size):
        super().__init__(size)
        self.title = 'Projekt: Godsword'
        self.pan = Pan()
        self.rotate = Rotate()
        self.zoom = Zoom()

        self.loader = OBJMTLLoader()
        self.blocks = dict(
            (mat.value.tex, mat.value) for mat in enums.Material)

        self.vec = np.array([0, 0, 1])
        self.t = 0
        '''
        super(Mesh, self).__init__(**kw)
        self.geometry = geometry
        self.material = material
        self.mtl = self.material  # shortcut for material property
        self.vertex_format = kw.pop("vertex_format", DEFAULT_VERTEX_FORMAT)
        self.create_mesh()
        '''

    def cube(self, tile):
        DEFAULT_VERTEX_FORMAT = [(b'v_tc0', 2, 'float'),
                                 (b'v_normal', 3, 'float'),
                                 (b'v_pos', 3, 'float')]

        obj = self.blocks[tile].obj
        T()
        obj = pywave.Wavefront('tex/block.obj', collect_faces=True)
        material = obj.materials['grass']
        cube = obj.meshes['Cube']

        vertices = obj.vertices
        faces = cube.faces
        grass = obj.materials['grass']
        dirt = obj.materials['dirt']
        vertices = grass.vertices + dirt.vertices
        #indices  = np.array(faces).ravel().tolist()
        indices = np.arange(36).astype(int).tolist()
        #vertices = np.array(vertices).ravel().tolist()

        tex = Image('tex/grass.png').texture
        mat = Material(tex)
        kw = {
            "vertices": vertices,
            "indices": indices,
            "fmt": DEFAULT_VERTEX_FORMAT,
            "mode": "triangles",
            'texture': tex
        }
        #if self.material.map:
        #     kw["texture"] = self.material.map

        mesh = KivyMesh(**kw)

        class Meshy(Object3D):
            def __init__(self, mesh, material):
                super().__init__()
                self._mesh = mesh
                self.material = material
                self.mtl = material
                self.vertex_format = DEFAULT_VERTEX_FORMAT

        cube = Meshy(mesh, tex)

        #cube.material = orig.material
        #cube.geometry = orig.geometry
        orig._mesh = cube._mesh
        orig.material = mat
        cube = orig

        #cube = kivy3.Mesh([], material)
        if tile == 'lava':
            cube.pos.y = -0.5
        elif tile == 'stone':
            cube.pos.y = 1
        elif tile == 'grass':
            pass
        elif tile == 'forest':
            pass
        elif tile == 'water':
            cube.pos.y = -0.33

        #cube.material.color = 0., .7, 0.  # green
        #cube.material.diffuse = 0., .7, 0.  # green
        return cube

    def makeMap(self):
        tiles = loadTiled('../Projekt-Godsword/resource/maps/map1/map.tmx')
        n, sz = tiles.shape[0], 1
        for i in range(n):
            for j in range(n):
                tile = tiles[i, j]
                cube = self.cube(tile)
                self.scene.add(cube)

                #NEVER set cube.pos directly.
                #It won't do anything
                cube.pos.x = i - n // 2 + sz // 2
                cube.pos.z = j - n // 2 + sz // 2

    def glSetup(self):
        #gl.glEnable(gl.GL_CULL_FACE)
        #gl.glCullFace(gl.GL_BACK)
        pass

    def build(self):
        camera = PerspectiveCamera(30, 1, 1, 1000)
        self.renderer = Renderer()
        self.scene = Scene()
        root = FloatLayout()

        obj = self.loader.load('tex/nn.obj', 'tex/nn.mtl')
        self.scene.add(obj)
        obj.pos.y = 1
        self.makeMap()

        self.renderer.render(self.scene, camera)
        self.renderer.camera.look_at(0, 0, 0)
        root.add_widget(self.renderer)
        root.add_widget(self.pan)
        root.add_widget(self.rotate)
        root.add_widget(self.zoom)
        self.renderer.bind(size=self._adjust_aspect)
        self.loop(self.update)
        return root

    def update(self, t):
        print(1 / t)
        self.t += t
        rad = 80
        sz = 500
        pi = 3.14159265

        r = self.rotate
        x = r.x + r.xVol
        y = r.y + r.yVol

        x = x / sz
        y = y / sz
        yclip = np.clip(y, -pi / 2, 0)

        xz_x = np.cos(x)
        xz_z = np.sin(x)

        yz_y = np.cos(yclip)
        yz_z = np.sin(yclip)

        xz = np.array([[xz_x, 0, -xz_z], [0, 1, 0], [xz_z, 0, xz_x]])

        yz = np.array([[1, 0, 0], [0, yz_y, -yz_z], [0, yz_z, yz_y]])

        #Find cylindrical xz plane rotation
        rot_xz = rad * np.dot(xz, self.vec)
        xx, _, zz = rot_xz
        xz_vec = np.array([xx, 0, zz])

        #Find spherical yz plane rotation
        _, yy, zn = np.dot(yz, self.vec)
        xz_norm = zn

        #For x, z: shrink to position of spherical rotation
        #For y: use height from spherical rotation
        vec = np.array([xx * xz_norm, -rad * yy, zz * xz_norm])

        #Zoom factor
        zoom = Zoom.clipZoom(self.zoom.zoom)
        vec = vec * zoom

        p = self.pan
        x = p.x + p.xVol
        z = p.y + p.yVol

        x = 10 * x / sz
        z = -10 * z / sz

        #Horizontal component
        unit_y = np.array([0, 1, 0])
        xx, _, zz = np.cross(rot_xz, unit_y)
        norm = np.sqrt(xx**2 + zz**2)
        xh, zh = x * xx / norm, x * zz / norm

        #Depth component
        xx, _, zz = -xz_vec
        norm = np.sqrt(xx**2 + zz**2)
        xd, zd = z * xx / norm, z * zz / norm

        xx, yy, zz = vec
        vec = np.array([xx + xh + xd, yy, zz + zh + zd])
        self.renderer.camera.look_at([-xh - xd, 0, -zh - zd])
        self.renderer.camera.pos = vec.tolist()

    def _adjust_aspect(self, inst, val):
        rsize = self.renderer.size
        aspect = rsize[0] / float(rsize[1])
        self.renderer.camera.aspect = aspect
Example #35
0
    def build(self):
        layout = GridLayout(cols=3)

        # create renderer
        self.renderer = Renderer(size_hint=(5, 5))
        self.renderer.set_clear_color(
            (0.1, 0.1, 0.1, 1)
        )  # rgba

        # create scene
        scene = Scene()
        self.cubes = []

        # create cubes for scene
        #
        # default pure green cube
        cube_geo = BoxGeometry(.3, .3, .3)
        cube_mat = Material(
            color=(0, 0.5, 0)  # base color
        )
        self.cubes.append(Mesh(
            geometry=cube_geo,
            material=cube_mat
        ))  # default pos == (0, 0, 0)
        self.cubes[0].pos.z = -5
        self.cubes[0].pos.x = 1
        self.cubes[0].pos.y = 0.8
        self.cubes[0].rotation.x = 45

        # black cube, red shadow, half-transparent
        cube_geo = BoxGeometry(.3, .3, .3)
        cube_mat = Material(
            transparency=0.5,
            color=(0, 0, 0),  # base color
            diffuse=(10, 0, 0),  # color of "shadows"
            specular=(0, 0, 0)  # mirror-like reflections
        )
        self.cubes.append(Mesh(
            geometry=cube_geo,
            material=cube_mat
        ))  # default pos == (0, 0, 0)
        self.cubes[1].pos.z = -5
        self.cubes[1].pos.x = -1
        self.cubes[1].pos.y = 0.8
        self.cubes[1].rotation.y = 45

        # default pure green cube with red reflections
        cube_geo = BoxGeometry(.3, .3, .3)
        cube_mat = Material(
            transparency=1,
            color=(0, 0.5, 0),  # base color
            diffuse=(0, 0, 0),  # color of "shadows"
            specular=(10, 0, 0)  # mirror-like reflections
        )
        self.cubes.append(Mesh(
            geometry=cube_geo,
            material=cube_mat
        ))  # default pos == (0, 0, 0)
        self.cubes[2].pos.z = -5
        self.cubes[2].pos.x = 1
        self.cubes[2].pos.y = -0.8
        self.cubes[2].rotation.z = 45

        # black cube with red reflections
        # and half-transparent
        cube_geo = BoxGeometry(.3, .3, .3)
        cube_mat = Material(
            transparency=0.5,
            color=(0, 0, 0),  # base color
            specular=(10, 0, 0)  # mirror-like reflections
        )
        self.cubes.append(Mesh(
            geometry=cube_geo,
            material=cube_mat
        ))  # default pos == (0, 0, 0)
        self.cubes[3].pos.z = -5
        self.cubes[3].pos.x = -1
        self.cubes[3].pos.y = -0.8
        self.cubes[3].rotation.x = 45

        cube_geo = BoxGeometry(.3, .3, .3)
        cube_mat = Material(
            transparency=0.5,
            color=(0, 0, 0),  # base color
            specular=(10, 0, 0)
        )
        self.main_cube = Mesh(
            geometry=cube_geo,
            material=cube_mat
        )  # default pos == (0, 0, 0)
        self.main_cube.rotation.x = 45
        self.main_cube.rotation.y = 45
        self.main_cube.pos.z = -5
        scene.add(self.main_cube)

        plane_geo = BoxGeometry(5, 5, .1)
        plane_mat = Material(
            color=(1, 1, 1)  # base color
        )
        plane = Mesh(
            geometry=plane_geo,
            material=plane_mat
        )
        plane.pos.z = -10
        scene.add(plane)

        # create camera for scene
        self.camera = PerspectiveCamera(
            fov=75,    # distance from the screen
            aspect=0,  # "screen" ratio
            near=.1,    # nearest rendered point
            far=1000     # farthest rendered point
        )

        # start rendering the scene and camera
        for cube in self.cubes:
            scene.add(cube)
        self.renderer.render(scene, self.camera)

        # set renderer ratio is its size changes
        # e.g. when added to parent
        self.renderer.bind(size=self._adjust_aspect)

        layout.add_widget(Factory.CamRot())
        layout.add_widget(Widget())
        layout.add_widget(Factory.CamStrafe())
        layout.add_widget(Widget())

        layout.add_widget(self.renderer)

        layout.add_widget(Label(text='+\n\nY\n\n-'))
        layout.add_widget(Factory.CamNav())
        layout.add_widget(Label(text='-      X      +'))
        layout.add_widget(Factory.ObjNav())

        Clock.schedule_interval(self.rotate_cube, .01)
        Clock.schedule_interval(self.scale_cube, 1)

        # keyboard listener
        Listener()
        return layout
Example #36
0
    def build(self):
        self.renderer = Renderer(shader_file=shader_file)
        scene = Scene()
        camera = PerspectiveCamera(45, 1, 0.1, 2500)
        self.renderer.set_clear_color(clear_color)

        self.camera = camera

        root = ObjectTrackball(camera, 10, self.renderer)

        id_color = (0, 0, 0x7F)
        geometry = BoxGeometry(1, 1, 1)
        material = Material(color=(1., 1., 1.),
                            diffuse=(1., 1., 1.),
                            specular=(.35, .35, .35),
                            id_color=id_color,
                            shininess=1.)
        obj = Mesh(geometry, material)
        scene.add(obj)
        root.object_list.append({'id': id_color, 'obj': obj})

        id_color = (0, 0x7F, 0)
        geometry = BoxGeometry(1, 1, 1)
        material = Material(color=(0., 0., 1.),
                            diffuse=(0., 0., 1.),
                            specular=(.35, .35, .35),
                            id_color=id_color,
                            shininess=1.)
        obj = Mesh(geometry, material)
        obj.position.x = 2
        scene.add(obj)
        root.object_list.append({'id': id_color, 'obj': obj})

        # create a grid on the xz plane
        geometry = GridGeometry(size=(30, 30), spacing=1)
        material = Material(color=(1., 1., 1.),
                            diffuse=(1., 1., 1.),
                            specular=(.35, .35, .35),
                            transparency=.5)
        lines = Lines(geometry, material)
        lines.rotation.x = 90
        scene.add(lines)

        geometry = Geometry()
        geometry.vertices = [[0.0, 0.0, 0.0], [3.0, 0.0, 0.0]]
        geometry.lines = [Line2(a=0, b=1)]
        material = Material(color=(1., 0., 0.),
                            diffuse=(1., 0., 0.),
                            specular=(.35, .35, .35))
        lines = Lines(geometry, material)
        lines.position.y = -0.01
        scene.add(lines)

        geometry = Geometry()
        geometry.vertices = [[0.0, 0.0, 0.0], [0.0, 3.0, 0.0]]
        geometry.lines = [Line2(a=0, b=1)]
        material = Material(color=(0., 1., 0.),
                            diffuse=(0., 1., 0.),
                            specular=(1., 1.0, 1.0))
        lines = Lines(geometry, material)
        scene.add(lines)

        geometry = Geometry()
        geometry.vertices = [[0.0, 0.0, 0.0], [0.0, 0.0, 3.0]]
        geometry.lines = [Line2(a=0, b=1)]
        material = Material(color=(0., 0., 1.),
                            diffuse=(0., 0., 1.),
                            specular=(.35, .35, .35))
        lines = Lines(geometry, material)
        lines.position.y = -0.01
        scene.add(lines)

        self.renderer.render(scene, camera)
        self.renderer.main_light.intensity = 1000
        self.renderer.main_light.pos = (10, 10, -10)

        root.add_widget(self.renderer)
        self.renderer.bind(size=self._adjust_aspect)

        return root
Example #37
0
class Level(object):
    def __init__(self, game):
        self.name = ""
        self.game = game
        self.colliders = []
        self.entities = []
        self.time = 0

        # create camera for scene
        self.camera = PerspectiveCamera(
            fov=80,  # distance from the screen
            aspect=0,  # "screen" ratio
            near=.1,  # nearest rendered point
            far=1000  # farthest rendered point
        )
        self.camera.pos.y = 3

        self.scene = Scene()
        self.player = Player()
        self.entities.append(self.player)
        self.scene.add(self.player)

    def tick(self, df):
        self.time += df
        v = self.game.inputVector
        self.player.velocity.add(v * df * 10 * Vector3(-1, 0, 1))
        for e in self.entities:
            e.tick(df)
        self.camera.pos.x = self.player.pos.x + 0.3
        self.camera.pos.z = self.player.pos.z - 3
        self.camera.look_at(self.player.pos)
        for c in self.colliders:
            if c.callback is not None:
                if c.check(self.player.pos, self.player.size):
                    if len(inspect.getargspec(c.callback)[0]) > 1:
                        if c.callback(c):
                            break
                    else:
                        if c.callback():
                            break

    def reset(self):
        for e in self.entities:
            e.reset()

    def spawn(self, entity, position=None):
        if position:
            entity.dpos = Vector3(position)
            entity.reset()

        self.entities.append(entity)
        self.scene.add(entity)
        return entity

    def spawn_text(self,
                   text,
                   position,
                   size=0.1,
                   orientation="y",
                   color=(1, 1, 1, 1)):
        my_label = CoreLabel(font_size=int(200 * size))
        my_label.text = text
        my_label.refresh()
        aspect = float(my_label.texture.size[0]) / my_label.texture.size[1]

        quad = Quad(Material(map=my_label.texture,
                             color=color[:3],
                             transparency=color[3]),
                    size * aspect,
                    size,
                    orientation=orientation)
        quad.label = my_label
        self.spawn(quad, position)

    def spawn_std_cube(self, *args, **kwargs):
        # return self.spawn_wireframe_cube(*args, **kwargs)

        return self.spawn_solid_cube(*args, **kwargs)

    def spawn_wireframe_cube(self,
                             location,
                             size=(1, 1, 1),
                             color=(1, 1, 1, 0.5),
                             callback=None):
        mat = Material(color=color[0:3], transparency=color[3])
        cube = Cube(material=mat, size=size)
        cube.dpos = Vector3(location)
        cube.reset()
        self.spawn(cube)
        if callback is not None:
            collider = BoxCollider(p1=p1,
                                   p2=p2,
                                   parent=cube,
                                   callback=callback)
            self.colliders.append(collider)
            return (cube, collider)
        return cube

    def spawn_solid_cube(self,
                         location,
                         texture=None,
                         size=(1, 1, 1),
                         color=(1, 1, 1, 0.5),
                         callback=None):
        geo = BoxGeometry(size[0], size[1], size[2])
        mat = Material(color=color[0:3], transparency=color[3], map=texture)
        cube = Mesh(geometry=geo, material=mat)
        self.spawn(cube, location)
        if callback is not None:
            collider = BoxCollider(p1=p1,
                                   p2=p2,
                                   parent=cube,
                                   callback=callback)
            self.colliders.append(collider)
            return (cube, collider)
        return cube

    def spawn_portal(self,
                     position,
                     radius=0.2,
                     color=(1, 1, 1),
                     callback=None):
        mat = Material(color=color)
        portal = self.spawn(PortalPad(mat, radius, 0.02), position)
        if callback is not None:
            collider = SphereCollider([0, 0, 0],
                                      radius,
                                      parent=portal,
                                      callback=callback)
            self.colliders.append(collider)
            return (portal, collider)
        return portal

    def spawn_line(self, p1, p2, width=1, color=(1, 1, 1), callback=None):
        mat = Material(color=color)
        line = Lines(mat, [p1, p2], width)
        self.scene.add(line)

        if callback is not None:
            collider = LineCollider(p1=p1,
                                    p2=p2,
                                    parent=line,
                                    callback=callback)
            self.colliders.append(collider)
            return (line, collider)
        return line

    def spawn_stalker(self, position, size=0.1, callback=None):
        stalker = Stalker(level=self)
        stalker.dpos = Vector3(position)
        stalker.reset()
        self.entities.append(stalker)
        self.scene.add(stalker)

        if callback is not None:
            collider = SphereCollider(position=(0, 0, 0),
                                      radius=size,
                                      parent=stalker,
                                      callback=callback)
            self.colliders.append(collider)
            return (stalker, collider)
        return stalker
Example #38
0
    def build(self):
        self.theflag = 0
        self.theflag0 = 0
        self.distan = 1000  # дистанция до начальной точки (0,0,-50) что бы ничего не было за экраном (надо будет выстваить на изменение)
        bl = BoxLayout(orientation='vertical',
                       size_hint=(.15, 1),
                       spacing=10,
                       padding=10)  # левая панель
        al = AnchorLayout(anchor_x='left',
                          anchor_y='center')  # основная система интерфейса
        layout = GridLayout(cols=2, spacing=3,
                            size_hint=(1, 1))  #сетка для кнопок поворота

        matrix = np.load('matrix0.npy', allow_pickle=True)
        counter = int(int(matrix.size) / 2)
        x = np.zeros(counter)
        y = np.zeros(counter)
        z = np.zeros(counter)
        soe = np.zeros((counter, counter))

        for i in range(2):
            if (i == 0):
                for j in range(counter):
                    for k in range(3):
                        a = matrix[i, j]
                        if (k == 0):
                            x[j] = a[k] * 10
                        elif (k == 1):
                            y[j] = a[k] * 10
                        else:
                            z[j] = a[k] * 10
            else:
                for j in range(counter):
                    a = matrix[i, j]
                    for k in range(counter):
                        soe[j][k] = a[k]
        print(x, y, z)
        print(soe)
        # кнопка загрузки координат
        loader = Button(text='Load', on_press=self.load)
        bl.add_widget(loader)

        #starter = Button(text='Построить', on_press = self.letstart)
        #bl.add_widget(starter)

        bl.add_widget(Widget())
        # create renderer
        self.renderer = Renderer()

        # create scene
        scene = Scene()

        #lines
        k0 = 0
        k1 = 0
        lines_list = []
        for i in soe:
            for j in i:
                if (j == 1):
                    line0_geo = BoxGeometry(
                        1,
                        int(((y[k0] - y[k1])**2 + (x[k0] - x[k1])**2 +
                             (z[k0] - z[k1])**2)**0.5), 1)
                    #print(int(((abs(x[k0]-x[k1]) + abs(y[k0]-y[k1])+ abs(z[k0]-z[k1]))**0.5)),'length')
                    #print(int(abs(y[k0]-y[k1]) + abs(x[k0]-x[k1])+ abs(z[k0]-z[k1])))
                    line0_mat = Material()
                    self.line0 = Mesh(
                        geometry=line0_geo,
                        material=line0_mat)  # default pos == (0, 0, 0)
                    self.line0.pos.x = int((x[k0] + x[k1]) / 2)
                    self.line0.pos.y = int((y[k0] + y[k1]) / 2)
                    self.line0.pos.z = int((z[k0] + z[k1]) / 2) - self.distan
                    if y[k0] - y[k1] == 0 and x[k0] - x[
                            k1] == 0 and z[k0] - z[k1] != 0:
                        self.line0.rotation.x = 90
                    elif y[k0] - y[k1] == 0 and x[k0] - x[k1] != 0 and z[
                            k0] - z[k1] == 0:
                        self.line0.rotation.z = 90
                    elif y[k0] - y[k1] != 0 and x[k0] - x[k1] == 0 and z[
                            k0] - z[k1] == 0:
                        ###
                        fff = 0
                    elif y[k0] - y[k1] != 0 and x[k0] - x[k1] != 0 and z[
                            k0] - z[k1] == 0:
                        self.line0.rotation.z = math.atan(
                            (x[k0] - x[k1]) / (y[k0] - y[k1])) / math.pi * 180
                    elif y[k0] - y[k1] != 0 and x[k0] - x[
                            k1] == 0 and z[k0] - z[k1] != 0:
                        #self.line0.rotation.x = math.atan((z[k0]-z[k1])/(y[k0]-y[k1]))/math.pi*180
                        self.line0.rotation.x = math.acos(
                            abs(y[k0] - y[k1]) /
                            ((x[k0] - x[k1])**2 + (y[k0] - y[k1])**2 +
                             (z[k0] - z[k1])**2)**0.5) / math.pi * 180
                        #print()
                    elif y[k0] - y[k1] == 0 and x[k0] - x[k1] != 0 and z[
                            k0] - z[k1] != 0:
                        self.line0.rotation.z = math.atan(
                            (x[k0] - x[k1]) /
                            (z[k0] - z[k1])) / math.pi * 180 * -1
                        self.line0.rotation.x = 90

                    ###
                    elif y[k0] - y[k1] != 0 and x[k0] - x[k1] != 0 and z[
                            k0] - z[k1] != 0:
                        if ((x[k0] < x[k1] and y[k0] < y[k1])
                                or (x[k0] > x[k1] and y[k0] > y[k1])):
                            #self.line0.rotation.z = math.atan((abs(z[k0]-z[k1]))/1.5/(abs(y[k0]-y[k1])))/math.pi*180
                            self.line0.rotation.z = math.acos(
                                abs(y[k0] - y[k1]) /
                                ((x[k0] - x[k1])**2 + (y[k0] - y[k1])**2 +
                                 (0)**2)**0.5) / math.pi * 180 * -1
                            #проблема
                        else:
                            self.line0.rotation.z = math.acos(
                                abs(y[k0] - y[k1]) /
                                ((x[k0] - x[k1])**2 + (y[k0] - y[k1])**2 +
                                 (0)**2)**0.5) / math.pi * 180
                        #self.line0.rotation.x = math.atan((1.25*abs(x[k0]-x[k1]))/(abs(y[k0]-y[k1])))/math.pi*180*-1
                        if ((z[k0] < z[k1] and y[k0] < y[k1])
                                or (z[k0] > z[k1] and y[k0] > y[k1])):
                            self.line0.rotation.x = math.acos(
                                abs(y[k0] - y[k1]) /
                                ((0)**2 + (y[k0] - y[k1])**2 +
                                 (z[k0] - z[k1])**2)**0.5) / math.pi * 180
                            #проблема
                        else:
                            self.line0.rotation.x = math.acos(
                                abs(y[k0] - y[k1]) /
                                ((0)**2 + (y[k0] - y[k1])**2 +
                                 (z[k0] - z[k1])**2)**0.5) / math.pi * 180 * -1

                        #self.line0.rotation.x = math.acos(abs(y[k0]-y[k1])/((0)**2+(y[k0]-y[k1])**2+(z[k0]-z[k1])**2)**0.5)/math.pi*180*-1#there
                        print(self.line0.rotation.z)
                        print(self.line0.rotation.x)
                    lines_list.append(self.line0)
                k1 += 1
            k0 += 1
            k1 = 0
        line0_geo = BoxGeometry(1, y[1] - y[0], 1)
        line0_mat = Material()
        self.line0 = Mesh(geometry=line0_geo,
                          material=line0_mat)  # default pos == (0, 0, 0)
        self.line0.pos.z = int(z[0]) - self.distan

        #self.line3.rotation.x = 90

        #points
        point_list = []
        sumx = 0
        sumy = 0
        sumz = 0
        sumcount = 0
        loader = OBJLoader()

        for i in range(counter):
            point_geom = SphereGeometry(1.1)
            point_mat = Material()
            self.point0 = Mesh(geometry=point_geom, material=point_mat)
            self.point0.pos.x = int(x[i])
            self.point0.pos.y = int(y[i])
            self.point0.pos.z = int(z[i]) - self.distan
            self.point0.scale = (1, 1, 1)
            point_list.append(self.point0)
            sumx += self.point0.pos.x
            sumy += self.point0.pos.y
            sumz += self.point0.pos.z
            sumcount += 1
            #scene.add(self.point0)

        point_geom = SphereGeometry()
        point_mat = Material()
        self.point1 = Mesh(geometry=point_geom, material=point_mat)
        self.point1.pos.x = sumx / sumcount
        self.point1.pos.y = sumy / sumcount
        self.point1.pos.z = sumz / sumcount
        self.point1.scale = (1, 1, 1)
        #scene.add(self.point1)
        self.camera = PerspectiveCamera(
            fov=100,  # размер окна т.е. чем больше фов тем больше масштаб
            aspect=0,  # "screen" ratio
            near=1,  # рендер от
            far=10000  # дистанция рендера
        )

        k0 = 0
        self.ll = []
        for i in soe:
            for j in i:
                if (j == 1):
                    self.ll.append(lines_list[k0])
                    scene.add(lines_list[k0])
                    k0 += 1

        for i in range(counter):
            scene.add(point_list[i])
            pass

        self.pp = point_list
        self.renderer.render(scene, self.camera)
        self.renderer.bind(size=self._adjust_aspect)
        al.add_widget(self.renderer)
        bl.add_widget(Factory.Fov())
        bl.add_widget(Factory.CamNav())
        al.add_widget(bl)
        return al