threequick 0.0.0__tar.gz → 0.0.2__tar.gz

{threequick-0.0.0/src/threequick.egg-info → threequick-0.0.2}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: threequick
-Version: 0.0.0
-Summary: A simple python library for creating 3D visualisations without OpenGL.
+Version: 0.0.2
+Summary: A simple python library for creating 3D visualisations
 Author-email: Hannah Baldwin <contact@hannahbaldwin.net>
 License: GPL-3.0
 Project-URL: Homepage, https://github.com/habaldwin01/threequick
@@ -16,4 +16,4 @@ Requires-Dist: pygame>=2.0.0
 Dynamic: license-file
 
 # threequick
-A simple python library for creating 3D visualisations without OpenGL
+A simple python library for creating 3D visualisations.

threequick-0.0.2/README.md

@@ -0,0 +1,2 @@
+# threequick
+A simple python library for creating 3D visualisations.

{threequick-0.0.0 → threequick-0.0.2}/pyproject.toml

@@ -5,7 +5,7 @@ authors = [
   { name="Hannah Baldwin", email="contact@hannahbaldwin.net" },
 ]
 license = { text="GPL-3.0" }
-description = "A simple python library for creating 3D visualisations without OpenGL."
+description = "A simple python library for creating 3D visualisations"
 readme = "README.md"
 requires-python = ">=3.6"
 classifiers = [

threequick-0.0.2/scripts/example.py

@@ -0,0 +1,98 @@
+import pygame
+import numpy as np
+import math
+from threequick import CameraContext, Object3d, Cube, Sphere, PointCloud
+
+
+window = pygame.display.set_mode((1280, 720), pygame.RESIZABLE)
+pygame.display.set_caption("threequick test")
+done = False
+renderable_objects = []
+
+
+tc = Cube(0.2)
+# pitch  roll   yaw
+# x      y      z
+#tc.set_rotation(0,0,0)
+#tc.set_position(0,0,0)
+tc.set_rotation(30,10,60)
+tc.set_position(1,0,0)
+renderable_objects.append(tc)
+
+sp = Sphere(16, 6+1, 1)
+renderable_objects.append(sp)
+
+#point_cloud = PointCloud()
+#renderable_objects.append(point_cloud)
+
+#point_cloud.add_point([0,0.25,0.25], [0,255,0])
+
+cam_dist = 5
+
+camera_context = CameraContext([0,-cam_dist,0], [70,0,30], 90, window)
+camera_context.position[0] = (math.sin(math.radians(camera_context.rotation[2])) * -cam_dist) * math.sin(math.radians(camera_context.rotation[0]))
+camera_context.position[1] = (math.cos(math.radians(camera_context.rotation[2])) * -cam_dist) * math.sin(math.radians(camera_context.rotation[0]))
+camera_context.position[2] = math.cos(math.radians(camera_context.rotation[0])) * -cam_dist
+
+cube_angle = 0
+
+pygame.init()
+
+last_ticks = pygame.time.get_ticks()
+
+while not done:
+    current_ticks = pygame.time.get_ticks()
+
+    pygame.draw.rect(window, (0, 0, 0), (0, 0, window.get_width(), window.get_height()))
+
+    mx, my = pygame.mouse.get_pos()
+    for event in pygame.event.get():
+        if event.type == pygame.QUIT:
+            exit()
+
+    left_button, middle_button, right_button = pygame.mouse.get_pressed()
+    if not left_button:
+        last_rc_pos = (mx, my)
+
+
+    if left_button:
+        camera_context.rotation[0] -= (my - last_rc_pos[1]) * 0.2
+        if camera_context.rotation[0] > 180:
+            camera_context.rotation[0] = 180
+        if camera_context.rotation[0] < 0:
+            camera_context.rotation[0] = 0
+        smx = (math.sin(math.radians(camera_context.rotation[0]))) + 0.5
+        camera_context.rotation[2] -= (mx - last_rc_pos[0]) * 0.2 / smx
+        last_rc_pos = (mx, my)
+
+
+    orbital_period_s = 8
+    cube_angle = ((pygame.time.get_ticks() / 1000) / orbital_period_s) * 360
+
+    tc.set_rotation(30,10,60 + cube_angle)
+    tc.set_position(math.sin(math.radians(cube_angle)),-math.cos(math.radians(cube_angle)),0)
+    #tc.set_position(0,0,0)
+
+    # Slow rotation of camera
+    #camera_context.rotation[2] += (last_ticks - current_ticks) / 80
+
+
+    # Calculate camera position based off angle so it always points at 0,0,0
+    camera_context.position[0] = (math.sin(math.radians(camera_context.rotation[2])) * -cam_dist) * math.sin(math.radians(camera_context.rotation[0]))
+    camera_context.position[1] = (math.cos(math.radians(camera_context.rotation[2])) * -cam_dist) * math.sin(math.radians(camera_context.rotation[0]))
+    camera_context.position[2] = math.cos(math.radians(camera_context.rotation[0])) * -cam_dist
+
+
+    last_ticks = current_ticks
+
+    camera_context.update_screenspace()
+    for ro in renderable_objects:
+        ro.draw(camera_context)
+
+    for event in pygame.event.get():
+        if event.type == pygame.QUIT:
+            done = True
+
+    pygame.display.flip()
+
+exit()

{threequick-0.0.0 → threequick-0.0.2}/src/threequick/__init__.py

@@ -1 +1 @@
-from .threequick import CameraContext, Object3d, Cube, Sphere, PointCloud
+from .threequick import CameraContext, Object3d, Cube, Sphere, PointCloud, Ellipsoid

{threequick-0.0.0 → threequick-0.0.2}/src/threequick/threequick.py

@@ -1,6 +1,12 @@
 import pygame
+import pygame.font
 import numpy as np
 import math
+import random
+from typing import Optional, Union
+
+pygame.font.init()
+sans_font = pygame.font.Font(pygame.font.get_default_font(), 36)
 
 def transform_3d_point_4x4_mat(matrix, point):
     # Convert to homogeneous coordinates
@@ -42,10 +48,12 @@ class CameraContext:
     def __init__(self,
                  position: list[float],
                  rotation: list[float],
+                 fov: float,
                  surface: pygame.Surface):
         self.position = position
         self.rotation = rotation
         self.screen_size = (1,1)
+        self.fov = fov
         self.frustum_width = 1
         self.frustum_height = 1
         self.surface = surface
@@ -54,13 +62,13 @@ class CameraContext:
         self.screen_size = (self.surface.get_width(), self.surface.get_height())
 
         self.min_render_distance = 0.1
-        self.frustum_width = self.min_render_distance
+        self.frustum_width = self.min_render_distance / (math.pi - math.radians(self.fov))
         self.frustum_height = self.frustum_width * (self.screen_size[1] / self.screen_size[0])
         #self.projection_matrix = [[nx/2,  0,     0,     (nx-1)/2],
         #                       [0,     ny/2,  0,     (ny-1)/2],
         #                       [0,     0,     1/2,   1/2     ]]
 
-        f = 4 # far
+        f = 10 # far
         n = self.min_render_distance # near
         r = self.frustum_width # width
         t = self.frustum_height # height
@@ -73,6 +81,8 @@ class CameraContext:
                                   [0, 0, c, d],
                                   [0, 0,-1, 0]]
 
