skelform-pygame 0.2.3__tar.gz

skelform_pygame-0.2.3/.gitignore

@@ -0,0 +1,2 @@
+/dist
+/__pycache__

skelform_pygame-0.2.3/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: skelform_pygame
+Version: 0.2.3
+Summary: SkelForm runtime for Pygame. Uses the generic runtime
+Author-email: Retropaint <darkglasses1122@gmail.com>
+License-Expression: MIT
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Requires-Dist: dacite>=1.9.2
+Requires-Dist: pygame-ce>=2.5.6
+Requires-Dist: skelform-python>=0.2.0.1
+Description-Content-Type: text/markdown
+
+Library for running [SkelForm](https://skelform.org) animations in
+[Pygame](https://pygame.org).
+
+```python
+import skelform_pygame as skf_pg
+```
+
+## Basic Setup
+
+- `skf_pg.load()` - loads `.skf` file and returns armature & textures, to be
+  used later
+- `skf_pg.animate()` - transforms the armature's bones based on the animation(s)
+- `skf_pg.construct()` - provides the bones from this armature that are ready
+  for use
+- `skf_pg.draw()` - draws the bones on-screen, with the provided style(s)
+
+### 1. Load:
+
+```python
+(armature, textures) = skf_pg.load("skellina.skf")
+```
+
+This should only be called once (eg; before main game loop), and `armature` and
+`textures` should be kept for later use.
+
+### 2\. Animate:
+
+```python
+# use `skf_pg.time_frame()` to get the animation frame based on time (1000 = 1 second)
+time = 2000
+frame = skf_pg.time_frame(time, armature.animations[0], False, True)
+
+print(frame) # will be at the 2 second mark of the animation
+
+armature.bones = skf_pg.animate(armature, [armature.animations[0]], [0], [0])
+```
+
+_Note: not needed if armature is statilc_
+
+### 3\. Construct:
+
+```python
+center = pygame.Vector2(screen.get_width()/2, screen.get_height()/2)
+
+final_bones = skf_pg.construct(
+    armature,
+    screen,
+    skf_pg.AnimOptions(
+      pos=center
+    )
+)
+```
+
+Modifications to the armature (eg; aiming at cursor) may be done before or after
+construction.
+
+### 4\. Draw:
+
+```python
+skf_pg.draw(final_bones, armature.styles, textures, screen)
+```
+
+## Limitations
+
+- Mesh deformation not supported

skelform_pygame-0.2.3/README.md

@@ -0,0 +1,65 @@
+Library for running [SkelForm](https://skelform.org) animations in
+[Pygame](https://pygame.org).
+
+```python
+import skelform_pygame as skf_pg
+```
+
+## Basic Setup
+
+- `skf_pg.load()` - loads `.skf` file and returns armature & textures, to be
+  used later
+- `skf_pg.animate()` - transforms the armature's bones based on the animation(s)
+- `skf_pg.construct()` - provides the bones from this armature that are ready
+  for use
+- `skf_pg.draw()` - draws the bones on-screen, with the provided style(s)
+
+### 1. Load:
+
+```python
+(armature, textures) = skf_pg.load("skellina.skf")
+```
+
+This should only be called once (eg; before main game loop), and `armature` and
+`textures` should be kept for later use.
+
+### 2\. Animate:
+
+```python
+# use `skf_pg.time_frame()` to get the animation frame based on time (1000 = 1 second)
+time = 2000
+frame = skf_pg.time_frame(time, armature.animations[0], False, True)
+
+print(frame) # will be at the 2 second mark of the animation
+
+armature.bones = skf_pg.animate(armature, [armature.animations[0]], [0], [0])
+```
+
+_Note: not needed if armature is statilc_
+
+### 3\. Construct:
+
+```python
+center = pygame.Vector2(screen.get_width()/2, screen.get_height()/2)
+
+final_bones = skf_pg.construct(
+    armature,
+    screen,
+    skf_pg.AnimOptions(
+      pos=center
+    )
+)
+```
+
+Modifications to the armature (eg; aiming at cursor) may be done before or after
+construction.
+
+### 4\. Draw:
+
+```python
+skf_pg.draw(final_bones, armature.styles, textures, screen)
+```
+
+## Limitations
+
+- Mesh deformation not supported

skelform_pygame-0.2.3/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["hatchling >= 1.26"]
+build-backend = "hatchling.build"
+
+[project]
+name = "skelform_pygame"
+version = "0.2.3"
+authors = [
+  { name="Retropaint", email="darkglasses1122@gmail.com" },
+]
+description = "SkelForm runtime for Pygame. Uses the generic runtime"
+readme = "README.md"
+requires-python = ">=3.9"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+dependencies = [
+    "dacite>=1.9.2",
+    "pygame-ce>=2.5.6",
+    "skelform-python>=0.2.0.1",
+]

skelform_pygame-0.2.3/readme.md

@@ -0,0 +1,65 @@
+Library for running [SkelForm](https://skelform.org) animations in
+[Pygame](https://pygame.org).
+
+```python
+import skelform_pygame as skf_pg
+```
+
+## Basic Setup
+
+- `skf_pg.load()` - loads `.skf` file and returns armature & textures, to be
+  used later
+- `skf_pg.animate()` - transforms the armature's bones based on the animation(s)
+- `skf_pg.construct()` - provides the bones from this armature that are ready
+  for use
+- `skf_pg.draw()` - draws the bones on-screen, with the provided style(s)
+
+### 1. Load:
+
+```python
+(armature, textures) = skf_pg.load("skellina.skf")
+```
+
+This should only be called once (eg; before main game loop), and `armature` and
+`textures` should be kept for later use.
+
+### 2\. Animate:
+
+```python
+# use `skf_pg.time_frame()` to get the animation frame based on time (1000 = 1 second)
+time = 2000
+frame = skf_pg.time_frame(time, armature.animations[0], False, True)
+
+print(frame) # will be at the 2 second mark of the animation
+
+armature.bones = skf_pg.animate(armature, [armature.animations[0]], [0], [0])
+```
+
+_Note: not needed if armature is statilc_
+
+### 3\. Construct:
+
+```python
+center = pygame.Vector2(screen.get_width()/2, screen.get_height()/2)
+
+final_bones = skf_pg.construct(
+    armature,
+    screen,
+    skf_pg.AnimOptions(
+      pos=center
+    )
+)
+```
+
+Modifications to the armature (eg; aiming at cursor) may be done before or after
+construction.
+
+### 4\. Draw:
+
+```python
+skf_pg.draw(final_bones, armature.styles, textures, screen)
+```
+
+## Limitations
+
+- Mesh deformation not supported

skelform_pygame-0.2.3/skelform_pygame/__init__.py

@@ -0,0 +1,150 @@
+import sys
+
+import math
+import copy
+import zipfile
+import json
+from dataclasses import dataclass
+from typing import Optional
+
+# 3rd parties
+# sys.path.append("/Users/o/projects/skelform/runtimes/skelform_python")
+import skelform_python as skf_py
+import dacite
+import pygame
+from typing import List, Tuple
+
+
+# Loads an `.skf` file.
+def load(path: str) -> Tuple[skf_py.Armature, List[pygame.image]]:
+    with zipfile.ZipFile(path, "r") as zip_file:
+        armature_json = json.load(zip_file.open("armature.json"))
+
+    armature = dacite.from_dict(data_class=skf_py.Armature, data=armature_json)
+    textures = []
+
+    with zipfile.ZipFile(path, "r") as zip_file:
+        for atlas in armature.atlases:
+            textures.append(pygame.image.load(zip_file.open(atlas.filename)))
+
+    return (armature, textures)
+
+
+@dataclass
+class ConstructOptions:
+    position: pygame.math.Vector2
+    scale: pygame.Vector2
+
+    def __init__(
+        self,
+        position=pygame.Vector2(0, 0),
+        scale=pygame.Vector2(0.25, 0.25),
+    ):
+        self.position = position
+        self.scale = scale
+
+
+# Transforms an armature's bones based on the provided animation(s) and their frame(s).
+#
+# `smoothFrames` is used to smoothly interpolate transforms. Mainly used for smooth animation transitions. Higher frames are smoother.
+#
+# Note: smoothFrames should ideally be set to 0 (or empty) when reversing animations.
+def animate(
+    armature: skf_py.Armature,
+    animations: list[skf_py.Animation],
+    frames: list[int],
+    smooth_frames: list[int],
+) -> List[skf_py.Bone]:
+    return skf_py.animate(armature, animations, frames, smooth_frames)
+
+
+# Returns the constructed array of bones from this armature.
+#
+# While constructing, several options (positional offset, scale) may be set.
+def construct(
+    armature: skf_py.Armature, screen: pygame.Surface, anim_options: ConstructOptions
+) -> List[skf_py.Bone]:
+    final_bones = skf_py.construct(armature)
+
+    for bone in final_bones:
+        bone.pos.y = -bone.pos.y
+
+        bone.pos *= anim_options.scale
+        bone.scale *= anim_options.scale
+        bone.pos += anim_options.position
+
+        bone.rot = skf_py.check_bone_flip(bone.rot, anim_options.scale)
+
+    return final_bones
+
+
+# Draws the bones to the provided screen, using the provided styles and textures.
+#
+# Recommended: include the whole texture array from the file even if not all will be used,
+# as the provided styles will determine the final appearance.
+def draw(
+    bones: List[skf_py.Bone],
+    styles: List[skf_py.Style],
+    tex_imgs: List[pygame.image],
+    screen: pygame.Surface,
+):
+    bones.sort(key=lambda prop: prop.zindex)
+    surfaces = []
+
+    final_textures = skf_py.setup_bone_textures(bones, styles)
+
+    for bone in bones:
+        if bone.id not in final_textures:
+            continue
+
+        tex = final_textures[bone.id]
+
+        tex_surf = tex_imgs[tex.atlas_idx].subsurface(
+            (tex.offset.x, tex.offset.y, tex.size.x, tex.size.y)
+        )
+
+        pygame.Surface.convert(tex_surf)
+
+        tex_surf = pygame.transform.smoothscale_by(
+            tex_surf,
+            (math.fabs(bone.scale.x), math.fabs(bone.scale.y)),
+        )
+
+        if bone.scale.x < 0 or bone.scale.y < 0:
+            tex_surf = pygame.transform.flip(
+                tex_surf, bone.scale.x < 0, bone.scale.y < 0
+            )
+
+        # push textures back left and up so that it's centered
+        prop_tex_pos = bone.pos
+        prop_tex_pos.x -= tex_surf.get_size()[0] / 2
+        prop_tex_pos.y -= tex_surf.get_size()[1] / 2
+
+        deg = math.degrees(bone.rot)
+        (tex_surf, rect) = rot_center(tex_surf, tex_surf.get_rect(), deg)
+
+        moved_rect = rect.move(
+            prop_tex_pos.x,
+            prop_tex_pos.y,
+        )
+
+        surfaces.append((tex_surf, moved_rect))
+
+    screen.blits(surfaces)
+
+
+# https://www.pygame.org/wiki/RotateCenter
+def rot_center(image: pygame.image, rect: pygame.Rect, angle: float):
+    rot_image = pygame.transform.rotate(image, angle)
+    rot_rect = rot_image.get_rect(center=rect.center)
+    return rot_image, rot_rect
+
+
+# Returns the animation frame based on the provided time.
+def time_frame(time: int, animation: skf_py.Animation, reverse: bool, loop: bool):
+    return skf_py.time_frame(time, animation, reverse, loop)
+
+
+# Returns the properly bound animation frame based on the provided animation.
+def format_frame(frame: int, animation: skf_py.Animation, reverse: bool, loop: bool):
+    return skf_py.format_frame(frame, animation, reverse, loop)

skelform_pygame-0.2.3/tests/.python-version

@@ -0,0 +1 @@
+3.13

skelform_pygame-0.2.3/tests/main.py

@@ -0,0 +1,176 @@
+# Example file showing a circle moving on screen
+
+import sys
+
+import os
+
+os.environ["PYGAME_HIDE_SUPPORT_PROMPT"] = "1"
+
+sys.path.append("../../skelform_pygame")
+
+import pygame
+import zipfile
+import json
+import skelform_pygame as skf_pg
+import time
+import copy
+
+pygame.init()
+screen = pygame.display.set_mode((1280, 720))
+pygame.display.set_caption("SkelForm Basic Animation")
+font = pygame.font.Font(None, 50)
+clock = pygame.time.Clock()
+running = True
+dt = 0
+dir = 1
+anim_time = 0
+blend = 20
+last_anim_idx = 0
+vel_y = 0
+started_falling = False
+ground = screen.get_height() / 2 + 75
+
+player_pos = pygame.Vector2(screen.get_width() / 2, ground - 50)
+
+(skellina, skellina_img) = skf_pg.load("skellina.skf")
+
+
+# helper for finding bone by name
+def bone(name, bones):
+    for bone in bones:
+        if bone.name == name:
+            return bone
+
+
+# renders text with a drop-shadow
+def text(str, pos):
+    drop_x = pos[0]
+    drop_y = pos[1]
+    drop_x += 2.5
+    drop_y += 2.5
+    text = font.render(str, True, (0, 0, 0))
+    screen.blit(text, (drop_x, drop_y))
+    text = font.render(str, True, (255, 255, 255))
+    screen.blit(text, pos)
+
+
+while running:
+    for event in pygame.event.get():
+        if event.type == pygame.QUIT:
+            running = False
+
+    screen.fill("grey")
+    speed = 400
+    moving = False
+    keys = pygame.key.get_pressed()
+
+    # moving with A and D keys
+    if keys[pygame.K_a]:
+        player_pos.x -= speed * dt
+        dir = -1
+        moving = True
+    if keys[pygame.K_d]:
+        player_pos.x += speed * dt
+        dir = 1
+        moving = True
+
+    # press space to jump
+    grounded = player_pos.y > ground
+    if keys[pygame.K_SPACE] and grounded:
+        player_pos.y = ground - 1
+        vel_y = -10
+        grounded = False
+        started_falling = False
+        anim_time = 0
+
+    # gravity
+    player_pos.y += vel_y
+    vel_y += 0.3
+    if grounded:
+        vel_y = 0
+
+    # animation states
+    anim_idx = 0
+    looping = True
+    reversing = False
+    blend_frames = 20
+    if moving:
+        anim_idx = 1
+    if not grounded:
+        anim_idx = 3
+        looping = False
+
+    # falling animation
+    if vel_y > 0:
+        if not started_falling:
+            anim_time = 0
+        started_falling = True
+        reversing = True
+        blend_frames = 0
+
+    # reset animation timer whenever a new animation starts
+    if last_anim_idx != anim_idx:
+        anim_time = 0
+        last_anim_idx = anim_idx
+
+    anim_frame = skf_pg.time_frame(
+        anim_time, skellina.animations[anim_idx], reversing, looping
+    )
+    skellina.bones = skf_pg.animate(
+        skellina,
+        [skellina.animations[anim_idx]],
+        [anim_frame],
+        [blend_frames],
+    )
+
+    # make immutable edits to armature for construction
+    skellina_c = copy.deepcopy(skellina)
+
+    # point shoulder and head to mouse
+    skel_scale = 0.15
+    shoulder_target = bone("Left Shoulder Pad Target", skellina_c.bones)
+    looker = bone("Looker", skellina_c.bones)
+    raw_mouse = pygame.mouse.get_pos()
+    mouse = skf_pg.skf_py.Vec2(
+        -player_pos.x / skel_scale * dir + raw_mouse[0] / skel_scale * dir,
+        player_pos.y / skel_scale - raw_mouse[1] / skel_scale,
+    )
+    shoulder_target.pos = mouse
+    looker.pos = mouse
+
+    # flip shoulder IK constraint if looking the other way
+    left_shoulder = bone("Left Shoulder Pad", skellina_c.bones)
+    looking_back_left = dir == -1 and raw_mouse[0] > player_pos.x
+    looking_back_right = dir != -1 and raw_mouse[0] < player_pos.x
+    if looking_back_left or looking_back_right:
+        bone("Skull", skellina_c.bones).scale.y = -1
+        left_shoulder.ik_constraint = 1
+    else:
+        left_shoulder.ik_constraint = 2
+
+    # construct and draw skellina
+    props = skf_pg.construct(
+        skellina_c,
+        screen,
+        skf_pg.ConstructOptions(
+            player_pos,
+            scale=pygame.Vector2(skel_scale * dir, skel_scale),
+        ),
+    )
+    skf_pg.draw(props, skellina_c.styles, skellina_img, screen)
+    pygame.draw.circle(screen, (255, 0, 0), (raw_mouse), 5)
+
+    # Text
+    offset = 40
+    initial = 25
+    text("A - Move left", (25, initial))
+    text("D - Move right", (25, initial + offset))
+    text("Space - Jump", (25, initial + offset * 2))
+    text("Skellina will look at and reach for cursor", (25, initial + offset * 3))
+
+    pygame.display.flip()
+
+    dt = clock.tick(144) / 1000
+    anim_time += clock.get_time() / 1000
+
+pygame.quit()

skelform_pygame-0.2.3/tests/skf/.gitignore

@@ -0,0 +1,2 @@
+# Created by venv; see https://docs.python.org/3/library/venv.html
+*