Esempio n. 1
0
def demo3d():
    b1 = phyber_engine_3D.p_Ball_3D(60, 2)
    b2 = phyber_engine_3D.p_Ball_3D(30, 1)

    b1.set_translation(1, 0, -5)
    b1.set_velocity(vec4(-0.00005, 0, 0, 1))
    b2.set_translation(-1, -2, -10)
    b2.set_velocity(vec4(0.00005, 0, 0, 1))

    size = (600, 400)
    phyber = phyber_engine_3D.Phyber_3D([b1, b2])

    sim = Renderer_3D_runtime(phyber, 16, size, 60)
    sim.set_proj(size[0], size[1], 90, 100, 0.01)
    sim.init()
Esempio n. 2
0
    def apply_acceleration(self, deltaTime):
        self.velocity += self.acceleration * deltaTime

        self.acceleration = vec4(0, 0, 0, 1)

        self.position += self.velocity * deltaTime
        self.trans = mat4x4.mat_translation(self.position[0], self.position[1],
                                            self.position[2])
Esempio n. 3
0
    def __init__(self, engine, simSpeed, size, fps):
        self.engine = engine

        self.simSpeed = simSpeed

        self.projMat = mat4x4.make_identity()
        self.lightSource = vec4(5, 5, 10, 0)
        self.camera = vec4(0, 0, 0, 0)

        self.fps = fps
        self.deltaTime = 0
        self.lastTime = 0
        self.running = True

        pygame.init()
        self.size = size
        self.screen = pygame.display.set_mode(self.size)
        self.clock = pygame.time.Clock()
Esempio n. 4
0
    def __init__(self, engine, simSpeed, size, fps, seconds):
        self.engine = engine

        self.simSpeed = simSpeed
        self.fps = fps
        self.iterations = seconds * self.fps
        self.tick = (1 / fps) * simSpeed

        self.size = size

        self.projMat = mat4x4.make_identity()
        self.lightSource = vec4(5, 5, 10, 0)
        self.camera = vec4(0, 0, 0, 0)

        self.path = os.path.dirname(os.path.realpath(__file__))
        self.tempPath = os.path.join(self.path, 'temp')

        self.frameBuffer = np.zeros((self.size[1], self.size[0], 3), dtype=np.uint8)
Esempio n. 5
0
    def __init__(self, mass, radius):
        import OBJ_Reader

        self.radius = radius
        self.mass = mass
        self.acceleration = vec4(0, 0, 0, 1)
        self.velocity = vec4(0, 0, 0, 1)
        self.position = vec4(0, 0, 0, 1)

        self.trans = mat4x4.make_identity()
        self.rotX = mat4x4.make_identity()
        self.rotY = mat4x4.make_identity()
        self.rotZ = mat4x4.make_identity()
        self.scale = mat4x4.mat_scale(self.radius)

        self.tris = list()
        reader = OBJ_Reader.ObjReader('models/Sphere.obj')
        for t in reader.triangles:
            v1 = vec4(t[0][0], t[0][1], t[0][2], 1)
            v2 = vec4(t[1][0], t[1][1], t[1][2], 1)
            v3 = vec4(t[2][0], t[2][1], t[2][2], 1)
            v1 = self.scale * v1
            v2 = self.scale * v2
            v3 = self.scale * v3
            self.tris.append(Triangle([v1, v2, v3], t[3]))
Esempio n. 6
0
    def to_2D(self, bodies):
        triangles = list()
        for b in bodies:
            for tris in b.tris:
                v1 = b.rotZ * tris.verts[0]
                v2 = b.rotZ * tris.verts[1]
                v3 = b.rotZ * tris.verts[2]

                v1 = b.rotX * v1
                v2 = b.rotX * v2
                v3 = b.rotX * v3

                v1 = b.trans * v1
                v2 = b.trans * v2
                v3 = b.trans * v3

                u1 = v2 - v1
                u2 = v3 - v1
                normal = vec4.vec_cross(u1, u2)
                normal[3] = 0
                normal = normal.normalized()

                if (vec4.dot_product_3d(normal, v1 - self.camera) < 0):

                    #calculate lighting
                    lightDir = self.lightSource - v1 + ((((v3 - v2) *
                                                          (1 / 2)) - v1) *
                                                        (1 / 2))
                    lightDir[3] = 0
                    lightDir = lightDir.normalized()
                    lum = vec4.dot_product_3d(
                        normal,
                        lightDir)  #+ ((((v3 - v2) * (1 / 2)) - v1) * (1 / 2)))

                    v1 = self.projMat * v1
                    v2 = self.projMat * v2
                    v3 = self.projMat * v3

                    if (v1[3] != 0):
                        v1 *= (1 / v1[3])
                    if (v2[3] != 0):
                        v2 *= (1 / v2[3])
                    if (v3[3] != 0):
                        v3 *= (1 / v3[3])

                    #v1[0] *= -1
                    #v1[1] *= -1
                    #v2[0] *= -1
                    #v2[1] *= -1
                    #v3[0] *= -1
                    #v3[1] *= -1

                    offsetView = vec4(1, 1, 0, 0)
                    v1 = v1 + offsetView
                    v2 = v2 + offsetView
                    v3 = v3 + offsetView
                    v1[0] *= 0.5 * self.width
                    v1[1] *= 0.5 * self.height
                    v2[0] *= 0.5 * self.width
                    v2[1] *= 0.5 * self.height
                    v3[0] *= 0.5 * self.width
                    v3[1] *= 0.5 * self.height

                    triangles.append([
                        v1[:2], v2[:2], v3[:2],
                        self.get_lum_value(lum),
                        mean([v1[2], v2[2], v3[2]])
                    ])
        triangles = sorted(triangles, reverse=False, key=lambda t: t[4])
        return triangles
Esempio n. 7
0
 def set_light_source(self, x, y, z):
     self.lightSource = vec4(x, y, z, 1)
Esempio n. 8
0
 def __init__(self, verts, normal=[0, 0, 0]):
     self.verts = verts
     self.normal = vec4(normal[0], normal[1], normal[2], 1)
     self.normal = self.normal.normalized()
Esempio n. 9
0
 def set_translation(self, x, y, z):
     self.position = vec4(x, y, z, 1)
     self.trans = mat4x4.mat_translation(self.position[0], self.position[1],
                                         self.position[2])