+        # From https://songho.ca/opengl/gl_transform.html
+
         self.translation_matrix = [[1, 0, 0, self.position[0]],
                                    [0, 1, 0, self.position[1]],
                                    [0, 0, 1, self.position[2]],
@@ -103,71 +113,109 @@ class Renderable():
 class Object3d(Renderable):
     def __init__(self,
                  vertices: list[list[float]],
-                 edges: list[list[int]],
-                 faces: list[list[int]]) -> None:
-        self.__mod_vertices = vertices
-        self.__mod_edges = edges
-        self.__mod_faces = faces
+                 faces: list[list[int]],
+                 color: Optional[list[int]] = None,
+                 face_color: list[int] = None) -> None:
+        self.__mod_vertices = [None] * len(vertices)
+        #self.__mod_edges = edges
+        #self.__mod_faces = faces
         self.vertices = vertices
-        self.edges = edges
         self.faces = faces
-        self.position = [0,0,0]
-        self.rotation_matrix = [[1, 0, 0, 0],
-                                [0, 1, 0, 0],
-                                [0, 0, 1, 0],
-                                [0, 0, 0, 1]]
+        self.face_color = face_color
+        self.position = [0, 0, 0]
+        self.color = color
+        self.rotation_matrix = pry_rot_to_4x4(0, 0, 0)
+        self.update_vertex_cache()
+        edges = set()
+        for face in self.faces:
+            edges.add((face[0], face[1]))
+            edges.add((face[1], face[2]))
+            edges.add((face[2], face[0]))
+        self.edges = list(edges)
+        if self.color is None:
+            if self.face_color is None:
+                self.face_color = []
+                for face in self.faces:
+                    self.face_color.append([random.randint(0,255),random.randint(0,255),random.randint(0,255)])
+
+                for face_idx in range(len(self.faces)):
+                    print(str(self.faces[face_idx]) + " => " + str(self.face_color[face_idx]))
 
     def set_rotation(self, pitch, roll, yaw):
         self.rotation_matrix = pry_rot_to_4x4(pitch, roll, yaw)
-
-        for vindex, vertex in enumerate(self.vertices):
-            self.__mod_vertices[vindex] = transform_3d_point_4x4_mat(self.rotation_matrix, vertex)
+        self.update_vertex_cache()
 
     def set_position(self, x, y, z):
         self.position = [x, y, z]
+        self.update_vertex_cache()
 
+    def update_vertex_cache(self):
         for vindex, vertex in enumerate(self.vertices):
+            vertex = transform_3d_point_4x4_mat(self.rotation_matrix, vertex)
             self.__mod_vertices[vindex] = [vertex[0] + self.position[0], vertex[1] + self.position[1], vertex[2] + self.position[2]]
 
-    def draw(self, camera_context: CameraContext) -> None:
+    def draw_wireframe(self, camera_context: CameraContext) -> None:
         scr_center = (camera_context.screen_size[0] / 2, camera_context.screen_size[1] / 2)
         tpf = camera_context.transform_point
         for edge in self.edges:
             p1 = tpf(self.__mod_vertices[edge[0]])
             p2 = tpf(self.__mod_vertices[edge[1]])
             if p1 is not None and p2 is not None:
-                pygame.draw.line(camera_context.surface, (255, 255, 255), p1, p2)
+                pygame.draw.line(camera_context.surface, self.color, p1, p2)
+
+    def draw(self, camera_context: CameraContext) -> None:
+        scr_center = (camera_context.screen_size[0] / 2, camera_context.screen_size[1] / 2)
+        tpf = camera_context.transform_point
+        for idx, face in enumerate(self.faces):
+            poly_points = [tpf(self.__mod_vertices[face[0]]),
+                    tpf(self.__mod_vertices[face[1]]),
+                    tpf(self.__mod_vertices[face[2]])]
+
+            dir_sum = 0
+            for edgeidx in range(3):
+                p1 = poly_points[edgeidx]
+                p2 = poly_points[(edgeidx + 1) % 3]
+                dir_sum += (p2[0] - p1[0]) * (p2[1] + p1[1])
+            backface_cull = dir_sum < 0
+
+            #if not backface_cull:
+            if self.color is None:
+                if backface_cull:
+                    #pygame.draw.lines(camera_context.surface, self.face_color[idx], True, poly_points)
+                    pass
+                else:
+                    pygame.draw.polygon(camera_context.surface, self.face_color[idx], poly_points)
+
+
+                #for ptidx in range(3):
+                #    text_surface = sans_font.render(str(face[ptidx]), False, (255,255,255))
+                #    camera_context.surface.blit(text_surface, poly_points[ptidx])
+            else:
+                if not backface_cull:
+                    pygame.draw.polygon(camera_context.surface, self.color, poly_points)
+
 
 class Cube(Object3d):
-    edges: list[list[int]] = [
-        [0, 1],
-        [1, 2],
-        [2, 3],
-        [3, 0],
-        [4, 5],
-        [5, 6],
-        [6, 7],
-        [7, 4],
-        [0, 4],
-        [1, 5],
-        [2, 6],
-        [3, 7]
-    ]
     faces: list[list[int]] = [
-        [0, 1, 2],
-        [1, 2, 3],
-        [4, 5, 6],
-        [5, 6, 7],
-        [0, 1, 5],
-        [1, 5, 4],
-        [1, 2, 6],
-        [2, 6, 5],
-        [2, 3, 7],
-        [3, 7, 6],
-        [3, 0, 4],
-        [0, 4, 7]
+        [0,1,2],
+        [0,2,3],
+
+        [4,7,6],
+        [6,5,4],
+
+        [5,2,1],
+        [6,2,5],
+
+        [5,1,4],
+        [4,1,0],
+
+        [7,0,3],
+        [4,0,7],
+
+        [7,3,6],
+        [6,3,2]
     ]
-    def __init__(self, size) -> None:
+    def __init__(self, size, color = None) -> None:
         size = size/2
         vertices: list[list[float]] = [
             [-size, -size, -size],
@@ -179,17 +227,17 @@ class Cube(Object3d):
             [size, size, size],
             [-size, size, size]
         ]
-        super().__init__(vertices, Cube.edges, Cube.faces)
+        super().__init__(vertices, Cube.faces, color)
 
-class Sphere(Object3d):
-    def __init__(self, n_meridians, n_parallels, diameter) -> None:
+class Ellipsoid(Object3d):
+    def __init__(self, n_meridians, n_parallels, diameter, flattening, color = None) -> None:
+        compression_factor = 1 - flattening
         radius = diameter/2
-        vertices = [[0,0,radius],[0,0,-radius]]
-        edges = []
+        vertices = [[0,0,radius * compression_factor],[0,0,-radius * compression_factor]]
         faces = []
         for ipa in range(n_parallels):
             vang = ((ipa + 1) / (n_parallels + 1)) * math.pi
-            vpos = -math.cos(vang) * radius
+            vpos = -math.cos(vang) * radius * compression_factor
             for ime in range(n_meridians):
                 ang = (ime * math.pi * 2) / n_meridians
                 sa = math.sin(ang)
@@ -199,24 +247,29 @@ class Sphere(Object3d):
 
         # bottom cap
         for ime in range(n_meridians):
-            edges.append([1,2+ime])
+            faces.append([2+ime,1,2+((ime+1)%n_meridians)])
 
         # top cap
         for ime in range(n_meridians):
-            edges.append([0,2+ime+(n_meridians * (n_parallels - 1))])
+            bc_offset = (n_meridians * (n_parallels - 1))
+            faces.append([0,2+ime+bc_offset,2+((ime+1)%n_meridians)+bc_offset])
 
-        # meridians
+        # panels
         for ipa in range(n_parallels - 1):
             for ime in range(n_meridians):
-                edges.append([2+ime+(n_meridians * (ipa + 1)),2+ime+(n_meridians * ipa)])
-
-        # parallels
-        for ipa in range(n_parallels):
-            for ime in range(n_meridians):
-                edges.append([2+ime+(n_meridians * ipa),2+((ime + 1)%n_meridians)+(n_meridians * ipa)])
-
-        super().__init__(vertices, edges, faces)
-
+                pt1 = 2+((ime + 0)%n_meridians)+(n_meridians * ipa)
+                pt2 = 2+((ime + 0)%n_meridians)+(n_meridians * (ipa + 1))
+                pt3 = 2+((ime + 1)%n_meridians)+(n_meridians * ipa)
+                pt4 = 2+((ime + 1)%n_meridians)+(n_meridians * (ipa + 1))
+                faces.append([pt2, pt1, pt3])
+                faces.append([pt2, pt3, pt4])
+                #edges.append([2+ime+(n_meridians * (ipa + 1)),2+ime+(n_meridians * ipa)])
+
+        super().__init__(vertices, faces, color)
+
+class Sphere(Ellipsoid):
+    def __init__(self, n_meridians, n_parallels, diameter, color = None) -> None:
+        super().__init__(n_meridians, n_parallels, diameter, 0, color)
 
 class PointCloud(Renderable):
     def __init__(self, diameter = 2) -> None:

{threequick-0.0.0 → threequick-0.0.2/src/threequick.egg-info}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: threequick
-Version: 0.0.0
-Summary: A simple python library for creating 3D visualisations without OpenGL.
+Version: 0.0.2
+Summary: A simple python library for creating 3D visualisations
 Author-email: Hannah Baldwin <contact@hannahbaldwin.net>
 License: GPL-3.0
 Project-URL: Homepage, https://github.com/habaldwin01/threequick
@@ -16,4 +16,4 @@ Requires-Dist: pygame>=2.0.0
 Dynamic: license-file
 
 # threequick
-A simple python library for creating 3D visualisations without OpenGL
+A simple python library for creating 3D visualisations.

{threequick-0.0.0 → threequick-0.0.2}/src/threequick.egg-info/SOURCES.txt

@@ -10,4 +10,6 @@ src/threequick.egg-info/PKG-INFO
 src/threequick.egg-info/SOURCES.txt
 src/threequick.egg-info/dependency_links.txt
 src/threequick.egg-info/requires.txt
+src/threequick.egg-info/scm_file_list.json
+src/threequick.egg-info/scm_version.json
 src/threequick.egg-info/top_level.txt

threequick-0.0.2/src/threequick.egg-info/scm_file_list.json

@@ -0,0 +1,12 @@
+{
+  "files": [
+    "README.md",
+    "pyproject.toml",
+    "LICENSE",
+    ".gitignore",
+    "scripts/build-install-test.sh",
+    "scripts/example.py",
+    "src/threequick/__init__.py",
+    "src/threequick/threequick.py"
+  ]
+}

threequick-0.0.2/src/threequick.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.0.2",
+  "distance": 0,
+  "node": "g1c2fe6dc0ad76f3a32cf39120b3f25647deecce2",
+  "dirty": false,
+  "branch": "main",
+  "node_date": "2026-07-10"
+}

threequick-0.0.0/README.md

@@ -1,2 +0,0 @@
-# threequick
-A simple python library for creating 3D visualisations without OpenGL

threequick-0.0.0/scripts/example.py

@@ -1,68 +0,0 @@
-import pygame
-import numpy as np
-import math
-from threequick import CameraContext, Object3d, Cube, Sphere, PointCloud
-
-
-window = pygame.display.set_mode((1280, 720), pygame.RESIZABLE)
-pygame.display.set_caption("threequick test")
-done = False
-renderable_objects = []
-
-
-tc = Cube(0.2)
-# pitch  roll   yaw
-# x      y      z
-tc.set_rotation(30,10,60)
-renderable_objects.append(tc)
-
-sp = Sphere(16, 6+1, 1)
-renderable_objects.append(sp)
-
-point_cloud = PointCloud()
-renderable_objects.append(point_cloud)
-
-point_cloud.add_point([0,0.25,0.25], [0,255,0])
-
-cam_dist = 2
-
-camera_context = CameraContext([0,-cam_dist,0], [90,0,0], window)
-
-
-while not done:
-    pygame.draw.rect(window, (0, 0, 0), (0, 0, 1280, 720))
-
-    mx, my = pygame.mouse.get_pos()
-    for event in pygame.event.get():
-        if event.type == pygame.QUIT:
-            exit()
-
-    left_button, middle_button, right_button = pygame.mouse.get_pressed()
-    if not left_button:
-        last_rc_pos = (mx, my)
-
-
-    if left_button:
-        camera_context.rotation[0] -= (my - last_rc_pos[1]) * 0.2
-        if camera_context.rotation[0] > 180:
-            camera_context.rotation[0] = 180
-        if camera_context.rotation[0] < 0:
-            camera_context.rotation[0] = 0
-        smx = (math.sin(math.radians(camera_context.rotation[0]))) + 0.5
-        camera_context.rotation[2] -= (mx - last_rc_pos[0]) * 0.2 / smx
-        camera_context.position[0] = (math.sin(math.radians(camera_context.rotation[2])) * -cam_dist) * math.sin(math.radians(camera_context.rotation[0]))
-        camera_context.position[1] = (math.cos(math.radians(camera_context.rotation[2])) * -cam_dist) * math.sin(math.radians(camera_context.rotation[0]))
-        camera_context.position[2] = math.cos(math.radians(camera_context.rotation[0])) * -cam_dist
-        last_rc_pos = (mx, my)
-
-    camera_context.update_screenspace()
-    for ro in renderable_objects:
-        ro.draw(camera_context)
-
-    for event in pygame.event.get():
-        if event.type == pygame.QUIT:
-            done = True
-
-    pygame.display.flip()
-
-exit()